"use server";

import { revalidatePath } from "next/cache";
import { redirect } from "next/navigation";
import { prisma } from "@/lib/db";
import { authorize, authorizeTeacher, canManageOwnedResource } from "@/lib/auth/rbac";
import type { SessionUser } from "@/lib/auth/session";
import { recordAudit } from "@/lib/audit";
import { awardXp } from "@/lib/gamification";
import {
  classroomSchema,
  courseSchema,
  lessonSchema,
  moduleSchema,
  joinClassSchema,
  fieldErrors,
} from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import { ensureCertificateForCourse } from "@/lib/certificates";

/**
 * Course, module, lesson and classroom mutations.
 *
 * Every action re-authorizes server-side. Teachers may only touch resources
 * they own (or that live in a class they teach); admins may touch anything.
 */

/** Turn a title into a URL-safe, collision-resistant slug. */
function slugify(input: string): string {
  return input
    .toLowerCase()
    .replace(/[^a-z0-9\s-]/g, "")
    .trim()
    .replace(/\s+/g, "-")
    .slice(0, 60);
}

/** Append `-2`, `-3`, … until the slug is free. */
async function uniqueCourseSlug(base: string, excludeId?: string): Promise<string> {
  const root = base || "kursus";
  let candidate = root;
  let suffix = 2;
  for (;;) {
    const clash = await prisma.course.findUnique({
      where: { slug: candidate },
      select: { id: true },
    });
    if (!clash || clash.id === excludeId) return candidate;
    candidate = `${root}-${suffix}`;
    suffix += 1;
  }
}

async function uniqueLessonSlug(
  courseId: string,
  base: string,
  excludeId?: string
): Promise<string> {
  const root = base || "pelajaran";
  let candidate = root;
  let suffix = 2;
  for (;;) {
    const clash = await prisma.lesson.findUnique({
      where: { courseId_slug: { courseId, slug: candidate } },
      select: { id: true },
    });
    if (!clash || clash.id === excludeId) return candidate;
    candidate = `${root}-${suffix}`;
    suffix += 1;
  }
}

/** Generate a short, human-readable class join code. */
async function uniqueJoinCode(): Promise<string> {
  const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
  for (let attempt = 0; attempt < 40; attempt += 1) {
    let code = "";
    for (let i = 0; i < 6; i += 1) {
      code += alphabet[Math.floor(Math.random() * alphabet.length)];
    }
    const clash = await prisma.classroom.findUnique({ where: { joinCode: code }, select: { id: true } });
    if (!clash) return code;
  }
  throw new Error("Could not generate a unique join code.");
}

/** Confirm the actor may manage a given course. */
async function assertCourseManageable(courseId: string) {
  const actor = await authorizeTeacher();
  const course = await prisma.course.findUnique({
    where: { id: courseId },
    select: { id: true, teacherId: true, classroom: { select: { teacherId: true } } },
  });
  if (!course) throw new Error("Course not found.");

  const ownerIds = [course.teacherId, course.classroom?.teacherId].filter(Boolean) as string[];
  if (!ownerIds.some((ownerId) => canManageOwnedResource(actor, ownerId))) {
    throw new Error("You do not have permission to manage this course.");
  }
  return { actor, course };
}

// ---------------------------------------------------------------------------
// Courses
// ---------------------------------------------------------------------------

