"use server";

import { revalidatePath } from "next/cache";
import { prisma } from "@/lib/db";
import { authorizeTeacher } from "@/lib/auth/rbac";
import type { SessionUser } from "@/lib/auth/session";
import { recordAudit } from "@/lib/audit";
import { announcementSchema, fieldErrors } from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";

/**
 * Announcement mutations.
 *
 * Publishing fans out an ANNOUNCEMENT notification to every affected student.
 * Only the author (or an admin) may edit or delete a post; that rule is
 * re-checked inside every mutating action rather than trusted from the page.
 */

/** Confirm the actor may mutate a given announcement. */
async function assertAnnouncementManageable(announcementId: string) {
  const actor = await authorizeTeacher();
  const announcement = await prisma.announcement.findUnique({
    where: { id: announcementId },
    select: { id: true, authorId: true, title: true },
  });
  if (!announcement) throw new Error("Pengumuman tidak ditemukan.");

  if (actor.role !== "ADMIN" && announcement.authorId !== actor.id) {
    throw new Error("Hanya penulis atau administrator yang dapat mengubah pengumuman ini.");
  }
  return { actor, announcement };
}

/**
 * Whether the actor may address an announcement to this class/course.
 *
 * Both ids arrive from the request body. The compose dialog only lists targets
 * the actor owns, but a filtered dropdown is not an authorization check — the
 * server has to re-derive it. Admins may address anything.
 */
async function canTargetAnnouncement(
  actor: SessionUser,
  classId: string | null,
  courseId: string | null
): Promise<boolean> {
  if (actor.role === "ADMIN") return true;
  if (!classId && !courseId) return true; // site-wide post

  if (classId) {
    const classroom = await prisma.classroom.findUnique({
      where: { id: classId },
      select: { teacherId: true },
    });
    return classroom?.teacherId === actor.id;
  }

  const course = await prisma.course.findUnique({
    where: { id: courseId as string },
    select: { teacherId: true, classroom: { select: { teacherId: true } } },
  });
  if (!course) return false;
  return course.teacherId === actor.id || course.classroom?.teacherId === actor.id;
}

/** Everyone a given announcement reaches, deduplicated. */
async function resolveAudience(
  classId: string | null,
  courseId: string | null
): Promise<string[]> {
  if (classId) {
    const enrollments = await prisma.classEnrollment.findMany({
      where: { classId, status: "ACTIVE" },
      select: { studentId: true },
    });
    return enrollments.map((row) => row.studentId);
  }

  if (courseId) {
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { courseId, status: "ACTIVE" },
      select: { studentId: true },
    });
    return enrollments.map((row) => row.studentId);
  }

  // School-wide: every active student.
  const students = await prisma.user.findMany({
    where: { role: "STUDENT", status: "ACTIVE" },
    select: { id: true },
  });
  return students.map((row) => row.id);
}

/** Notify every affected student that a new announcement is up. */
async function notifyAudience(
  announcementId: string,
  title: string,
  classId: string | null,
  courseId: string | null
): Promise<void> {
  const recipientIds = await resolveAudience(classId, courseId);
  if (recipientIds.length === 0) return;

  await prisma.notification.createMany({
    data: recipientIds.map((userId) => ({
      userId,
      type: "ANNOUNCEMENT" as const,
      title: "Pengumuman baru",
      body: title,
      link: `/dashboard/announcements#${announcementId}`,
    })),
  });
}

function revalidateAnnouncementRoutes(): void {
  revalidatePath("/dashboard/announcements");
  revalidatePath("/dashboard/notifications");
  revalidatePath("/dashboard");
}

