"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 { recordAudit } from "@/lib/audit";
import { awardXp, evaluateAchievements } from "@/lib/gamification";
import { assignmentSchema, gradeSchema, submissionSchema, fieldErrors } from "@/lib/validation";
import { uploadFile, StorageError } from "@/lib/storage";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import type { SessionUser } from "@/lib/auth/session";

/**
 * Assignment, submission and grading mutations.
 *
 * Authorization model:
 *   • Authoring (create/update/delete an assignment) — teacher who owns the
 *     course, or an admin.
 *   • Submitting — the enrolled student themself.
 *   • Grading — same rule as authoring; a teacher can never grade another
 *     teacher's course.
 */

/** Confirm the actor may author assignments for a course. */
async function assertCourseManageable(courseId: string): Promise<SessionUser> {
  const actor = await authorizeTeacher();
  const course = await prisma.course.findUnique({
    where: { id: courseId },
    select: { teacherId: true, classroom: { select: { teacherId: true } } },
  });
  if (!course) throw new Error("Kursus tidak ditemukan.");

  const ownerIds = [course.teacherId, course.classroom?.teacherId].filter(Boolean) as string[];
  if (!ownerIds.some((ownerId) => canManageOwnedResource(actor, ownerId))) {
    throw new Error("Kamu tidak berhak mengelola kursus ini.");
  }
  return actor;
}

/** Confirm the actor may grade a given submission. */
async function assertCanGradeSubmission(submissionId: string): Promise<SessionUser> {
  const actor = await authorizeTeacher();
  const submission = await prisma.submission.findUnique({
    where: { id: submissionId },
    select: {
      assignment: {
        select: {
          course: {
            select: { teacherId: true, classroom: { select: { teacherId: true } } },
          },
        },
      },
    },
  });
  if (!submission) throw new Error("Pengumpulan tidak ditemukan.");

  const ownerIds = [
    submission.assignment.course.teacherId,
    submission.assignment.course.classroom?.teacherId,
  ].filter(Boolean) as string[];
  if (!ownerIds.some((ownerId) => canManageOwnedResource(actor, ownerId))) {
    throw new Error("Kamu tidak berhak menilai pengumpulan ini.");
  }
  return actor;
}

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

// ---------------------------------------------------------------------------
// Assignments
// ---------------------------------------------------------------------------

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

  const parsed = assignmentSchema.safeParse({
    courseId,
    lessonId: formData.get("lessonId") ?? "",
    title: formData.get("title"),
    description: formData.get("description") ?? "",
    instructions: formData.get("instructions") ?? "",
    type: formData.get("type") ?? "HOMEWORK",
    maxScore: formData.get("maxScore") ?? 100,
    weight: formData.get("weight") ?? 1,
    dueAt: formData.get("dueAt") ? new Date(String(formData.get("dueAt"))) : undefined,
    allowLate: formData.get("allowLate") === "on" || formData.get("allowLate") === "true",
    status: formData.get("status") ?? "DRAFT",
  });

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

  const data = parsed.data;

  // A lesson id from the form must belong to the course being authorized.
  if (data.lessonId) {
    const lesson = await prisma.lesson.findUnique({
      where: { id: data.lessonId },
      select: { courseId: true },
    });
    if (!lesson || lesson.courseId !== courseId) {
      return actionError("Pelajaran yang dipilih bukan bagian dari kursus ini.");
    }
  }

  const assignment = await prisma.assignment.create({
    data: {
      courseId,
      lessonId: data.lessonId || null,
      title: data.title,
      description: data.description,
      instructions: data.instructions || null,
      type: data.type,
      maxScore: data.maxScore,
      weight: data.weight,
      dueAt: data.dueAt ?? null,
      allowLate: data.allowLate,
      status: data.status,
      createdById: actor.id,
    },
    select: { id: true, title: true },
  });

  // Publishing an assignment notifies every enrolled student immediately.
  if (data.status === "PUBLISHED") {
    await notifyAssignmentPublished(assignment.id);
  }

  await recordAudit({
    actorId: actor.id,
    action: "ASSIGNMENT_CREATED",
    entity: "Assignment",
    entityId: assignment.id,
    metadata: { courseId, title: assignment.title, status: data.status },
  });

  revalidatePath("/dashboard/assignments");
  revalidatePath(`/dashboard/courses/${courseId}`);
  revalidatePath("/dashboard/grading");
  return actionSuccess(`Tugas "${assignment.title}" dibuat.`);
}