export async function createCourseAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor;
  try {
    actor = await authorizeTeacher();
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = courseSchema.safeParse({
    title: formData.get("title"),
    summary: formData.get("summary") ?? "",
    description: formData.get("description") ?? "",
    level: formData.get("level") ?? "BEGINNER",
    language: formData.get("language") ?? "JAVASCRIPT",
    status: formData.get("status") ?? "DRAFT",
    estimatedHours: formData.get("estimatedHours") ?? 8,
    coverColor: formData.get("coverColor") ?? "#26241c",
    tags: formData.getAll("tags[]").length > 0
      ? formData.getAll("tags[]")
      : String(formData.get("tags") ?? "")
          .split(",")
          .map((tag) => tag.trim())
          .filter(Boolean),
    classroomId: formData.get("classroomId") ?? "",
  });

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

  const data = parsed.data;
  const slug = await uniqueCourseSlug(slugify(data.title));

  // The classroom id comes from the form, so prove the actor may attach a course
  // to it. Without this a teacher could bind their course to another teacher's
  // class, exposing it to that class's students and handing its teacher a share
  // of the course.
  if (data.classroomId) {
    const classroom = await prisma.classroom.findUnique({
      where: { id: data.classroomId },
      select: { teacherId: true },
    });
    if (!classroom || !canManageOwnedResource(actor, classroom.teacherId)) {
      return actionError("Kelas yang dipilih bukan milikmu.");
    }
  }

  const course = await prisma.course.create({
    data: {
      title: data.title,
      slug,
      summary: data.summary || null,
      description: data.description || null,
      level: data.level,
      language: data.language,
      status: data.status,
      estimatedHours: data.estimatedHours,
      coverColor: data.coverColor,
      tags: data.tags,
      classroomId: data.classroomId || null,
      teacherId: actor.id,
      publishedAt: data.status === "PUBLISHED" ? new Date() : null,
    },
    select: { id: true, title: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "COURSE_CREATED",
    entity: "Course",
    entityId: course.id,
    metadata: { title: course.title },
  });

  revalidatePath("/dashboard/courses");
  revalidatePath("/dashboard/teaching");
  return actionSuccess(`Kursus "${course.title}" berhasil dibuat.`);
}

export async function updateCourseAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  let context;
  try {
    context = await assertCourseManageable(courseId);
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }
  const { actor } = context;

  const parsed = courseSchema.safeParse({
    title: formData.get("title"),
    summary: formData.get("summary") ?? "",
    description: formData.get("description") ?? "",
    level: formData.get("level") ?? "BEGINNER",
    language: formData.get("language") ?? "JAVASCRIPT",
    status: formData.get("status") ?? "DRAFT",
    estimatedHours: formData.get("estimatedHours") ?? 8,
    coverColor: formData.get("coverColor") ?? "#26241c",
    tags: String(formData.get("tags") ?? "")
      .split(",")
      .map((tag) => tag.trim())
      .filter(Boolean),
    classroomId: formData.get("classroomId") ?? "",
  });

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

  const data = parsed.data;
  const existing = await prisma.course.findUniqueOrThrow({
    where: { id: courseId },
    select: { status: true, publishedAt: true, slug: true, title: true },
  });

  // Same rule as create: the classroom id must belong to the actor.
  if (data.classroomId) {
    const classroom = await prisma.classroom.findUnique({
      where: { id: data.classroomId },
      select: { teacherId: true },
    });
    if (!classroom || !canManageOwnedResource(actor, classroom.teacherId)) {
      return actionError("Kelas yang dipilih bukan milikmu.");
    }
  }

  const slug =
    data.title === existing.title
      ? existing.slug
      : await uniqueCourseSlug(slugify(data.title), courseId);

  await prisma.course.update({
    where: { id: courseId },
    data: {
      title: data.title,
      slug,
      summary: data.summary || null,
      description: data.description || null,
      level: data.level,
      language: data.language,
      status: data.status,
      estimatedHours: data.estimatedHours,
      coverColor: data.coverColor,
      tags: data.tags,
      classroomId: data.classroomId || null,
      publishedAt:
        data.status === "PUBLISHED" ? (existing.publishedAt ?? new Date()) : existing.publishedAt,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "COURSE_UPDATED",
    entity: "Course",
    entityId: courseId,
    metadata: { status: data.status },
  });

  revalidatePath("/dashboard/courses");
  revalidatePath(`/dashboard/courses/${courseId}`);
  revalidatePath("/dashboard/teaching");
  return actionSuccess("Perubahan kursus disimpan.");
}

export async function deleteCourseAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  try {
    const { actor } = await assertCourseManageable(courseId);
    await prisma.course.delete({ where: { id: courseId } });
    await recordAudit({
      actorId: actor.id,
      action: "COURSE_DELETED",
      entity: "Course",
      entityId: courseId,
    });
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Gagal menghapus kursus.");
  }

  revalidatePath("/dashboard/courses");
  revalidatePath("/dashboard/teaching");
  redirect("/dashboard/courses");
}

// ---------------------------------------------------------------------------
// Modules
// ---------------------------------------------------------------------------

