import { parseRoomStreamCategory } from '@/lib/streams/roomStreamCategory'
import { isStreamPayloadLive } from '@/lib/streams/wsStreams'
import type { StreamStatusPayload } from '@/lib/streams/streamStatusPayload'

export type StreamCatalogEntry = {
    roomId: string
    publicId: string
    streamerName: string
    title: string
    category: string | null
    thumbnail?: string
    src?: string
    avatar?: string
    likeCount: number
}

export type PopularStreamItem = {
    roomId: string
    id: string
    streamerName: string
    title: string
    category: string
    viewerCount: number
    thumbnail?: string
    src?: string
    avatar?: string
    isLive: boolean
    startedAt?: number | null
}

export function buildPopularLiveStreams(
    catalog: StreamCatalogEntry[],
    statusByRoomId: ReadonlyMap<string, StreamStatusPayload>,
    viewersByRoomId: ReadonlyMap<string, number>,
    limit: number,
    defaultCategoryLabel: string
): PopularStreamItem[] {
    const liveItems: PopularStreamItem[] = []

    for (const entry of catalog) {
        const status = statusByRoomId.get(entry.roomId)
        if (!isStreamPayloadLive(status)) continue

        const parsed = parseRoomStreamCategory(entry.category)
        liveItems.push({
            roomId: entry.roomId,
            id: entry.publicId,
            streamerName: entry.streamerName,
            title: entry.title,
            category: parsed?.groupId ?? defaultCategoryLabel,
            viewerCount: viewersByRoomId.get(entry.roomId) ?? 0,
            thumbnail: entry.thumbnail,
            src: entry.src,
            avatar: entry.avatar,
            isLive: true,
            startedAt: status?.startedAt ?? null,
        })
    }

    const catalogByRoom = new Map(catalog.map((c) => [c.roomId, c]))

    liveItems.sort((a, b) => {
        const likesA = catalogByRoom.get(a.roomId)?.likeCount ?? 0
        const likesB = catalogByRoom.get(b.roomId)?.likeCount ?? 0
        if (likesB !== likesA) return likesB - likesA
        if (b.viewerCount !== a.viewerCount) return b.viewerCount - a.viewerCount
        return (b.startedAt ?? 0) - (a.startedAt ?? 0)
    })

    return liveItems.slice(0, Math.max(0, limit))
}