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

type Params = { params: Promise<{ id: string }> };

/** Student detail — profile + course enrollments + exam marks history. */
export async function GET(_req: Request, { params }: Params) {
  const session = await requireCampusInstitution();
  if (!session || !session.institutionId) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const { id } = await params;
  const student = await prisma.cuStudent.findFirst({
    where: { id: Number(id), institutionId: session.institutionId },
    include: {
      program: { select: { id: true, name: true, nameBn: true, gradeScale: true, degreeLevel: true, department: true, faculty: true } },
      currentTerm: { select: { id: true, name: true, nameBn: true } },
      enrollments: {
        orderBy: [{ id: "desc" }],
        include: {
          offering: {
            select: {
              id: true, sessionYear: true, section: true,
              course: { select: { id: true, code: true, name: true, nameBn: true, credits: true, courseType: true, term: { select: { name: true, nameBn: true } } } },
              staff: { select: { name: true, nameBn: true } },
            },
          },
        },
      },
      marks: {
        include: {
          schedule: {
            select: {
              id: true, fullMarks: true, passMarks: true, examDate: true,
              course: { select: { id: true, code: true, name: true, nameBn: true, credits: true } },
              exam: { select: { id: true, name: true, examType: true, resultPublished: true, term: { select: { name: true, nameBn: true } } } },
            },
          },
        },
      },
    },
  });
  if (!student) return NextResponse.json({ error: "Not found" }, { status: 404 });

  return NextResponse.json({ student });
}

/** Update a student (same fields as create, all optional). */
export async function PATCH(req: Request, { params }: Params) {
  const session = await requireCampusInstitution();
  if (!session || !session.institutionId) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const { id } = await params;
  const student = await prisma.cuStudent.findFirst({
    where: { id: Number(id), institutionId: session.institutionId },
    select: { id: true, studentIdNo: true, programId: true },
  });
  if (!student) return NextResponse.json({ error: "Not found" }, { status: 404 });

  try {
    const body = await req.json();
    const data: Record<string, unknown> = {};

    if (body.studentIdNo !== undefined) {
      const studentIdNo = String(body.studentIdNo).trim();
      if (!studentIdNo) return NextResponse.json({ error: "Missing fields" }, { status: 400 });
      if (studentIdNo !== student.studentIdNo) {
        const dup = await prisma.cuStudent.findFirst({
          where: { institutionId: session.institutionId, studentIdNo, id: { not: student.id } },
          select: { id: true },
        });
        if (dup) return NextResponse.json({ error: "ID_EXISTS" }, { status: 409 });
      }
      data.studentIdNo = studentIdNo;
    }
    let programId = student.programId;
    if (body.programId !== undefined) {
      const pid = Number(body.programId);
      const program = await prisma.cuProgram.findFirst({
        where: { id: pid, institutionId: session.institutionId },
        select: { id: true },
      });
      if (!program) return NextResponse.json({ error: "Invalid program" }, { status: 400 });
      programId = program.id;
      data.programId = program.id;
    }
    if (body.currentTermId !== undefined) {
      const termId = Number(body.currentTermId);
      if (Number.isFinite(termId) && termId > 0) {
        const term = await prisma.cuTerm.findFirst({
          where: { id: termId, programId },
          select: { id: true },
        });
        if (!term) return NextResponse.json({ error: "Invalid term" }, { status: 400 });
        data.currentTermId = term.id;
      } else {
        data.currentTermId = null;
      }
    }
    if (body.name !== undefined) data.name = String(body.name).trim();
    if (body.nameBn !== undefined) data.nameBn = String(body.nameBn).trim() || null;
    if (body.gender !== undefined) data.gender = body.gender === "FEMALE" ? "FEMALE" : "MALE";
    for (const key of ["guardianName", "guardianPhone", "phone", "email", "address", "boardRollNo", "registrationNo", "sessionYear", "status", "note"] as const) {
      if (body[key] !== undefined) data[key] = String(body[key]).trim() || null;
    }
    for (const key of ["dob", "admissionDate"] as const) {
      if (body[key] !== undefined) {
        const s = String(body[key]).slice(0, 10);
        data[key] = /^\d{4}-\d{2}-\d{2}$/.test(s) ? new Date(`${s}T00:00:00Z`) : null;
      }
    }

    const updated = await prisma.cuStudent.update({
      where: { id: student.id },
      data,
      include: {
        program: { select: { id: true, name: true, nameBn: true, gradeScale: true } },
        currentTerm: { select: { id: true, name: true, nameBn: true } },
      },
    });
    return NextResponse.json({ student: updated });
  } catch {
    return NextResponse.json({ error: "Could not update student" }, { status: 500 });
  }
}

/** Delete a student and their marks/enrollments. */
export async function DELETE(_req: Request, { params }: Params) {
  const session = await requireCampusInstitution();
  if (!session || !session.institutionId) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const { id } = await params;
  const student = await prisma.cuStudent.findFirst({
    where: { id: Number(id), institutionId: session.institutionId },
    select: { id: true },
  });
  if (!student) return NextResponse.json({ error: "Not found" }, { status: 404 });

  try {
    await prisma.cuStudent.delete({ where: { id: student.id } });
    return NextResponse.json({ ok: true });
  } catch {
    return NextResponse.json({ error: "Could not delete student" }, { status: 500 });
  }
}