import type { Metadata } from "next"
import { Suspense } from "react"
import { notFound } from "next/navigation"
import { after } from "next/server"
import { db } from "@/lib/db/index"
import {
    games,
    gameVersions,
    performanceEntries,
    gameComments,
    gamePlatformSupport,
    hardware,
    user,
} from "@/lib/db/schema"
import { and, desc, eq, sql } from "drizzle-orm"
import { isSyncStale, syncSteamGame } from "@/lib/steam/sync"
import { GamePageClient } from "./game-page-client"

// This page needs live data — skip static generation at build time
export const dynamic = "force-dynamic"

async function resolveGame(id: string) {
    const isNumeric = /^\d+$/.test(id)
    let game
    if (isNumeric) {
        const rows = await db
            .select()
            .from(games)
            .where(eq(games.steamAppId, Number(id)))
            .limit(1)
        game = rows[0]
    } else {
        const rows = await db
            .select()
            .from(games)
            .where(eq(games.id, id))
            .limit(1)
        game = rows[0]
    }
    return game
}

export async function generateMetadata({ params }: { params: Promise<{ id: string }> }): Promise<Metadata> {
    const { id } = await params
    const game = await resolveGame(id)

    if (!game) {
        return { title: "Game Not Found | DeckyVault" }
    }

    const description = game.description
        ? game.description.slice(0, 160)
        : `Find benchmarks, community presets, and performance settings for ${game.title} on Steam Deck.`

    return {
        title: `${game.title} - Benchmarks & Settings`,
        description,
        alternates: { canonical: `https://deckyvault.xyz/game/${game.id}` },
        openGraph: {
            title: `${game.title} - Benchmarks & Settings | DeckyVault`,
            description: game.description?.slice(0, 200) ?? `Benchmarks and settings for ${game.title}`,
            url: `https://deckyvault.xyz/game/${game.id}`,
            images: [{ url: `/game/${game.id}/opengraph-image`, width: 1200, height: 630 }],
            type: "website",
            siteName: "DeckyVault",
        },
        twitter: {
            card: "summary_large_image",
            title: `${game.title} - Benchmarks & Settings | DeckyVault`,
            description: game.description?.slice(0, 200) ?? `Benchmarks and settings for ${game.title}`,
            images: [`/game/${game.id}/opengraph-image`],
        },
    }
}

async function createGameStub(steamAppId: number) {
    const url = new URL("https://store.steampowered.com/api/appdetails/")
    url.searchParams.set("appids", String(steamAppId))
    url.searchParams.set("cc", "US")
    url.searchParams.set("l", "en")

    const res = await fetch(url.toString(), {
        headers: { Accept: "application/json" },
    })

    let title = `Steam App ${steamAppId}`
    let developer: string | null = null
    let publisher: string | null = null
    let genres: string[] | null = null
    let headerImage: string | null = null
    let capsuleImage: string | null = null
    let description: string | null = null

    if (res.ok) {
        const data = (await res.json()) as Record<
            string,
            {
                success: boolean
                data: {
                    type?: string
                    name: string
                    developers?: string[]
                    publishers?: string[]
                    genres?: { description: string }[]
                    header_image?: string
                    short_description?: string
                }
            }
        >
        const entry = data[String(steamAppId)]
        if (entry?.success && entry.data) {
            if (entry.data.type && entry.data.type !== "game") {
                notFound()
            }
            title = entry.data.name
            developer = entry.data.developers?.[0] ?? null
            publisher = entry.data.publishers?.[0] ?? null
            genres = entry.data.genres?.map((g) => g.description) ?? []
            headerImage = entry.data.header_image ?? null
            capsuleImage = `https://cdn.akamai.steamstatic.com/steam/apps/${steamAppId}/library_600x900.jpg`
            description = entry.data.short_description ?? null
        }
    }

    const [game] = await db
        .insert(games)
        .values({
            steamAppId,
            source: "steam",
            title,
            developer,
            publisher,
            genres,
            headerImage,
            capsuleImage,
            description,
            storeUrl: `https://store.steampowered.com/app/${steamAppId}`,
            lastSync: new Date(),
            syncStatus: "synced",
        })
        .returning()

    return game
}