/** Fan out a notification to everyone who can see the assignment. */
async function notifyAssignmentPublished(assignmentId: string): Promise<void> {
  const assignment = await prisma.assignment.findUnique({
    where: { id: assignmentId },
    select: {
      id: true,
      title: true,
      dueAt: true,
      course: {
        select: {
          title: true,
          enrollments: { select: { studentId: true } },
          classroom: { select: { enrollments: { select: { studentId: true } } } },
        },
      },
    },
  });
  if (!assignment) return;

  const recipientIds = new Set<string>([
    ...assignment.course.enrollments.map((row) => row.studentId),
    ...(assignment.course.classroom?.enrollments.map((row) => row.studentId) ?? []),
  ]);
  if (recipientIds.size === 0) return;

  await prisma.notification.createMany({
    data: [...recipientIds].map((userId) => ({
      userId,
      type: "ASSIGNMENT" as const,
      title: "Tugas baru",
      body: `${assignment.title} · ${assignment.course.title}`,
      link: `/dashboard/assignments/${assignment.id}`,
    })),
  });
}

export async function updateAssignmentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const assignmentId = String(formData.get("assignmentId") ?? "");
  const existing = await prisma.assignment.findUnique({
    where: { id: assignmentId },
    select: { courseId: true, status: true },
  });
  if (!existing) return actionError("Tugas tidak ditemukan.");

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

  const parsed = assignmentSchema.safeParse({
    courseId: existing.courseId,
    lessonId: formData.get("lessonId") ?? "",
    title: formData.get("title"),
    description: formData.get("description") ?? "",
    instructions: formData.get("instructions") ?? "",
    type: formData.get("type") ?? "HOMEWORK",
    maxScore: formData.get("maxScore") ?? 100,
    weight: formData.get("weight") ?? 1,
    dueAt: formData.get("dueAt") ? new Date(String(formData.get("dueAt"))) : undefined,
    allowLate: formData.get("allowLate") === "on" || formData.get("allowLate") === "true",
    status: formData.get("status") ?? "DRAFT",
  });

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

  const data = parsed.data;

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

  // A score ceiling below an already-awarded score would corrupt the gradebook.
  if (data.maxScore !== undefined) {
    const highest = await prisma.submission.aggregate({
      where: { assignmentId, score: { not: null } },
      _max: { score: true },
    });
    if (highest._max.score !== null && data.maxScore < highest._max.score) {
      return actionError(
        `Nilai maksimal tidak boleh lebih kecil dari nilai tertinggi yang sudah diberikan (${highest._max.score}).`,
        { maxScore: "Nilai maksimal terlalu kecil." }
      );
    }
  }

  await prisma.assignment.update({
    where: { id: assignmentId },
    data: {
      lessonId: data.lessonId || null,
      title: data.title,
      description: data.description,
      instructions: data.instructions || null,
      type: data.type,
      maxScore: data.maxScore,
      weight: data.weight,
      dueAt: data.dueAt ?? null,
      allowLate: data.allowLate,
      status: data.status,
    },
  });

  const justPublished = existing.status !== "PUBLISHED" && data.status === "PUBLISHED";
  if (justPublished) await notifyAssignmentPublished(assignmentId);

  await recordAudit({
    actorId: actor.id,
    action: "ASSIGNMENT_UPDATED",
    entity: "Assignment",
    entityId: assignmentId,
    metadata: { status: data.status },
  });

  revalidatePath("/dashboard/assignments");
  revalidatePath(`/dashboard/assignments/${assignmentId}`);
  revalidatePath(`/dashboard/courses/${existing.courseId}`);
  revalidatePath("/dashboard/grading");
  return actionSuccess("Tugas diperbarui.");
}

export async function deleteAssignmentAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const assignmentId = String(formData.get("assignmentId") ?? "");
  const existing = await prisma.assignment.findUnique({
    where: { id: assignmentId },
    select: { courseId: true, _count: { select: { submissions: true } } },
  });
  if (!existing) return actionError("Tugas tidak ditemukan.");

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

  if (existing._count.submissions > 0) {
    return actionError(
      `Tugas ini sudah memiliki ${existing._count.submissions} pengumpulan. Hapus pengumpulannya lebih dulu, atau arsipkan tugas ini.`
    );
  }

  await prisma.assignment.delete({ where: { id: assignmentId } });

  await recordAudit({
    actorId: actor.id,
    action: "ASSIGNMENT_DELETED",
    entity: "Assignment",
    entityId: assignmentId,
  });

  revalidatePath("/dashboard/assignments");
  revalidatePath(`/dashboard/courses/${existing.courseId}`);
  redirect("/dashboard/assignments");
}