export async function createAnnouncementAction(
  _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 = announcementSchema.safeParse({
    title: formData.get("title"),
    body: formData.get("body"),
    classId: formData.get("classId") ?? "",
    courseId: formData.get("courseId") ?? "",
    pinned: formData.get("pinned") === "on" || formData.get("pinned") === "true",
  });

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

  const data = parsed.data;
  const classId = data.classId || null;
  const courseId = data.courseId || null;

  if (classId && courseId) {
    return actionError("Pilih salah satu sasaran: kelas atau kursus, bukan keduanya.", {
      classId: "Hanya satu sasaran yang boleh dipilih.",
    });
  }

  // A teacher may only broadcast into their own class or course. The id comes
  // from the form and the dropdown is merely filtered on the client, so without
  // this a teacher could post into another teacher's class, notifying every
  // student in it.
  if (!(await canTargetAnnouncement(actor, classId, courseId))) {
    return actionError("Kamu hanya dapat mengirim pengumuman ke kelas atau kursusmu sendiri.");
  }

  const announcement = await prisma.announcement.create({
    data: {
      title: data.title,
      body: data.body,
      authorId: actor.id,
      classId,
      courseId,
      pinned: data.pinned,
    },
    select: { id: true, title: true },
  });

  await notifyAudience(announcement.id, announcement.title, classId, courseId);

  await recordAudit({
    actorId: actor.id,
    action: "ANNOUNCEMENT_CREATED",
    entity: "Announcement",
    entityId: announcement.id,
    metadata: { title: announcement.title, classId, courseId, pinned: data.pinned },
  });

  revalidateAnnouncementRoutes();
  return actionSuccess(`Pengumuman "${announcement.title}" diterbitkan.`);
}

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

  let actor: SessionUser;
  try {
    const context = await assertAnnouncementManageable(announcementId);
    actor = context.actor;
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const parsed = announcementSchema.safeParse({
    title: formData.get("title"),
    body: formData.get("body"),
    classId: formData.get("classId") ?? "",
    courseId: formData.get("courseId") ?? "",
    pinned: formData.get("pinned") === "on" || formData.get("pinned") === "true",
  });

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

  const data = parsed.data;
  const classId = data.classId || null;
  const courseId = data.courseId || null;

  if (classId && courseId) {
    return actionError("Pilih salah satu sasaran: kelas atau kursus, bukan keduanya.", {
      classId: "Hanya satu sasaran yang boleh dipilih.",
    });
  }

  // Retargeting must obey the same rule as creating: an author may not move
  // their post into a class or course they do not own.
  if (!(await canTargetAnnouncement(actor, classId, courseId))) {
    return actionError("Kamu hanya dapat mengirim pengumuman ke kelas atau kursusmu sendiri.");
  }

  await prisma.announcement.update({
    where: { id: announcementId },
    data: {
      title: data.title,
      body: data.body,
      classId,
      courseId,
      pinned: data.pinned,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "ANNOUNCEMENT_UPDATED",
    entity: "Announcement",
    entityId: announcementId,
    metadata: { title: data.title, classId, courseId, pinned: data.pinned },
  });

  revalidateAnnouncementRoutes();
  return actionSuccess("Perubahan pengumuman disimpan.");
}

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

  try {
    const { actor, announcement } = await assertAnnouncementManageable(announcementId);
    await prisma.announcement.delete({ where: { id: announcementId } });
    await recordAudit({
      actorId: actor.id,
      action: "ANNOUNCEMENT_DELETED",
      entity: "Announcement",
      entityId: announcementId,
      metadata: { title: announcement.title },
    });
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  revalidateAnnouncementRoutes();
  return actionSuccess("Pengumuman dihapus.");
}

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

  try {
    const { actor, announcement } = await assertAnnouncementManageable(announcementId);
    const current = await prisma.announcement.findUniqueOrThrow({
      where: { id: announcementId },
      select: { pinned: true },
    });
    const pinned = !current.pinned;

    await prisma.announcement.update({
      where: { id: announcementId },
      data: { pinned },
    });

    await recordAudit({
      actorId: actor.id,
      action: pinned ? "ANNOUNCEMENT_PINNED" : "ANNOUNCEMENT_UNPINNED",
      entity: "Announcement",
      entityId: announcementId,
      metadata: { title: announcement.title },
    });

    revalidateAnnouncementRoutes();
    return actionSuccess(pinned ? "Pengumuman disematkan." : "Sematan pengumuman dilepas.");
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }
}
