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

export async function GET(req: NextRequest) {
  try {
    const session = await auth();
    if (!session?.user) {
      return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
    }
    const { searchParams } = new URL(req.url);
    const status = searchParams.get("status");
    const templateId = searchParams.get("templateId");

    const isAdmin = session.user.role === "admin";
    const userId = session.user.id;

    const evaluations = await prisma.evaluation.findMany({
      where: {
        ...(status && { status }),
        ...(templateId && { templateId }),
        ...(!isAdmin && {
          OR: [
            { evaluatorId: userId },
            { sharedWith: { some: { userId } } },
            { isPublic: true },
          ],
        }),
      },
      include: {
        template: { include: { dimensions: { orderBy: { orderIndex: "asc" } } } },
        dimensionScores: { include: { dimension: true } },
      },
      orderBy: { evaluationDate: "desc" },
    });

    return NextResponse.json(evaluations);
  } catch (e) {
    console.error(e);
    return NextResponse.json({ error: "Failed to fetch evaluations" }, { status: 500 });
  }
}

export async function POST(req: NextRequest) {
  try {
    const session = await auth();
    if (!session?.user) {
      return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
    }
    const body = await req.json();
    const { candidateName, candidateRole, candidateTeam, evaluationDate, templateId } = body;

    if (!candidateName || !candidateRole || !evaluationDate || !templateId) {
      return NextResponse.json(
        { error: "Missing required fields: candidateName, candidateRole, evaluationDate, templateId" },
        { status: 400 }
      );
    }

    const evaluatorName = session.user.name || session.user.email || "Évaluateur";

    const template = await prisma.template.findUnique({
      where: { id: templateId },
      include: { dimensions: { orderBy: { orderIndex: "asc" } } },
    });
    if (!template) {
      return NextResponse.json({ error: "Template not found" }, { status: 404 });
    }

    const evaluation = await prisma.evaluation.create({
      data: {
        candidateName,
        candidateRole,
        candidateTeam: candidateTeam || null,
        evaluatorName,
        evaluatorId: session.user.id,
        evaluationDate: new Date(evaluationDate),
        templateId,
        status: "draft",
      },
      include: {
        template: { include: { dimensions: { orderBy: { orderIndex: "asc" } } } },
        dimensionScores: { include: { dimension: true } },
      },
    });

    // Create empty dimension scores for each template dimension
    for (const dim of template.dimensions) {
      await prisma.dimensionScore.create({
        data: {
          evaluationId: evaluation.id,
          dimensionId: dim.id,
        },
      });
    }

    const updated = await prisma.evaluation.findUnique({
      where: { id: evaluation.id },
      include: {
        template: { include: { dimensions: { orderBy: { orderIndex: "asc" } } } },
        dimensionScores: { include: { dimension: true } },
      },
    });

    return NextResponse.json(updated);
  } catch (e) {
    console.error(e);
    return NextResponse.json({ error: "Failed to create evaluation" }, { status: 500 });
  }
}