export async function createModuleAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  try {
    await assertCourseManageable(courseId);
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = moduleSchema.safeParse({
    courseId,
    title: formData.get("title"),
    description: formData.get("description") ?? "",
    orderIndex: formData.get("orderIndex") ?? 0,
  });

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

  const count = await prisma.module.count({ where: { courseId } });
  await prisma.module.create({
    data: {
      courseId,
      title: parsed.data.title,
      description: parsed.data.description || null,
      orderIndex: parsed.data.orderIndex || count,
    },
  });

  revalidatePath(`/dashboard/courses/${courseId}`);
  return actionSuccess("Modul ditambahkan.");
}

export async function deleteModuleAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const moduleId = String(formData.get("moduleId") ?? "");
  const module = await prisma.module.findUnique({
    where: { id: moduleId },
    select: { courseId: true },
  });
  if (!module) return actionError("Modul tidak ditemukan.");

  try {
    await assertCourseManageable(module.courseId);
    await prisma.module.delete({ where: { id: moduleId } });
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Gagal menghapus modul.");
  }

  revalidatePath(`/dashboard/courses/${module.courseId}`);
  return actionSuccess("Modul dihapus.");
}

// ---------------------------------------------------------------------------
// Lessons
// ---------------------------------------------------------------------------

export async function createLessonAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  try {
    await assertCourseManageable(courseId);
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = lessonSchema.safeParse({
    courseId,
    moduleId: formData.get("moduleId") ?? "",
    title: formData.get("title"),
    summary: formData.get("summary") ?? "",
    content: formData.get("content") ?? "",
    type: formData.get("type") ?? "TEXT",
    videoUrl: formData.get("videoUrl") ?? "",
    attachmentUrl: formData.get("attachmentUrl") ?? "",
    durationMinutes: formData.get("durationMinutes") ?? 30,
    orderIndex: formData.get("orderIndex") ?? 0,
    isPreview: formData.get("isPreview") === "on" || formData.get("isPreview") === "true",
    status: formData.get("status") ?? "DRAFT",
    objectives: String(formData.get("objectives") ?? "")
      .split("\n")
      .map((line) => line.trim())
      .filter(Boolean),
  });

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

  const data = parsed.data;
  const slug = await uniqueLessonSlug(courseId, slugify(data.title));
  const count = await prisma.lesson.count({ where: { courseId } });

  // A module id from the form must belong to this course. Otherwise the lesson
  // is filed under another course's module and vanishes from its own outline.
  if (data.moduleId) {
    const module = await prisma.module.findUnique({
      where: { id: data.moduleId },
      select: { courseId: true },
    });
    if (!module || module.courseId !== courseId) {
      return actionError("Modul yang dipilih bukan bagian dari kursus ini.");
    }
  }

  const lesson = await prisma.lesson.create({
    data: {
      courseId,
      moduleId: data.moduleId || null,
      title: data.title,
      slug,
      summary: data.summary || null,
      content: data.content,
      type: data.type,
      videoUrl: data.videoUrl || null,
      attachmentUrl: data.attachmentUrl || null,
      durationMinutes: data.durationMinutes,
      orderIndex: data.orderIndex || count,
      isPreview: data.isPreview,
      status: data.status,
      objectives: data.objectives,
    },
    select: { id: true, title: true },
  });

  revalidatePath(`/dashboard/courses/${courseId}`);
  return actionSuccess(`Pelajaran "${lesson.title}" ditambahkan.`);
}

