import { NextResponse } from "next/server";
import { auth } from "@/lib/auth";
import { fetchUserStats, refreshAccessToken } from "@/lib/tiktok";
import { prisma } from "@/lib/prisma";

export async function GET() {
    const session = await auth();

    if (!session?.user) {
        return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
    }

    const userId = (session.user as { id?: string }).id;
    if (!userId) {
        return NextResponse.json({ error: "Session error" }, { status: 401 });
    }

    if (process.env.NODE_ENV === "development") {
        const user = await prisma.user.findUnique({ where: { id: userId } });
        return NextResponse.json({
            followers: 124,
            likes: 856,
            videoCount: 1,
            views: 3432,
            profileViews: 287,
            displayName: "CrowMate studio",
            avatarUrl: "",
            plan: (user as any)?.plan ?? "free",
        });
    }

    const tokenRecord = await prisma.tikTokToken.findUnique({ where: { userId } });

    if (!tokenRecord) {
        return NextResponse.json({ error: "Not connected" }, { status: 404 });
    }

    let { accessToken, refreshToken, openId, expiresAt } = tokenRecord;

    if (expiresAt.getTime() - Date.now() < 60_000) {
        try {
            const refreshed = await refreshAccessToken(refreshToken);
            await prisma.tikTokToken.update({
                where: { userId },
                data: {
                    accessToken: refreshed.access_token,
                    refreshToken: refreshed.refresh_token,
                    expiresAt: new Date(Date.now() + refreshed.expires_in * 1000),
                },
            });

            accessToken = refreshed.access_token;
        } catch (err) {
            console.error("[TikTok stats refresh error]", err);
            return NextResponse.json({ error: "Token refresh failed" }, { status: 401 });
        }
    }

    try {
        const stats = await fetchUserStats(accessToken, openId);
        
        try {
            let account = await prisma.trackedAccount.findFirst({
                where: { userId, platform: "tiktok" },
            });
            if (!account) {
                account = await prisma.trackedAccount.create({
                    data: {
                        userId,
                        platform:  "tiktok",
                        username:  stats.displayName ?? openId,
                        accountId: openId,
                    },
                });
            }
            await prisma.snapshot.create({
                data: {
                    accountId:  account.id,
                    followers:  stats.followers  ?? 0,
                    likes:      stats.likes      ?? 0,
                    videoCount: stats.videoCount ?? 0,
                    views:      stats.views      ?? 0,
                },
            });
        } catch (snapshotErr) {
            console.error("[TikTok snapshot save error]", snapshotErr);
        }
        const user = await prisma.user.findUnique({ where: { id: userId } });
        return NextResponse.json({ ...stats, plan: (user as any)?.plan ?? "free" });
    } catch (err) {
        console.error("[TikTok stats fetch error]", err);
        return NextResponse.json({ error: "Failed to fetch stats" }, { status: 500 });
    }
}