"use server";

import { revalidatePath } from "next/cache";
import { redirect } from "next/navigation";
import { prisma } from "@/lib/db";
import { authorizeTeacher, canManageOwnedResource } from "@/lib/auth/rbac";
import { recordAudit } from "@/lib/audit";
import {
  attendanceMarkSchema,
  attendanceSessionSchema,
  classroomSchema,
  fieldErrors,
} from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import type { SessionUser } from "@/lib/auth/session";
import type { AttendanceStatus } from "@prisma/client";

/**
 * Classroom and attendance mutations.
 *
 * `createClassroomAction` and `joinClassroomAction` live in `actions/courses.ts`
 * (they are part of the enrolment flow); this module owns everything else about
 * managing a class and marking attendance.
 */

function messageOf(error: unknown, fallback: string): string {
  if (error instanceof Error) return error.message;
  return fallback;
}

/** Confirm the actor teaches (or administers) a class. */
async function assertClassManageable(classId: string): Promise<SessionUser> {
  const actor = await authorizeTeacher();
  const classroom = await prisma.classroom.findUnique({
    where: { id: classId },
    select: { teacherId: true },
  });
  if (!classroom) throw new Error("Kelas tidak ditemukan.");
  if (!canManageOwnedResource(actor, classroom.teacherId)) {
    throw new Error("Kamu tidak berhak mengelola kelas ini.");
  }
  return actor;
}

async function assertSessionManageable(sessionId: string): Promise<SessionUser> {
  const actor = await authorizeTeacher();
  const session = await prisma.attendanceSession.findUnique({
    where: { id: sessionId },
    select: { classroom: { select: { teacherId: true } } },
  });
  if (!session) throw new Error("Sesi absensi tidak ditemukan.");
  if (!canManageOwnedResource(actor, session.classroom.teacherId)) {
    throw new Error("Kamu tidak berhak mengubah absensi kelas ini.");
  }
  return actor;
}

// ---------------------------------------------------------------------------
// Classrooms
// ---------------------------------------------------------------------------

export async function updateClassroomAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const parsed = classroomSchema.safeParse({
    name: formData.get("name"),
    description: formData.get("description") ?? "",
    academicYear: formData.get("academicYear"),
    gradeLevel: formData.get("gradeLevel") ?? "",
    room: formData.get("room") ?? "",
  });

  if (!parsed.success) {
    return actionError("Periksa kembali data kelas.", fieldErrors(parsed.error));
  }

  const data = parsed.data;

  await prisma.classroom.update({
    where: { id: classId },
    data: {
      name: data.name,
      description: data.description || null,
      academicYear: data.academicYear,
      gradeLevel: data.gradeLevel || null,
      room: data.room || null,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "CLASSROOM_UPDATED",
    entity: "Classroom",
    entityId: classId,
  });

  revalidatePath("/dashboard/classes");
  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess("Data kelas diperbarui.");
}

/** Archive instead of deleting — attendance history must survive. */
export async function archiveClassroomAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const restore = formData.get("restore") === "true";

  await prisma.classroom.update({
    where: { id: classId },
    data: { archivedAt: restore ? null : new Date() },
  });

  await recordAudit({
    actorId: actor.id,
    action: restore ? "CLASSROOM_RESTORED" : "CLASSROOM_ARCHIVED",
    entity: "Classroom",
    entityId: classId,
  });

  revalidatePath("/dashboard/classes");
  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess(restore ? "Kelas diaktifkan kembali." : "Kelas diarsipkan.");
}

export async function rotateJoinCodeAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
  let joinCode = "";
  for (let attempt = 0; attempt < 40; attempt += 1) {
    joinCode = Array.from(
      { length: 6 },
      () => alphabet[Math.floor(Math.random() * alphabet.length)]
    ).join("");
    const clash = await prisma.classroom.findUnique({
      where: { joinCode },
      select: { id: true },
    });
    if (!clash) break;
    joinCode = "";
  }

  if (!joinCode) return actionError("Gagal membuat kode baru. Coba lagi.");

  await prisma.classroom.update({ where: { id: classId }, data: { joinCode } });

  await recordAudit({
    actorId: actor.id,
    action: "CLASSROOM_JOIN_CODE_ROTATED",
    entity: "Classroom",
    entityId: classId,
  });

  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess(`Kode gabung baru: ${joinCode}`);
}