export async function updateLessonAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const lessonId = String(formData.get("lessonId") ?? "");
  const lesson = await prisma.lesson.findUnique({
    where: { id: lessonId },
    select: { courseId: true, slug: true, title: true },
  });
  if (!lesson) return actionError("Pelajaran tidak ditemukan.");

  try {
    await assertCourseManageable(lesson.courseId);
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = lessonSchema.safeParse({
    courseId: lesson.courseId,
    moduleId: formData.get("moduleId") ?? "",
    title: formData.get("title"),
    summary: formData.get("summary") ?? "",
    content: formData.get("content") ?? "",
    type: formData.get("type") ?? "TEXT",
    videoUrl: formData.get("videoUrl") ?? "",
    attachmentUrl: formData.get("attachmentUrl") ?? "",
    durationMinutes: formData.get("durationMinutes") ?? 30,
    orderIndex: formData.get("orderIndex") ?? 0,
    isPreview: formData.get("isPreview") === "on" || formData.get("isPreview") === "true",
    status: formData.get("status") ?? "DRAFT",
    objectives: String(formData.get("objectives") ?? "")
      .split("\n")
      .map((line) => line.trim())
      .filter(Boolean),
  });

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

  const data = parsed.data;
  const slug =
    data.title === lesson.title
      ? lesson.slug
      : await uniqueLessonSlug(lesson.courseId, slugify(data.title), lessonId);

  // Same rule as create: the module must belong to this lesson's course.
  if (data.moduleId) {
    const module = await prisma.module.findUnique({
      where: { id: data.moduleId },
      select: { courseId: true },
    });
    if (!module || module.courseId !== lesson.courseId) {
      return actionError("Modul yang dipilih bukan bagian dari kursus ini.");
    }
  }

  await prisma.lesson.update({
    where: { id: lessonId },
    data: {
      moduleId: data.moduleId || null,
      title: data.title,
      slug,
      summary: data.summary || null,
      content: data.content,
      type: data.type,
      videoUrl: data.videoUrl || null,
      attachmentUrl: data.attachmentUrl || null,
      durationMinutes: data.durationMinutes,
      orderIndex: data.orderIndex,
      isPreview: data.isPreview,
      status: data.status,
      objectives: data.objectives,
    },
  });

  revalidatePath(`/dashboard/courses/${lesson.courseId}`);
  revalidatePath(`/dashboard/lessons/${lessonId}`);
  return actionSuccess("Pelajaran diperbarui.");
}

export async function deleteLessonAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const lessonId = String(formData.get("lessonId") ?? "");
  const lesson = await prisma.lesson.findUnique({
    where: { id: lessonId },
    select: { courseId: true },
  });
  if (!lesson) return actionError("Pelajaran tidak ditemukan.");

  try {
    await assertCourseManageable(lesson.courseId);
    await prisma.lesson.delete({ where: { id: lessonId } });
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Gagal menghapus pelajaran.");
  }

  revalidatePath(`/dashboard/courses/${lesson.courseId}`);
  return actionSuccess("Pelajaran dihapus.");
}

// ---------------------------------------------------------------------------
// Lesson progress (student)
// ---------------------------------------------------------------------------

export async function completeLessonAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const lessonId = String(formData.get("lessonId") ?? "");
  const seconds = Number(formData.get("timeSpentSeconds") ?? 0);

  const lesson = await prisma.lesson.findUnique({
    where: { id: lessonId },
    select: {
      id: true,
      courseId: true,
      status: true,
      title: true,
      course: {
        select: {
          classroomId: true,
          enrollments: { where: { studentId: actor.id }, select: { id: true }, take: 1 },
          classroom: {
            select: {
              enrollments: {
                where: { studentId: actor.id, status: "ACTIVE" },
                select: { id: true },
                take: 1,
              },
            },
          },
        },
      },
    },
  });

  if (!lesson) return actionError("Pelajaran tidak ditemukan.");

  // Students may only complete lessons they have access to.
  const hasAccess =
    lesson.course.enrollments.length > 0 ||
    (lesson.course.classroom?.enrollments.length ?? 0) > 0;
  if (!hasAccess) return actionError("Kamu tidak terdaftar pada kursus ini.");

  const existing = await prisma.lessonProgress.findUnique({
    where: { lessonId_studentId: { lessonId, studentId: actor.id } },
    select: { status: true, timeSpentSeconds: true },
  });

  const alreadyCompleted = existing?.status === "COMPLETED";

  await prisma.lessonProgress.upsert({
    where: { lessonId_studentId: { lessonId, studentId: actor.id } },
    create: {
      lessonId,
      studentId: actor.id,
      status: "COMPLETED",
      progressPercent: 100,
      timeSpentSeconds: Number.isFinite(seconds) ? Math.max(0, Math.round(seconds)) : 0,
      lastViewedAt: new Date(),
      completedAt: new Date(),
    },
    update: {
      status: "COMPLETED",
      progressPercent: 100,
      timeSpentSeconds:
        (existing?.timeSpentSeconds ?? 0) +
        (Number.isFinite(seconds) ? Math.max(0, Math.round(seconds)) : 0),
      lastViewedAt: new Date(),
      completedAt: new Date(),
    },
  });

  // Idempotent: re-opening a lesson must not farm XP.
  if (!alreadyCompleted) {
    await awardXp({
      userId: actor.id,
      amount: 20,
      source: "LESSON_COMPLETE",
      reason: `Menyelesaikan pelajaran: ${lesson.title}`,
      refType: "lesson",
      refId: lessonId,
      idempotent: true,
    });
  }

  await recalcCourseProgress(actor.id, lesson.courseId);

  await recordAudit({
    actorId: actor.id,
    action: "LESSON_COMPLETED",
    entity: "Lesson",
    entityId: lessonId,
    metadata: { courseId: lesson.courseId },
  });

  revalidatePath(`/dashboard/lessons/${lessonId}`);
  revalidatePath(`/dashboard/courses/${lesson.courseId}`);
  revalidatePath("/dashboard/progress");
  revalidatePath("/dashboard");

  return actionSuccess(alreadyCompleted ? "Pelajaran sudah selesai." : "Pelajaran ditandai selesai! +20 XP");
}

