"use server";

import { revalidatePath } from "next/cache";
import { prisma } from "@/lib/db";
import { authorize, authorizeAdmin, authorizeStudent } from "@/lib/auth/rbac";
import { recordAudit } from "@/lib/audit";
import {
  certificateIssueSchema,
  certificateRevokeSchema,
  fieldErrors,
} from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import {
  ensureCertificateForCourse,
  reinstateCertificate,
  revokeCertificate,
} from "@/lib/certificates";
import type { SessionUser } from "@/lib/auth/session";

/**
 * Certificate mutations.
 *
 * Issuing is normally automatic (see `recalcCourseProgress`), so the manual
 * action exists to backfill completions that predate this feature, and for an
 * administrator to issue on a student's behalf.
 */

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

/** Revalidate every surface a certificate appears on. */
function revalidateCertificateSurfaces(studentId: string): void {
  revalidatePath("/dashboard/certificates");
  revalidatePath(`/dashboard/users/${studentId}`);
  revalidatePath("/dashboard/progress");
  revalidatePath("/dashboard");
}

/**
 * Issue a certificate for one student's completed course.
 *
 * Reachable by the student themselves (the "terbitkan" button on a finished
 * course) and by staff. A student may only ever issue their own.
 */
export async function issueCertificateAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const parsed = certificateIssueSchema.safeParse({
    studentId: formData.get("studentId"),
    courseId: formData.get("courseId"),
  });

  if (!parsed.success) {
    return actionError("Data sertifikat tidak lengkap.", fieldErrors(parsed.error));
  }

  const { studentId, courseId } = parsed.data;

  // A student may only act on their own record. Staff may act for others, but a
  // teacher only for a course they actually teach — otherwise any teacher could
  // mint certificates for students in another teacher's course.
  const isSelf = studentId === actor.id;
  if (!isSelf) {
    if (actor.role === "ADMIN") {
      // Admins may issue for anyone.
    } else if (actor.role === "TEACHER") {
      const course = await prisma.course.findUnique({
        where: { id: courseId },
        select: { teacherId: true, classroom: { select: { teacherId: true } } },
      });
      const ownsCourse =
        course !== null &&
        (course.teacherId === actor.id || course.classroom?.teacherId === actor.id);
      if (!ownsCourse) {
        return actionError("Kamu hanya dapat menerbitkan sertifikat untuk kursus yang kamu ampu.");
      }
    } else {
      return actionError("Kamu hanya dapat menerbitkan sertifikatmu sendiri.");
    }
  }

  try {
    const result = await ensureCertificateForCourse(studentId, courseId, actor.id);

    if (!result) {
      return actionError(
        "Sertifikat belum dapat diterbitkan. Pastikan seluruh pelajaran pada kursus ini sudah diselesaikan."
      );
    }

    if (result.created) {
      await recordAudit({
        actorId: actor.id,
        action: "CERTIFICATE_ISSUED",
        entity: "Certificate",
        entityId: result.certificateId,
        metadata: { studentId, courseId, serial: result.serial },
      });
    }

    revalidateCertificateSurfaces(studentId);

    return actionSuccess(
      result.created
        ? `Sertifikat ${result.serial} berhasil diterbitkan.`
        : `Sertifikat ${result.serial} sudah pernah diterbitkan.`
    );
  } catch (error) {
    return actionError(messageOf(error, "Gagal menerbitkan sertifikat."));
  }
}

/** Revoke a certificate. Administrators only — this withdraws a credential. */
export async function revokeCertificateAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorizeAdmin();
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const parsed = certificateRevokeSchema.safeParse({
    certificateId: formData.get("certificateId"),
    note: formData.get("note") ?? "",
  });

  if (!parsed.success) {
    return actionError("Data tidak lengkap.", fieldErrors(parsed.error));
  }

  const { certificateId, note } = parsed.data;

  const certificate = await prisma.certificate.findUnique({
    where: { id: certificateId },
    select: { id: true, serial: true, status: true, studentId: true },
  });

  if (!certificate) return actionError("Sertifikat tidak ditemukan.");
  if (certificate.status === "REVOKED") {
    return actionError("Sertifikat ini sudah dicabut.");
  }

  try {
    await revokeCertificate(certificateId, note || null);

    await recordAudit({
      actorId: actor.id,
      action: "CERTIFICATE_REVOKED",
      entity: "Certificate",
      entityId: certificateId,
      metadata: { serial: certificate.serial, studentId: certificate.studentId, note: note || null },
    });

    revalidateCertificateSurfaces(certificate.studentId);

    return actionSuccess(`Sertifikat ${certificate.serial} dicabut.`);
  } catch (error) {
    return actionError(messageOf(error, "Gagal mencabut sertifikat."));
  }
}

/** Restore a revoked certificate. Administrators only. */
export async function reinstateCertificateAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorizeAdmin();
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const certificateId = String(formData.get("certificateId") ?? "");
  if (!certificateId) return actionError("Sertifikat tidak ditemukan.");

  const certificate = await prisma.certificate.findUnique({
    where: { id: certificateId },
    select: { id: true, serial: true, status: true, studentId: true },
  });

  if (!certificate) return actionError("Sertifikat tidak ditemukan.");
  if (certificate.status === "ISSUED") {
    return actionError("Sertifikat ini sedang aktif.");
  }

  try {
    await reinstateCertificate(certificateId);

    await recordAudit({
      actorId: actor.id,
      action: "CERTIFICATE_REINSTATED",
      entity: "Certificate",
      entityId: certificateId,
      metadata: { serial: certificate.serial, studentId: certificate.studentId },
    });

    revalidateCertificateSurfaces(certificate.studentId);

    return actionSuccess(`Sertifikat ${certificate.serial} diaktifkan kembali.`);
  } catch (error) {
    return actionError(messageOf(error, "Gagal mengaktifkan sertifikat."));
  }
}

/**
 * Backfill every certificate a student has earned but does not hold yet.
 *
 * Used from the student's own page as a single "periksa kelulusan" action, so a
 * student whose course finished before this feature shipped is not stuck.
 */
export async function syncMyCertificatesAction(
  _previous: ActionState,
  _formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorizeStudent();
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  try {
    const completed = await prisma.courseEnrollment.findMany({
      where: {
        studentId: actor.id,
        status: "COMPLETED",
        progress: { gte: 100 },
      },
      select: { courseId: true },
    });

    let issued = 0;
    for (const enrollment of completed) {
      const result = await ensureCertificateForCourse(actor.id, enrollment.courseId, null);
      if (result?.created) issued += 1;
    }

    if (issued > 0) {
      await recordAudit({
        actorId: actor.id,
        action: "CERTIFICATE_BACKFILLED",
        entity: "User",
        entityId: actor.id,
        metadata: { issued },
      });
    }

    revalidateCertificateSurfaces(actor.id);

    return actionSuccess(
      issued === 0
        ? "Tidak ada sertifikat baru. Selesaikan seluruh pelajaran pada sebuah kursus untuk memperolehnya."
        : `${issued} sertifikat baru diterbitkan.`
    );
  } catch (error) {
    return actionError(messageOf(error, "Gagal memeriksa kelulusan."));
  }
}
