import { getUserIdFromCookie } from '@/app/api/_helpers/session'
import { GROUP_MEMBERS_LIST_ORDER_SQL, isGroupLeaderRole } from '@/lib/groups/groupMemberRole'
import { isStreamLiveByLifecycleStatus } from '@/lib/streams/lifecycleStatus'
import { resolveMediaUrl } from '@/lib/media/resolveMediaUrl'
import { Suspense } from 'react'
import { getDb } from '@/server/db'
import FamilyDetailPageClient from './FamilyDetailPageClient'
import FamilyDetailSkeleton from './FamilyDetailSkeleton'

export const runtime = 'nodejs'
export const dynamic = 'force-dynamic'

type GroupRow = {
    id: string
    name: string
    avatar: string | null
    banner: string | null
    isVerified: number
    groupLevelExp: number
    createdAt: number
    updatedAt: number
    artistsCount: number
    membersCount: number
}

export default async function FamilyDetailPage({ params }: { params: { id: string } }) {
    const groupId = String(params?.id ?? '').trim()

    if (!groupId) {
        return (
            <Suspense fallback={<FamilyDetailSkeleton />}>
                <FamilyDetailPageClient groupId={groupId} initialData={null} />
            </Suspense>
        )
    }

    try {
        const db = await getDb()

        // 获取家族基本信息
        const group = await db.get<GroupRow>(
            `SELECT
                g.group_id AS id,
                g.name,
                g.avatar_url AS avatar,
                g.banner_url AS banner,
                g.is_verified AS isVerified,
                g.group_level_exp AS groupLevelExp,
                g.created_at AS createdAt,
                g.updated_at AS updatedAt,
                (SELECT COUNT(1) FROM user_groups ug WHERE ug.group_id = g.group_id AND ug.role = 'artist') AS artistsCount,
                (SELECT COUNT(1) FROM user_groups ug WHERE ug.group_id = g.group_id) AS membersCount
             FROM groups g WHERE g.group_id = ?`,
            [groupId]
        )

        if (!group) {
            return (
                <Suspense fallback={<FamilyDetailSkeleton />}>
                    <FamilyDetailPageClient groupId={groupId} initialData={null} />
                </Suspense>
            )
        }

        // 获取家族成员（艺人）列表
        const members = await db.all(
            `SELECT u.user_id AS id, u.display_name AS displayName, u.avatar_url AS avatar,
                    (SELECT COUNT(1) FROM user_actions f WHERE f.target_id = u.user_id AND f.action_type = 'follow') AS followersCount,
                    0 AS totalViewsCount, ug.role
             FROM users u
             INNER JOIN user_groups ug ON u.user_id = ug.user_id
             WHERE ug.group_id = ?
             ORDER BY ${GROUP_MEMBERS_LIST_ORDER_SQL}`,
            [groupId]
        ).catch(() => [])

        // 获取家族相关的直播
        const liveStreams = await db.all(
            `SELECT rs.room_id AS roomId, rs.room_id AS userId, NULLIF(TRIM(u.display_id), '') AS displayId, rs.title, 0 AS viewers,
                    rs.thumbnail_url AS thumbnail, rs.started_at AS startedAt, rs.stream_status AS streamStatus,
                    u.display_name AS displayName, u.avatar_url AS avatar
             FROM room_streams rs
             INNER JOIN users u ON rs.room_id = u.user_id
             INNER JOIN user_groups ug ON u.user_id = ug.user_id
             WHERE ug.group_id = ? AND 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 10`,
            [groupId]
        ).catch(() => [])

        const initialData = {
            id: group.id,
            name: group.name,
            avatar: resolveMediaUrl(group.avatar) || null,
            banner: resolveMediaUrl(group.banner) || null,
            description: null as string | null,
            isVerified: Boolean(group.isVerified),
            groupLevelExp: group.groupLevelExp ?? 0,
            artistsCount: group.artistsCount,
            membersCount: group.membersCount,
            createdAt: group.createdAt,
            updatedAt: group.updatedAt,
            members: (members || []).map((m: any) => ({
                id: m.id,
                displayName: m.displayName,
                avatar: resolveMediaUrl(m.avatar) || null,
                followersCount: m.followersCount,
                totalViewsCount: m.totalViewsCount,
                role: m.role,
            })),
            liveStreams: (liveStreams || []).map((ls: any) => ({
                roomId: ls.displayId || ls.roomId,
                userId: ls.userId,
                title: ls.title,
                viewers: ls.viewers,
                thumbnail: ls.thumbnail,
                startedAt: ls.startedAt,
                isLive: isStreamLiveByLifecycleStatus(ls.streamStatus),
                displayName: ls.displayName,
                avatar: resolveMediaUrl(ls.avatar) || null,
            })),
        }

        const currentUserId = await getUserIdFromCookie()
        let canManageMembers = false
        if (currentUserId) {
            const myMembership = await db.get<{ role: string }>(
                `SELECT role FROM user_groups WHERE group_id = ? AND user_id = ?`,
                [groupId, currentUserId]
            )
            canManageMembers = Boolean(myMembership && isGroupLeaderRole(myMembership.role))
        }

        return (
            <Suspense fallback={<FamilyDetailSkeleton />}>
                <FamilyDetailPageClient
                    groupId={groupId}
                    initialData={initialData}
                    currentUserId={currentUserId}
                    canManageMembers={canManageMembers}
                />
            </Suspense>
        )
    } catch (error) {
        console.error('Failed to fetch family data:', error)
        return (
            <Suspense fallback={<FamilyDetailSkeleton />}>
                <FamilyDetailPageClient groupId={groupId} initialData={null} />
            </Suspense>
        )
    }
}