/** Recompute a student's percentage completion for one course. */
async function recalcCourseProgress(studentId: string, courseId: string): Promise<void> {
  const [totalLessons, completedLessons] = await Promise.all([
    prisma.lesson.count({ where: { courseId, status: "PUBLISHED" } }),
    prisma.lessonProgress.count({
      where: { studentId, status: "COMPLETED", lesson: { courseId, status: "PUBLISHED" } },
    }),
  ]);

  const progress = totalLessons === 0 ? 0 : Math.round((completedLessons / totalLessons) * 100);

  await prisma.courseEnrollment.updateMany({
    where: { studentId, courseId },
    data: {
      progress,
      status: progress >= 100 ? "COMPLETED" : "ACTIVE",
      completedAt: progress >= 100 ? new Date() : null,
    },
  });

  // Finishing the last lesson is what earns a certificate, so it is issued
  // here rather than from a scheduled job. Idempotent: re-completing a lesson
  // cannot mint a second one. Failures are swallowed because a certificate is
  // a bonus — it must never block the student's "pelajaran selesai" action.
  if (progress >= 100) {
    try {
      const issued = await ensureCertificateForCourse(studentId, courseId, null);
      if (issued?.created) {
        await recordAudit({
          actorId: studentId,
          action: "CERTIFICATE_ISSUED",
          entity: "Certificate",
          entityId: issued.certificateId,
          metadata: { studentId, courseId, serial: issued.serial, trigger: "course-completion" },
        });
        revalidatePath("/dashboard/certificates");
      }
    } catch {
      // Ignored by design.
    }
  }
}

export async function markLessonInProgressAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor;
  try {
    actor = await authorize("STUDENT");
  } catch {
    return actionError("Tidak diizinkan.");
  }

  const lessonId = String(formData.get("lessonId") ?? "");

  // The lesson id arrives from the client, so confirm the student may actually
  // see this lesson before recording progress against it. Without this the
  // action writes a LessonProgress row for any lesson id, including lessons in
  // courses the student is not enrolled in.
  const lesson = await prisma.lesson.findFirst({
    where: {
      id: lessonId,
      status: "PUBLISHED",
      course: {
        OR: [
          { enrollments: { some: { studentId: actor.id } } },
          { classroom: { enrollments: { some: { studentId: actor.id, status: "ACTIVE" } } } },
        ],
      },
    },
    select: { id: true },
  });
  if (!lesson) return actionError("Pelajaran tidak ditemukan.");

  const existing = await prisma.lessonProgress.findUnique({
    where: { lessonId_studentId: { lessonId, studentId: actor.id } },
    select: { status: true },
  });

  if (existing?.status === "COMPLETED") return actionSuccess();

  await prisma.lessonProgress.upsert({
    where: { lessonId_studentId: { lessonId, studentId: actor.id } },
    create: {
      lessonId,
      studentId: actor.id,
      status: "IN_PROGRESS",
      progressPercent: 25,
      lastViewedAt: new Date(),
    },
    update: { status: "IN_PROGRESS", lastViewedAt: new Date() },
  });

  return actionSuccess();
}

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

