import { NextResponse } from "next/server";
import { auth } from "@/lib/auth";
import { prisma } from "@/lib/prisma";

export async function GET() {
  const session = await auth();
  if (!session?.user?.id) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });

  const userId = session.user.id;

  const [chatCount, allMessages] = await Promise.all([
    prisma.chat.count({ where: { userId } }),
    prisma.message.findMany({
      where: { chat: { userId } },
      select: {
        role: true,
        promptTokens: true,
        tokens: true,
        evalDurationMs: true,
        totalDurationMs: true,
        chat: { select: { model: true } },
      },
    }),
  ]);

  let totalMessages = 0;
  let userMessages = 0;
  let assistantMessages = 0;
  let totalPromptTokens = 0;
  let totalCompletionTokens = 0;
  let totalEvalMs = 0;
  let totalDurationMs = 0;

  const perModelMap = new Map<
    string,
    {
      messages: number;
      promptTokens: number;
      completionTokens: number;
      evalMs: number;
      totalMs: number;
    }
  >();

  for (const m of allMessages) {
    totalMessages += 1;
    if (m.role === "user") userMessages += 1;
    if (m.role === "assistant") assistantMessages += 1;

    if (m.role !== "assistant") continue;

    const model = m.chat.model;
    if (!perModelMap.has(model)) {
      perModelMap.set(model, {
        messages: 0,
        promptTokens: 0,
        completionTokens: 0,
        evalMs: 0,
        totalMs: 0,
      });
    }
    const bucket = perModelMap.get(model)!;
    bucket.messages += 1;
    if (m.promptTokens) {
      bucket.promptTokens += m.promptTokens;
      totalPromptTokens += m.promptTokens;
    }
    if (m.tokens) {
      bucket.completionTokens += m.tokens;
      totalCompletionTokens += m.tokens;
    }
    if (m.evalDurationMs) {
      bucket.evalMs += m.evalDurationMs;
      totalEvalMs += m.evalDurationMs;
    }
    if (m.totalDurationMs) {
      bucket.totalMs += m.totalDurationMs;
      totalDurationMs += m.totalDurationMs;
    }
  }

  const perModel = [...perModelMap.entries()]
    .map(([model, b]) => ({
      model,
      messages: b.messages,
      promptTokens: b.promptTokens,
      completionTokens: b.completionTokens,
      totalEvalSeconds: Math.round(b.evalMs / 100) / 10,
      totalDurationSeconds: Math.round(b.totalMs / 100) / 10,
      avgTokensPerSecond:
        b.evalMs > 0 ? Math.round((b.completionTokens / (b.evalMs / 1000)) * 10) / 10 : 0,
    }))
    .sort((a, b) => b.completionTokens - a.completionTokens);

  const overallAvgTokensPerSecond =
    totalEvalMs > 0 ? Math.round((totalCompletionTokens / (totalEvalMs / 1000)) * 10) / 10 : 0;

  return NextResponse.json({
    totals: {
      chats: chatCount,
      messages: totalMessages,
      userMessages,
      assistantMessages,
      promptTokens: totalPromptTokens,
      completionTokens: totalCompletionTokens,
      totalEvalSeconds: Math.round(totalEvalMs / 100) / 10,
      totalDurationSeconds: Math.round(totalDurationMs / 100) / 10,
      avgTokensPerSecond: overallAvgTokensPerSecond,
    },
    perModel,
  });
}