/** Enrol an existing student into the class (and its courses). */
export async function addStudentToClassAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  const studentId = String(formData.get("studentId") ?? "");

  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const student = await prisma.user.findUnique({
    where: { id: studentId },
    select: { id: true, fullName: true, role: true },
  });
  if (!student || student.role !== "STUDENT") return actionError("Siswa tidak ditemukan.");

  const courses = await prisma.course.findMany({
    where: { classroomId: classId },
    select: { id: true },
  });

  await prisma.$transaction(async (tx) => {
    await tx.classEnrollment.upsert({
      where: { classId_studentId: { classId, studentId } },
      create: { classId, studentId, status: "ACTIVE" },
      update: { status: "ACTIVE", droppedAt: null },
    });

    for (const course of courses) {
      await tx.courseEnrollment.upsert({
        where: { courseId_studentId: { courseId: course.id, studentId } },
        create: { courseId: course.id, studentId, status: "ACTIVE" },
        update: { status: "ACTIVE" },
      });
    }
  });

  await recordAudit({
    actorId: actor.id,
    action: "CLASS_STUDENT_ADDED",
    entity: "Classroom",
    entityId: classId,
    metadata: { studentId },
  });

  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess(`${student.fullName} ditambahkan ke kelas.`);
}

/** Enrol many students at once, e.g. a whole grade level. */
export async function bulkAddStudentsAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  const studentIds = formData.getAll("studentIds").map(String);

  if (studentIds.length === 0) return actionError("Pilih setidaknya satu siswa.");

  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const courses = await prisma.course.findMany({
    where: { classroomId: classId },
    select: { id: true },
  });

  // The ids come straight from the request, so keep only real students. Without
  // this a teacher could enrol a colleague or an administrator into the class,
  // which addStudentToClassAction already refuses to do one at a time.
  const validStudents = await prisma.user.findMany({
    where: { id: { in: studentIds }, role: "STUDENT" },
    select: { id: true },
  });
  const validIds = validStudents.map((student) => student.id);
  if (validIds.length === 0) {
    return actionError("Tidak ada siswa valid yang bisa ditambahkan.");
  }

  await prisma.$transaction(async (tx) => {
    for (const studentId of validIds) {
      await tx.classEnrollment.upsert({
        where: { classId_studentId: { classId, studentId } },
        create: { classId, studentId, status: "ACTIVE" },
        update: { status: "ACTIVE", droppedAt: null },
      });

      for (const course of courses) {
        await tx.courseEnrollment.upsert({
          where: { courseId_studentId: { courseId: course.id, studentId } },
          create: { courseId: course.id, studentId, status: "ACTIVE" },
          update: { status: "ACTIVE" },
        });
      }
    }
  });

  await recordAudit({
    actorId: actor.id,
    action: "CLASS_STUDENTS_BULK_ADDED",
    entity: "Classroom",
    entityId: classId,
    metadata: { count: validIds.length, requested: studentIds.length },
  });

  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess(`${validIds.length} siswa ditambahkan ke kelas.`);
}

/** Reassign a class to another teacher (admin only). */
export async function transferClassroomAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  const teacherId = String(formData.get("teacherId") ?? "");

  let actor: SessionUser;
  try {
    actor = await authorizeTeacher();
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  if (actor.role !== "ADMIN") {
    return actionError("Hanya administrator yang dapat memindahkan kelas.");
  }

  const teacher = await prisma.user.findFirst({
    where: { id: teacherId, role: { in: ["TEACHER", "ADMIN"] } },
    select: { id: true, fullName: true },
  });
  if (!teacher) return actionError("Guru tidak ditemukan.");

  await prisma.classroom.update({ where: { id: classId }, data: { teacherId } });

  await recordAudit({
    actorId: actor.id,
    action: "CLASSROOM_TRANSFERRED",
    entity: "Classroom",
    entityId: classId,
    metadata: { teacherId },
  });

  revalidatePath(`/dashboard/classes/${classId}`);
  return actionSuccess(`Kelas dipindahkan ke ${teacher.fullName}.`);
}