export async function createClassroomAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorizeTeacher();
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "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") ?? "",
    teacherId: formData.get("teacherId") || undefined,
  });

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

  const data = parsed.data;
  const teacherId = actor.role === "ADMIN" && data.teacherId ? data.teacherId : actor.id;
  const code = `${slugify(data.name).slice(0, 12).toUpperCase() || "KELAS"}-${Math.floor(Math.random() * 900 + 100)}`;

  const classroom = await prisma.classroom.create({
    data: {
      name: data.name,
      code,
      description: data.description || null,
      academicYear: data.academicYear,
      gradeLevel: data.gradeLevel || null,
      room: data.room || null,
      joinCode: await uniqueJoinCode(),
      teacherId,
    },
    select: { id: true, name: true, joinCode: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "CLASSROOM_CREATED",
    entity: "Classroom",
    entityId: classroom.id,
    metadata: { name: classroom.name },
  });

  revalidatePath("/dashboard/classes");
  return actionSuccess(`Kelas "${classroom.name}" dibuat. Kode gabung: ${classroom.joinCode}`);
}

export async function joinClassroomAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = joinClassSchema.safeParse({ joinCode: formData.get("joinCode") });
  if (!parsed.success) {
    return actionError("Kode kelas tidak valid.", fieldErrors(parsed.error));
  }

  const classroom = await prisma.classroom.findUnique({
    where: { joinCode: parsed.data.joinCode.toUpperCase() },
    select: { id: true, name: true, archivedAt: true, courses: { select: { id: true } } },
  });

  if (!classroom || classroom.archivedAt) {
    return actionError("Kode kelas tidak ditemukan.", { joinCode: "Kode kelas tidak valid." });
  }

  const existing = await prisma.classEnrollment.findUnique({
    where: { classId_studentId: { classId: classroom.id, studentId: actor.id } },
    select: { id: true },
  });
  if (existing) {
    return actionError("Kamu sudah tergabung di kelas ini.");
  }

  // Joining a class also enrols the student in every course attached to it.
  await prisma.$transaction(async (tx) => {
    await tx.classEnrollment.create({
      data: { classId: classroom.id, studentId: actor.id, status: "ACTIVE" },
    });

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

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

  revalidatePath("/dashboard/classes");
  revalidatePath("/dashboard/courses");
  return actionSuccess(`Berhasil bergabung ke kelas "${classroom.name}".`);
}

export async function removeClassStudentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const enrollmentId = String(formData.get("enrollmentId") ?? "");
  const enrollment = await prisma.classEnrollment.findUnique({
    where: { id: enrollmentId },
    select: { classId: true, classroom: { select: { teacherId: true } } },
  });
  if (!enrollment) return actionError("Data siswa tidak ditemukan.");

  let actor;
  try {
    actor = await authorizeTeacher();
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }
  if (!canManageOwnedResource(actor, enrollment.classroom.teacherId)) {
    return actionError("Kamu tidak berhak mengubah kelas ini.");
  }

  await prisma.classEnrollment.update({
    where: { id: enrollmentId },
    data: { status: "DROPPED", droppedAt: new Date() },
  });

  await recordAudit({
    actorId: actor.id,
    action: "CLASS_STUDENT_REMOVED",
    entity: "ClassEnrollment",
    entityId: enrollmentId,
  });

  revalidatePath(`/dashboard/classes/${enrollment.classId}`);
  return actionSuccess("Siswa dikeluarkan dari kelas.");
}

