import { NextRequest, NextResponse } from 'next/server'
import { getDb } from '@/server/db'
import { isStreamLiveByLifecycleStatus } from '@/lib/streams/lifecycleStatus'
import {
    parseRoomStreamCategory,
    roomStreamCategoryToTagIds,
} from '@/lib/streams/roomStreamCategory'
import { formatDateTime } from '@/utils/formatDate'

function formatStreamStartTime(raw: unknown): string | undefined {
    if (raw == null || raw === '') return undefined
    const n = Number(raw)
    if (Number.isFinite(n)) {
        const ms = n < 1e12 ? n * 1000 : n
        return formatDateTime(new Date(ms).toISOString())
    }
    try {
        return formatDateTime(String(raw))
    } catch {
        return String(raw)
    }
}

export async function GET(request: NextRequest) {
    try {
        const db = await getDb()
        const searchParams = request.nextUrl.searchParams
        const limit = parseInt(searchParams.get('limit') || '12', 10)
        const offset = parseInt(searchParams.get('offset') || '0', 10)

        const streams = await db.all<{
            roomId: string
            userId: string
            title: string
            viewers: number
            thumbnail: string | null
            displayName: string
            displayId: string | null
            avatar: string | null
            category: string | null
            src: string | null
            streamStatus: string | null
            startedAt: number | string | null
        }>(
            `SELECT 
                rs.room_id AS roomId,
                rs.room_id AS userId,
                rs.title,
                0 AS viewers,
                rs.thumbnail_url AS thumbnail,
                rs.stream_token AS src,
                u.display_name AS displayName,
                u.display_id AS displayId,
                u.avatar_url AS avatar,
                rs.category,
                rs.stream_status AS streamStatus,
                rs.started_at AS startedAt
             FROM room_streams rs
             INNER JOIN users u ON rs.room_id = u.user_id
             WHERE rs.stream_status IN ('ready', 'initializing', 'connected', 'streaming', 'live', 'live-inprogress', 'reconnected')
             ORDER BY (SELECT COUNT(1) FROM room_stream_likes l WHERE l.room_id = rs.room_id) DESC,
                      COALESCE(rs.started_at, rs.created_at) DESC
             LIMIT ? OFFSET ?`,
            [limit, offset]
        )

        const result = (streams ?? []).map((s) => {
            const parsed = parseRoomStreamCategory(s.category)
            const category = parsed?.groupId ?? 'general'
            const tags = roomStreamCategoryToTagIds(s.category)
            const startTime = formatStreamStartTime(s.startedAt)
            const thumb = String(s.thumbnail ?? '').trim()
            const src = String(s.src ?? '').trim()
            return {
                id: String(s.displayId || '').trim() || s.roomId,
                streamerName: s.displayName,
                title: s.title,
                category,
                viewerCount: Number(s.viewers ?? 0),
                thumbnail: thumb || undefined,
                src: src || undefined,
                isLive: isStreamLiveByLifecycleStatus(s.streamStatus),
                avatar: s.avatar || undefined,
                startTime,
                tags: tags.length > 0 ? tags : undefined,
            }
        })

        return NextResponse.json({
            ok: true,
            streams: result,
            total: result.length,
        })
    } catch (error: any) {
        console.error('Failed to fetch popular streams:', error)
        return NextResponse.json(
            { ok: false, message: error?.message || 'Failed to fetch popular streams' },
            { status: 500 }
        )
    }
}