// ---------------------------------------------------------------------------
// Submissions (student)
// ---------------------------------------------------------------------------

/**
 * Verify the student may submit to this assignment.
 *
 * Returns a discriminated union so callers get exhaustiveness checking rather
 * than relying on `in` narrowing across object literals.
 */
type SubmissionContext =
  | { ok: false; message: string }
  | {
      ok: true;
      isLate: boolean;
      assignment: { id: string; title: string; courseId: string };
    };

async function resolveSubmissionContext(
  assignmentId: string,
  studentId: string
): Promise<SubmissionContext> {
  const assignment = await prisma.assignment.findUnique({
    where: { id: assignmentId },
    select: {
      id: true,
      title: true,
      courseId: true,
      status: true,
      dueAt: true,
      allowLate: true,
      course: {
        select: {
          enrollments: { where: { studentId }, select: { id: true }, take: 1 },
          classroom: {
            select: {
              enrollments: { where: { studentId, status: "ACTIVE" }, select: { id: true }, take: 1 },
            },
          },
        },
      },
    },
  });

  if (!assignment) return { ok: false, message: "Tugas tidak ditemukan." };
  if (assignment.status !== "PUBLISHED") {
    return { ok: false, message: "Tugas ini belum dibuka untuk pengumpulan." };
  }

  const enrolled =
    assignment.course.enrollments.length > 0 ||
    (assignment.course.classroom?.enrollments.length ?? 0) > 0;
  if (!enrolled) return { ok: false, message: "Kamu tidak terdaftar pada kursus ini." };

  const isLate = assignment.dueAt !== null && new Date() > assignment.dueAt;
  if (isLate && !assignment.allowLate) {
    return {
      ok: false,
      message: "Tenggat sudah lewat dan pengumpulan terlambat tidak diizinkan.",
    };
  }

  return {
    ok: true,
    isLate,
    assignment: { id: assignment.id, title: assignment.title, courseId: assignment.courseId },
  };
}

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

  const assignmentId = String(formData.get("assignmentId") ?? "");
  const context = await resolveSubmissionContext(assignmentId, actor.id);
  if (!context.ok) return actionError(context.message);

  const { assignment, isLate } = context;

  const parsed = submissionSchema.safeParse({
    assignmentId,
    content: formData.get("content") ?? "",
    submit: formData.get("submit") !== "draft",
  });

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

  const data = parsed.data;

  // The attachment fields are derived from the uploaded file and never read
  // from the form. They used to be client-supplied, which let a student point
  // their own submission at an arbitrary storage key and then download it
  // through the file route under their own identity.
  let fileUrl: string | null = null;
  let fileName: string | null = null;
  let fileSize: number | null = null;

  const upload = formData.get("file");
  if (upload instanceof File && upload.size > 0) {
    try {
      const stored = await uploadFile({ file: upload, folder: "submissions" });
      fileUrl = stored.key;
      fileName = stored.originalName;
      fileSize = stored.size;
    } catch (error) {
      if (error instanceof StorageError) {
        return actionError(error.message, { file: error.message });
      }
      return actionError("Gagal mengunggah berkas.");
    }
  }

  const isSubmit = data.submit;
  const existing = await prisma.submission.findUnique({
    where: { assignmentId_studentId: { assignmentId, studentId: actor.id } },
    select: { id: true, status: true },
  });

  // Once graded, a student may not silently overwrite their work.
  if (existing && (existing.status === "GRADED" || existing.status === "RETURNED")) {
    return actionError("Pengumpulan ini sudah dinilai dan tidak dapat diubah lagi.");
  }

  const status = isSubmit ? (isLate ? ("LATE" as const) : ("SUBMITTED" as const)) : ("DRAFT" as const);

  await prisma.submission.upsert({
    where: { assignmentId_studentId: { assignmentId, studentId: actor.id } },
    create: {
      assignmentId,
      studentId: actor.id,
      content: data.content || null,
      fileUrl,
      fileName,
      fileSize,
      status,
      isLate,
      submittedAt: isSubmit ? new Date() : null,
    },
    update: {
      content: data.content || null,
      fileUrl,
      fileName,
      fileSize,
      status,
      isLate,
      submittedAt: isSubmit ? new Date() : null,
    },
  });

  if (isSubmit) {
    await awardXp({
      userId: actor.id,
      amount: 15,
      source: "ASSIGNMENT_SUBMIT",
      reason: `Mengumpulkan tugas: ${assignment.title}`,
      refType: "assignment",
      refId: assignmentId,
      idempotent: true,
    });
    await evaluateAchievements(actor.id);
  }

  await recordAudit({
    actorId: actor.id,
    action: isSubmit ? "SUBMISSION_SUBMITTED" : "SUBMISSION_DRAFT_SAVED",
    entity: "Submission",
    entityId: assignmentId,
    metadata: { isLate, hasFile: Boolean(fileUrl) },
  });

  revalidatePath(`/dashboard/assignments/${assignmentId}`);
  revalidatePath("/dashboard/assignments");
  revalidatePath(`/dashboard/courses/${assignment.courseId}`);
  revalidatePath("/dashboard");

  return actionSuccess(
    isSubmit
      ? isLate
        ? "Tugas dikumpulkan (terlambat)."
        : "Tugas berhasil dikumpulkan!"
      : "Draf disimpan."
  );
}