/** Manually enrol a student into a course (teacher/admin). */
export async function enrollStudentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  const studentId = String(formData.get("studentId") ?? "");

  let actor: SessionUser;
  try {
    actor = await authorizeTeacher();
    const course = await prisma.course.findUnique({
      where: { id: courseId },
      select: { teacherId: true, classroom: { select: { teacherId: true } } },
    });
    if (!course) return actionError("Kursus tidak ditemukan.");

    const ownerIds = [course.teacherId, course.classroom?.teacherId].filter(Boolean) as string[];
    if (!ownerIds.some((ownerId) => canManageOwnedResource(actor, ownerId))) {
      return actionError("Kamu tidak berhak mengubah kursus ini.");
    }
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "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.");
  }

  await prisma.courseEnrollment.upsert({
    where: { courseId_studentId: { courseId, studentId } },
    create: { courseId, studentId, status: "ACTIVE" },
    update: { status: "ACTIVE" },
  });

  await prisma.notification.create({
    data: {
      userId: studentId,
      type: "INFO",
      title: "Kamu terdaftar di kursus baru",
      body: `Kamu telah ditambahkan ke sebuah kursus oleh ${actor.fullName}.`,
      link: `/dashboard/courses/${courseId}`,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "COURSE_STUDENT_ENROLLED",
    entity: "CourseEnrollment",
    entityId: courseId,
    metadata: { studentId },
  });

  revalidatePath(`/dashboard/courses/${courseId}`);
  return actionSuccess(`${student.fullName} ditambahkan ke kursus.`);
}

/** Remove a student from a course. */
export async function unenrollStudentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const courseId = String(formData.get("courseId") ?? "");
  const studentId = String(formData.get("studentId") ?? "");

  let actor: SessionUser;
  try {
    actor = await authorizeTeacher();
    const course = await prisma.course.findUnique({
      where: { id: courseId },
      select: { teacherId: true, classroom: { select: { teacherId: true } } },
    });
    if (!course) return actionError("Kursus tidak ditemukan.");

    const ownerIds = [course.teacherId, course.classroom?.teacherId].filter(Boolean) as string[];
    if (!ownerIds.some((ownerId) => canManageOwnedResource(actor, ownerId))) {
      return actionError("Kamu tidak berhak mengubah kursus ini.");
    }
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  await prisma.courseEnrollment.deleteMany({ where: { courseId, studentId } });

  await recordAudit({
    actorId: actor.id,
    action: "COURSE_STUDENT_UNENROLLED",
    entity: "CourseEnrollment",
    entityId: courseId,
    metadata: { studentId },
  });

  revalidatePath(`/dashboard/courses/${courseId}`);
  return actionSuccess("Siswa dikeluarkan dari kursus.");
}

// ---------------------------------------------------------------------------
// Lesson discussion
// ---------------------------------------------------------------------------

/**
 * Post a comment on a lesson.
 *
 * `Comment.lessonId` has no relation in the Prisma schema (the column exists
 * but is unlinked), so this writes it directly. Access is checked against the
 * lesson's course, so only enrolled students and the course's staff can post.
 */
export async function commentOnLessonAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const lessonId = String(formData.get("lessonId") ?? "");
  const body = String(formData.get("body") ?? "").trim();

  if (!lessonId) return actionError("Pelajaran tidak ditemukan.");
  if (body.length < 1) return actionError("Tulis komentar terlebih dahulu.");
  if (body.length > 4000) return actionError("Komentar terlalu panjang.");

  const lesson = await prisma.lesson.findUnique({
    where: { id: lessonId },
    select: {
      id: true,
      courseId: true,
      status: true,
      course: {
        select: {
          teacherId: true,
          classroom: {
            select: {
              teacherId: true,
              enrollments: {
                where: { studentId: actor.id, status: "ACTIVE" },
                select: { id: true },
                take: 1,
              },
            },
          },
          enrollments: { where: { studentId: actor.id }, select: { id: true }, take: 1 },
        },
      },
    },
  });

  if (!lesson) return actionError("Pelajaran tidak ditemukan.");

  const isEnrolled =
    lesson.course.enrollments.length > 0 ||
    (lesson.course.classroom?.enrollments.length ?? 0) > 0;

  const ownerIds = [lesson.course.teacherId, lesson.course.classroom?.teacherId].filter(
    Boolean
  ) as string[];

  if (!isEnrolled && !ownerIds.includes(actor.id) && actor.role !== "ADMIN") {
    return actionError("Kamu tidak terdaftar pada kursus ini.");
  }

  await prisma.comment.create({
    data: { lessonId, authorId: actor.id, body },
  });

  await recordAudit({
    actorId: actor.id,
    action: "LESSON_COMMENTED",
    entity: "Lesson",
    entityId: lessonId,
  });

  revalidatePath(`/dashboard/lessons/${lessonId}`);
  return actionSuccess("Komentar ditambahkan.");
}