export default async function GamePage({
    params,
    searchParams,
}: {
    params: Promise<{ id: string }>
    searchParams: Promise<{ sync?: string }>
}) {
    const { id } = await params
    const { sync } = await searchParams
    const isNumeric = /^\d+$/.test(id)
    const forceSync = sync === "1"

    // ── Resolve game ────────────────────────────────────────────────
    let game = await resolveGame(id)

    if (!game && isNumeric) {
        try {
            game = await createGameStub(Number(id))
        } catch (err) {
            console.error("Failed to auto-create game stub:", err)
        }
    }

    if (!game) {
        notFound()
    }

    // ── Fetch related data in parallel ──────────────────────────────
    const [
        benchmarkCount,
        presetCount,
        commentCount,
        platformSupport,
        presetRows,
    ] = await Promise.all([
        db
            .select({ count: sql<number>`count(*)::int` })
            .from(performanceEntries)
            .innerJoin(
                gameVersions,
                eq(performanceEntries.versionId, gameVersions.id),
            )
            .where(eq(gameVersions.gameId, game.id))
            .then((r) => r[0]?.count ?? 0),
        db
            .select({ count: sql<number>`count(*)::int` })
            .from(performanceEntries)
            .innerJoin(gameVersions, eq(performanceEntries.versionId, gameVersions.id))
            .where(
                and(
                    eq(gameVersions.gameId, game.id),
                    eq(performanceEntries.isRemoved, false),
                    sql`${performanceEntries.settingsJson} IS NOT NULL`,
                ),
            )
            .then((r) => r[0]?.count ?? 0),
        db
            .select({ count: sql<number>`count(*)::int` })
            .from(gameComments)
            .where(eq(gameComments.gameId, game.id))
            .then((r) => r[0]?.count ?? 0),
        db
            .select()
            .from(gamePlatformSupport)
            .where(eq(gamePlatformSupport.gameId, game.id))
            .then((r) => r),
        db
            .select({
                id: performanceEntries.id,
                hardwareSlug: performanceEntries.hardwareSlug,
                hardwareName: hardware.name,
                upvotes: performanceEntries.upvotes,
                settingsJson: performanceEntries.settingsJson,
                fpsAvg: performanceEntries.fpsAvg,
                fpsLow: performanceEntries.fpsLow,
                fpsHigh: performanceEntries.fpsHigh,
                fpsOnePercentLow: performanceEntries.fpsOnePercentLow,
                upscalerType: performanceEntries.upscalerType,
                upscalerVersion: performanceEntries.upscalerVersion,
                frameGenMethod: performanceEntries.frameGenMethod,
                protonVersion: performanceEntries.protonVersion,
                osVersion: performanceEntries.osVersion,
                createdAt: performanceEntries.createdAt,
                userId: performanceEntries.userId,
                userName: user.name,
                userImage: user.image,
                downvotes: performanceEntries.downvotes,
                launchOptions: performanceEntries.launchOptions,
                loadTimeSsd: performanceEntries.loadTimeSsd,
                loadTimeSd: performanceEntries.loadTimeSd,
                estimatedBatteryMin: performanceEntries.estimatedBatteryMin,
                customSystem: performanceEntries.customSystem,
                userNotes: performanceEntries.userNotes,
                verifiedAt: performanceEntries.verifiedAt,
                isPinned: performanceEntries.isPinned,
                pinnedAt: performanceEntries.pinnedAt,
            })
            .from(performanceEntries)
            .innerJoin(gameVersions, eq(performanceEntries.versionId, gameVersions.id))
            .innerJoin(hardware, eq(performanceEntries.hardwareSlug, hardware.slug))
            .innerJoin(user, eq(performanceEntries.userId, user.id))
            .where(
                and(
                    eq(gameVersions.gameId, game.id),
                    eq(performanceEntries.isRemoved, false),
                    sql`${performanceEntries.settingsJson} IS NOT NULL`,
                ),
            )
            .orderBy(desc(performanceEntries.isPinned), desc(performanceEntries.upvotes)),
    ])

    // ── Sync logic: force or stale-while-revalidate ─────────────────
    const shouldSync =
        game.source === "steam" &&
        game.steamAppId &&
        (forceSync || isSyncStale(game.lastSync))

    if (shouldSync) {
        after(async () => {
            await syncSteamGame(game.steamAppId!)
        })
    }

    // Serialize for client component (Dates → strings)
    const serializedGame = {
        id: game.id,
        steamAppId: game.steamAppId,
        title: game.title,
        description: game.description,
        developer: game.developer,
        publisher: game.publisher,
        genres: game.genres,
        headerImage: game.headerImage,
        capsuleImage: game.capsuleImage,
        storeUrl: game.storeUrl,
        source: game.source,
        lastSync: game.lastSync ? game.lastSync.toISOString() : null,
        syncStatus: game.syncStatus,
        createdAt: game.createdAt.toISOString(),
        systemRequirements: game.systemRequirements,
        metacriticScore: game.metacriticScore,
        metacriticUrl: game.metacriticUrl,
        recommendationsTotal: game.recommendationsTotal,
        priceCurrent: game.priceCurrent,
        priceInitial: game.priceInitial,
        priceCurrency: game.priceCurrency,
        isFree: game.isFree,
        releaseDate: game.releaseDate,
        categories: game.categories,
        platforms: game.platforms,
    }

    const serializedPresets = presetRows.map((p) => ({
        id: p.id,
        gameId: game.id,
        hardwareSlug: p.hardwareSlug,
        hardwareName: p.hardwareName,
        upvotes: p.upvotes,
        settingsCount: Array.isArray(p.settingsJson)
            ? p.settingsJson.reduce(
                  (sum: number, cat: { settings: unknown[] }) =>
                      sum + cat.settings.length,
                  0,
              )
            : 0,
        fpsAvg: p.fpsAvg,
        fpsLow: p.fpsLow,
        fpsHigh: p.fpsHigh,
        fpsOnePercentLow: p.fpsOnePercentLow ?? null,
        upscalerType: p.upscalerType,
        upscalerVersion: p.upscalerVersion,
        frameGenMethod: p.frameGenMethod,
        protonVersion: p.protonVersion,
        osVersion: p.osVersion,
        createdAt: p.createdAt.toISOString(),
        settingsJson: p.settingsJson,
        launchOptions: p.launchOptions,
        loadTimeSsd: p.loadTimeSsd ?? null,
        loadTimeSd: p.loadTimeSd ?? null,
        estimatedBatteryMin: p.estimatedBatteryMin ?? null,
        customSystem: p.customSystem ?? false,
        userNotes: p.userNotes,
        userId: p.userId,
        userName: p.userName,
        userImage: p.userImage,
        downvotes: p.downvotes,
        verifiedAt: p.verifiedAt ? p.verifiedAt.toISOString() : null,
        isPinned: p.isPinned,
        pinnedAt: p.pinnedAt ? p.pinnedAt.toISOString() : null,
    }))

    return (
        <>
            <script
                type="application/ld+json"
                dangerouslySetInnerHTML={{
                    __html: JSON.stringify({
                        "@context": "https://schema.org",
                        "@type": "VideoGame",
                        name: game.title,
                        ...(game.developer && { developer: { "@type": "Organization", name: game.developer } }),
                        ...(game.genres && game.genres.length > 0 && { genre: game.genres }),
                        ...(game.headerImage && { image: game.headerImage }),
                        url: `https://deckyvault.xyz/game/${game.id}`,
                        applicationCategory: "Game",
                        operatingSystem: "SteamOS",
                        ...(game.storeUrl && { offers: { "@type": "Offer", url: game.storeUrl } }),
                    }),
                }}
            />
            <Suspense fallback={<div className="min-h-screen" />}>
                <GamePageClient
                    game={serializedGame}
                    counts={{
                        benchmarks: benchmarkCount,
                        presets: presetCount,
                        comments: commentCount,
                    }}
                    platformSupport={platformSupport}
                    presets={serializedPresets}
                    gameId={game.id}
                />
            </Suspense>
        </>
    )
}