/** Remove the student's own submission, unless it has been graded. */
export async function withdrawSubmissionAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

  const assignmentId = String(formData.get("assignmentId") ?? "");
  const submission = await prisma.submission.findUnique({
    where: { assignmentId_studentId: { assignmentId, studentId: actor.id } },
    select: { id: true, status: true, assignment: { select: { courseId: true } } },
  });

  if (!submission) return actionError("Belum ada pengumpulan untuk ditarik.");
  if (submission.status === "GRADED" || submission.status === "RETURNED") {
    return actionError("Pengumpulan yang sudah dinilai tidak dapat ditarik.");
  }

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

  await recordAudit({
    actorId: actor.id,
    action: "SUBMISSION_WITHDRAWN",
    entity: "Submission",
    entityId: submission.id,
  });

  revalidatePath(`/dashboard/assignments/${assignmentId}`);
  revalidatePath(`/dashboard/courses/${submission.assignment.courseId}`);
  return actionSuccess("Pengumpulan ditarik.");
}

// ---------------------------------------------------------------------------
// Grading (teacher)
// ---------------------------------------------------------------------------

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

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

  const parsed = gradeSchema.safeParse({
    submissionId,
    score: formData.get("score"),
    feedback: formData.get("feedback") ?? "",
    returnToStudent: formData.get("returnToStudent") === "on" || formData.get("returnToStudent") === "true",
  });

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

  const data = parsed.data;

  const submission = await prisma.submission.findUnique({
    where: { id: submissionId },
    select: {
      studentId: true,
      score: true,
      assignment: {
        select: {
          id: true,
          title: true,
          type: true,
          maxScore: true,
          courseId: true,
        },
      },
    },
  });
  if (!submission) return actionError("Pengumpulan tidak ditemukan.");

  // A quiz marks itself, so this form is not how its score is set.
  //
  // The generic grader would write a score the quiz never produced, leaving
  // the gradebook disagreeing with the attempt the student actually sat —
  // exactly the state the reconciliation script had to repair. A quiz's own
  // per-answer form on the marked paper is the only way in, and it rewrites
  // the submission from the recomputed attempt total.
  if (submission.assignment.type === "QUIZ") {
    return actionError(
      "Kuis dinilai otomatis. Buka lembar percobaan siswa untuk menilai soal kode."
    );
  }

  if (data.score > submission.assignment.maxScore) {
    return actionError(
      `Nilai tidak boleh melebihi nilai maksimal (${submission.assignment.maxScore}).`,
      { score: "Nilai melebihi batas." }
    );
  }

  const isFirstGrade = submission.score === null;

  await prisma.submission.update({
    where: { id: submissionId },
    data: {
      score: Math.round(data.score),
      feedback: data.feedback || null,
      status: data.returnToStudent ? "RETURNED" : "GRADED",
      gradedById: actor.id,
      gradedAt: new Date(),
    },
  });

  // XP scales with the achieved percentage, capped so a 100/100 is worth 50 XP.
  if (isFirstGrade) {
    const percent = data.score / submission.assignment.maxScore;
    const xp = Math.round(percent * 50);
    await awardXp({
      userId: submission.studentId,
      amount: xp,
      source: "ASSIGNMENT_GRADE",
      reason: `Nilai tugas: ${submission.assignment.title} (${Math.round(data.score)}/${submission.assignment.maxScore})`,
      refType: "submission",
      refId: submissionId,
      idempotent: true,
    });
    await evaluateAchievements(submission.studentId);
  }

  await prisma.notification.create({
    data: {
      userId: submission.studentId,
      type: "GRADE",
      title: "Tugas telah dinilai",
      body: `${submission.assignment.title}: ${Math.round(data.score)}/${submission.assignment.maxScore}`,
      link: `/dashboard/assignments/${submission.assignment.id}`,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "SUBMISSION_GRADED",
    entity: "Submission",
    entityId: submissionId,
    metadata: { score: Math.round(data.score), maxScore: submission.assignment.maxScore },
  });

  revalidatePath("/dashboard/grading");
  revalidatePath(`/dashboard/grading/${submissionId}`);
  revalidatePath(`/dashboard/assignments/${submission.assignment.id}`);
  revalidatePath(`/dashboard/gradebook`);
  revalidatePath(`/dashboard/courses/${submission.assignment.courseId}`);
  revalidatePath("/dashboard");

  return actionSuccess("Penilaian disimpan dan siswa diberi tahu.");
}