// ---------------------------------------------------------------------------
// Attendance
// ---------------------------------------------------------------------------

export async function createAttendanceSessionAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const classId = String(formData.get("classId") ?? "");
  let actor: SessionUser;
  try {
    actor = await assertClassManageable(classId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const parsed = attendanceSessionSchema.safeParse({
    classId,
    courseId: formData.get("courseId") ?? "",
    date: formData.get("date"),
    topic: formData.get("topic") ?? "",
    note: formData.get("note") ?? "",
  });

  if (!parsed.success) {
    return actionError("Periksa kembali data sesi.", fieldErrors(parsed.error));
  }

  const data = parsed.data;

  // One session per class per day — enforced by a unique constraint.
  const existing = await prisma.attendanceSession.findUnique({
    where: { classId_date: { classId, date: data.date } },
    select: { id: true },
  });
  if (existing) {
    revalidatePath("/dashboard/attendance");
    return actionSuccess("Sesi absensi untuk tanggal ini sudah ada.");
  }

  const session = await prisma.attendanceSession.create({
    data: {
      classId,
      courseId: data.courseId || null,
      date: data.date,
      topic: data.topic || null,
      note: data.note || null,
      createdById: actor.id,
    },
    select: { id: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "ATTENDANCE_SESSION_CREATED",
    entity: "AttendanceSession",
    entityId: session.id,
    metadata: { classId, date: data.date.toISOString() },
  });

  revalidatePath("/dashboard/attendance");
  revalidatePath(`/dashboard/classes/${classId}`);
  redirect(`/dashboard/attendance/${session.id}`);
}

/** Save every student's status for a session in one transaction. */
export async function markAttendanceAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const sessionId = String(formData.get("sessionId") ?? "");

  let actor: SessionUser;
  try {
    actor = await assertSessionManageable(sessionId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const session = await prisma.attendanceSession.findUnique({
    where: { id: sessionId },
    select: { id: true, classId: true },
  });
  if (!session) return actionError("Sesi tidak ditemukan.");

  // Rows arrive as `status_<studentId>` / `note_<studentId>`.
  const enrolled = await prisma.classEnrollment.findMany({
    where: { classId: session.classId, status: "ACTIVE" },
    select: { studentId: true },
  });

  const records = enrolled.flatMap(({ studentId }) => {
    const rawStatus = formData.get(`status_${studentId}`);
    if (typeof rawStatus !== "string" || !rawStatus) return [];

    const note = formData.get(`note_${studentId}`);
    return [
      {
        studentId,
        status: rawStatus as AttendanceStatus,
        note: typeof note === "string" && note.trim() ? note.trim() : undefined,
      },
    ];
  });

  const parsed = attendanceMarkSchema.safeParse({ sessionId, records });
  if (!parsed.success) {
    return actionError("Periksa kembali data absensi.", fieldErrors(parsed.error));
  }

  await prisma.$transaction(async (tx) => {
    for (const record of parsed.data.records) {
      await tx.attendanceRecord.upsert({
        where: {
          sessionId_studentId: { sessionId, studentId: record.studentId },
        },
        create: {
          sessionId,
          studentId: record.studentId,
          status: record.status,
          note: record.note || null,
        },
        update: { status: record.status, note: record.note || null },
      });
    }
  });

  await recordAudit({
    actorId: actor.id,
    action: "ATTENDANCE_MARKED",
    entity: "AttendanceSession",
    entityId: sessionId,
    metadata: { marked: parsed.data.records.length },
  });

  revalidatePath("/dashboard/attendance");
  revalidatePath(`/dashboard/attendance/${sessionId}`);
  revalidatePath(`/dashboard/classes/${session.classId}`);
  return actionSuccess(`Absensi ${parsed.data.records.length} siswa disimpan.`);
}

/** Convenience: mark everyone present, then let the teacher adjust. */
export async function markAllPresentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const sessionId = String(formData.get("sessionId") ?? "");

  let actor: SessionUser;
  try {
    actor = await assertSessionManageable(sessionId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const session = await prisma.attendanceSession.findUnique({
    where: { id: sessionId },
    select: { classId: true },
  });
  if (!session) return actionError("Sesi tidak ditemukan.");

  const enrolled = await prisma.classEnrollment.findMany({
    where: { classId: session.classId, status: "ACTIVE" },
    select: { studentId: true },
  });

  if (enrolled.length === 0) return actionError("Belum ada siswa aktif di kelas ini.");

  await prisma.$transaction(
    enrolled.map(({ studentId }) =>
      prisma.attendanceRecord.upsert({
        where: { sessionId_studentId: { sessionId, studentId } },
        create: { sessionId, studentId, status: "PRESENT" },
        update: { status: "PRESENT" },
      })
    )
  );

  await recordAudit({
    actorId: actor.id,
    action: "ATTENDANCE_ALL_PRESENT",
    entity: "AttendanceSession",
    entityId: sessionId,
    metadata: { count: enrolled.length },
  });

  revalidatePath(`/dashboard/attendance/${sessionId}`);
  revalidatePath(`/dashboard/classes/${session.classId}`);
  return actionSuccess(`${enrolled.length} siswa ditandai hadir.`);
}

export async function deleteAttendanceSessionAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const sessionId = String(formData.get("sessionId") ?? "");

  let actor: SessionUser;
  try {
    actor = await assertSessionManageable(sessionId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const session = await prisma.attendanceSession.findUnique({
    where: { id: sessionId },
    select: { classId: true },
  });
  if (!session) return actionError("Sesi tidak ditemukan.");

  await prisma.attendanceSession.delete({ where: { id: sessionId } });

  await recordAudit({
    actorId: actor.id,
    action: "ATTENDANCE_SESSION_DELETED",
    entity: "AttendanceSession",
    entityId: sessionId,
  });

  revalidatePath("/dashboard/attendance");
  revalidatePath(`/dashboard/classes/${session.classId}`);
  redirect("/dashboard/attendance");
}

/** Update a single student's status inline from the class page. */
export async function updateSingleAttendanceAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const sessionId = String(formData.get("sessionId") ?? "");
  const studentId = String(formData.get("studentId") ?? "");
  const status = String(formData.get("status") ?? "");

  let actor: SessionUser;
  try {
    actor = await assertSessionManageable(sessionId);
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  if (!["PRESENT", "LATE", "ABSENT", "EXCUSED"].includes(status)) {
    return actionError("Status absensi tidak valid.");
  }

  // assertSessionManageable only proves the actor teaches the session's class.
  // The student id arrives in the same request, so without this check a teacher
  // could write an attendance row for a student who is not in the class at all,
  // falsifying that student's attendance totals.
  const session = await prisma.attendanceSession.findUnique({
    where: { id: sessionId },
    select: { classId: true },
  });
  if (!session) return actionError("Sesi absensi tidak ditemukan.");

  const member = await prisma.classEnrollment.findFirst({
    where: { classId: session.classId, studentId, status: "ACTIVE" },
    select: { id: true },
  });
  if (!member) return actionError("Siswa ini bukan anggota kelas tersebut.");

  await prisma.attendanceRecord.upsert({
    where: { sessionId_studentId: { sessionId, studentId } },
    create: { sessionId, studentId, status: status as AttendanceStatus },
    update: { status: status as AttendanceStatus },
  });

  await recordAudit({
    actorId: actor.id,
    action: "ATTENDANCE_UPDATED",
    entity: "AttendanceRecord",
    entityId: `${sessionId}:${studentId}`,
    metadata: { status },
  });

  revalidatePath(`/dashboard/attendance/${sessionId}`);
  return actionSuccess("Status absensi diperbarui.");
}