/** Grade many submissions at once, e.g. from the queue. */
export async function bulkGradeAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  const assignmentId = String(formData.get("assignmentId") ?? "");
  const submissionIds = formData.getAll("submissionIds").map(String);

  if (submissionIds.length === 0) return actionError("Pilih setidaknya satu pengumpulan.");

  const assignment = await prisma.assignment.findUnique({
    where: { id: assignmentId },
    select: { id: true, title: true, maxScore: true, courseId: true },
  });
  if (!assignment) return actionError("Tugas tidak ditemukan.");

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

  // Each row carries its own score input: `score_<submissionId>`.
  const graded: string[] = [];
  for (const submissionId of submissionIds) {
    const raw = formData.get(`score_${submissionId}`);
    if (raw === null || String(raw).trim() === "") continue;

    const score = Number(raw);
    if (!Number.isFinite(score) || score < 0 || score > assignment.maxScore) continue;

    const feedback = formData.get(`feedback_${submissionId}`);

    // Scope the write to the assignment that was authorized. The id list comes
    // from the request body, so without this a teacher could name any
    // submission in the system and have it marked with their own id — the
    // `where` clause, not the surrounding guard, is what makes the ids safe.
    const updated = await prisma.submission.updateMany({
      where: { id: submissionId, assignmentId },
      data: {
        score: Math.round(score),
        feedback: typeof feedback === "string" && feedback.trim() ? feedback.trim() : null,
        status: "RETURNED",
        gradedById: actor.id,
        gradedAt: new Date(),
      },
    });
    if (updated.count > 0) graded.push(submissionId);
  }

  if (graded.length === 0) {
    return actionError("Tidak ada nilai valid yang bisa disimpan.");
  }

  await recordAudit({
    actorId: actor.id,
    action: "SUBMISSIONS_BULK_GRADED",
    entity: "Assignment",
    entityId: assignmentId,
    metadata: { count: graded.length },
  });

  revalidatePath("/dashboard/grading");
  revalidatePath(`/dashboard/assignments/${assignmentId}`);
  revalidatePath("/dashboard/gradebook");

  return actionSuccess(`${graded.length} pengumpulan dinilai.`);
}

/** Add a comment to a submission thread (student or teacher). */
export async function commentOnSubmissionAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Tidak diizinkan."));
  }

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

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

  const submission = await prisma.submission.findUnique({
    where: { id: submissionId },
    select: { studentId: true, assignment: { select: { courseId: true } } },
  });
  if (!submission) return actionError("Pengumpulan tidak ditemukan.");

  // Only the owning student (or staff on that course) may comment.
  if (submission.studentId !== actor.id) {
    try {
      await assertCourseManageable(submission.assignment.courseId);
    } catch {
      return actionError("Kamu tidak berhak mengomentari pengumpulan ini.");
    }
  }

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

  revalidatePath(`/dashboard/assignments/${submissionId}`);
  revalidatePath(`/dashboard/grading/${submissionId}`);
  return actionSuccess("Komentar ditambahkan.");
}
