"use server";

import { revalidatePath } from "next/cache";
import { prisma } from "@/lib/db";
import type { AccountStatus } from "@prisma/client";
import { authorizeAdmin } from "@/lib/auth/rbac";
import { hashPassword } from "@/lib/auth/password";
import { destroyAllSessionsForUser } from "@/lib/auth/session";
import { recordAudit } from "@/lib/audit";
import {
  adminCreateUserSchema,
  adminUpdateUserSchema,
  adminResetPasswordSchema,
  fieldErrors,
} from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";

/**
 * Administrative user management.
 *
 * Every action re-authorizes as ADMIN server-side. Guard rails prevent an
 * administrator from locking themselves out: they may not suspend, delete or
 * demote their own account, and a user who authored courses, assignments,
 * projects, classes or attendance sessions cannot be deleted (Prisma enforces
 * `onDelete: Restrict` on those relations).
 */

const USERS_PATH = "/dashboard/users";

/** Statuses an administrator may assign to an account. */
const MANAGED_STATUSES: Record<string, true> = {
  ACTIVE: true,
  SUSPENDED: true,
  PENDING: true,
};

function revalidateUserViews(userId?: string): void {
  revalidatePath(USERS_PATH);
  revalidatePath("/dashboard/audit");
  if (userId) revalidatePath(`${USERS_PATH}/${userId}`);
}

const STATUS_ACTION_LABEL: Record<AccountStatus, string> = {
  ACTIVE: "diaktifkan",
  SUSPENDED: "ditangguhkan",
  PENDING: "dijadikan menunggu aktivasi",
};

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

  const parsed = adminCreateUserSchema.safeParse({
    username: formData.get("username"),
    fullName: formData.get("fullName"),
    email: formData.get("email") ?? "",
    password: formData.get("password"),
    role: formData.get("role") ?? "STUDENT",
    status: formData.get("status") ?? "ACTIVE",
    school: formData.get("school") ?? "",
    gradeLevel: formData.get("gradeLevel") ?? "",
  });

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

  const data = parsed.data;
  const email = data.email || null;

  const clash = await prisma.user.findFirst({
    where: { OR: [{ username: data.username }, ...(email ? [{ email }] : [])] },
    select: { username: true, email: true },
  });

  if (clash) {
    const errors: Record<string, string> = {};
    if (clash.username === data.username) errors.username = "Username sudah digunakan.";
    if (email && clash.email === email) errors.email = "Email sudah terdaftar.";
    return actionError("Pengguna dengan data tersebut sudah ada.", errors);
  }

  try {
    const passwordHash = await hashPassword(data.password);
    const created = await prisma.user.create({
      data: {
        username: data.username,
        fullName: data.fullName,
        email,
        passwordHash,
        role: data.role,
        status: data.status,
        school: data.school || null,
        gradeLevel: data.gradeLevel || null,
      },
      select: { id: true, username: true, fullName: true },
    });

    await recordAudit({
      actorId: actor.id,
      action: "USER_CREATED",
      entity: "User",
      entityId: created.id,
      metadata: { username: created.username, role: data.role, status: data.status },
    });

    revalidateUserViews(created.id);
    return actionSuccess(`Pengguna "${created.fullName}" berhasil dibuat.`);
  } catch {
    return actionError("Gagal membuat pengguna. Coba lagi.");
  }
}

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

  const parsed = adminUpdateUserSchema.safeParse({
    userId: formData.get("userId"),
    fullName: formData.get("fullName"),
    email: formData.get("email") ?? "",
    role: formData.get("role"),
    status: formData.get("status"),
    school: formData.get("school") ?? "",
    gradeLevel: formData.get("gradeLevel") ?? "",
  });

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

  const data = parsed.data;

  // Guard rail: an admin must not lock themselves out of the console.
  if (data.userId === actor.id) {
    if (data.role !== "ADMIN") {
      return actionError("Kamu tidak dapat menurunkan peran akunmu sendiri.");
    }
    if (data.status !== "ACTIVE") {
      return actionError("Kamu tidak dapat menangguhkan akunmu sendiri.");
    }
  }

  const target = await prisma.user.findUnique({
    where: { id: data.userId },
    select: { id: true, status: true },
  });
  if (!target) return actionError("Pengguna tidak ditemukan.");

  const email = data.email || null;
  if (email) {
    const clash = await prisma.user.findFirst({
      where: { email, id: { not: data.userId } },
      select: { id: true },
    });
    if (clash) {
      return actionError("Email sudah terdaftar.", { email: "Email sudah terdaftar." });
    }
  }

  try {
    await prisma.user.update({
      where: { id: data.userId },
      data: {
        fullName: data.fullName,
        email,
        role: data.role,
        status: data.status,
        school: data.school || null,
        gradeLevel: data.gradeLevel || null,
      },
    });

    // A user who is no longer active must lose their live sessions.
    if (data.status !== "ACTIVE" && target.status === "ACTIVE") {
      await destroyAllSessionsForUser(data.userId);
    }

    await recordAudit({
      actorId: actor.id,
      action: "USER_UPDATED",
      entity: "User",
      entityId: data.userId,
      metadata: { role: data.role, status: data.status },
    });

    revalidateUserViews(data.userId);
    return actionSuccess(`Data "${data.fullName}" berhasil diperbarui.`);
  } catch {
    return actionError("Gagal memperbarui pengguna. Coba lagi.");
  }
}

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

  const parsed = adminResetPasswordSchema.safeParse({
    userId: formData.get("userId"),
    newPassword: formData.get("newPassword"),
  });

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

  const { userId, newPassword } = parsed.data;

  const target = await prisma.user.findUnique({
    where: { id: userId },
    select: { id: true, fullName: true },
  });
  if (!target) return actionError("Pengguna tidak ditemukan.");

  try {
    const passwordHash = await hashPassword(newPassword);
    await prisma.user.update({ where: { id: userId }, data: { passwordHash } });
    await destroyAllSessionsForUser(userId);

    await recordAudit({
      actorId: actor.id,
      action: "USER_PASSWORD_RESET",
      entity: "User",
      entityId: userId,
    });

    revalidateUserViews(userId);
    return actionSuccess(
      `Kata sandi "${target.fullName}" telah direset. Semua sesi pengguna tersebut diakhiri.`
    );
  } catch {
    return actionError("Gagal mereset kata sandi. Coba lagi.");
  }
}

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

  const userId = String(formData.get("userId") ?? "");
  const status = String(formData.get("status") ?? "");

  if (!userId) return actionError("Pengguna tidak ditemukan.");
  if (!MANAGED_STATUSES[status]) return actionError("Status akun tidak valid.");

  const nextStatus = status as AccountStatus;

  // Guard rail: an admin must not suspend or deactivate their own account.
  if (userId === actor.id && nextStatus !== "ACTIVE") {
    return actionError("Kamu tidak dapat menangguhkan akunmu sendiri.");
  }

  const target = await prisma.user.findUnique({
    where: { id: userId },
    select: { id: true, fullName: true, status: true },
  });
  if (!target) return actionError("Pengguna tidak ditemukan.");

  if (target.status === nextStatus) {
    // Already in the requested state. Still enforce the invariant that an
    // inactive account holds no live sessions — a session could have been
    // issued before the status changed by another path.
    if (nextStatus !== "ACTIVE") await destroyAllSessionsForUser(userId);
    return actionSuccess(`Status "${target.fullName}" sudah ${STATUS_ACTION_LABEL[nextStatus]}.`);
  }

  try {
    await prisma.user.update({ where: { id: userId }, data: { status: nextStatus } });

    if (nextStatus !== "ACTIVE") {
      await destroyAllSessionsForUser(userId);
    }

    await recordAudit({
      actorId: actor.id,
      action: "USER_STATUS_CHANGED",
      entity: "User",
      entityId: userId,
      metadata: { from: target.status, to: nextStatus },
    });

    revalidateUserViews(userId);
    return actionSuccess(
      `Akun "${target.fullName}" berhasil ${STATUS_ACTION_LABEL[nextStatus]}.`
    );
  } catch {
    return actionError("Gagal mengubah status akun. Coba lagi.");
  }
}

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

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

  // Guard rail: an admin must not delete their own account.
  if (userId === actor.id) {
    return actionError("Kamu tidak dapat menghapus akunmu sendiri.");
  }

  const target = await prisma.user.findUnique({
    where: { id: userId },
    select: { id: true, fullName: true, username: true, role: true },
  });
  if (!target) return actionError("Pengguna tidak ditemukan.");

  // Prisma enforces `onDelete: Restrict` on every authored relation, so a
  // teacher or author cannot be removed while their work still references
  // them. Checking first yields a precise message naming what blocks the
  // delete, instead of surfacing a raw driver error.
  const authored = await prisma.user.findUnique({
    where: { id: userId },
    select: {
      _count: {
        select: {
          taughtClasses: true,
          createdCourses: true,
          createdAssignments: true,
          createdProjects: true,
          attendanceSessions: true,
        },
      },
    },
  });

  const blockers = authored
    ? [
        [authored._count.taughtClasses, "kelas"],
        [authored._count.createdCourses, "kursus"],
        [authored._count.createdAssignments, "tugas"],
        [authored._count.createdProjects, "proyek coding"],
        [authored._count.attendanceSessions, "sesi absensi"],
      ]
        .filter(([count]) => (count as number) > 0)
        .map(([count, label]) => `${count} ${label}`)
    : [];

  if (blockers.length > 0) {
    return actionError(
      `Pengguna ini tidak dapat dihapus karena masih menautkan ${blockers.join(", ")}. Pindahkan atau hapus data tersebut terlebih dahulu.`
    );
  }

  try {
    await prisma.user.delete({ where: { id: userId } });
  } catch (error) {
    // Belt and braces: a concurrent insert can still trip the constraint
    // between the check above and the delete. Prisma reports Postgres RESTRICT
    // violations as an unknown request error rather than P2003, so the message
    // itself is inspected.
    const message = error instanceof Error ? error.message : "";
    if (message.includes("23001") || /RESTRICT setting of foreign key/i.test(message)) {
      return actionError(
        "Pengguna ini tidak dapat dihapus karena masih terkait dengan data yang dibuatnya. Pindahkan atau hapus data tersebut terlebih dahulu."
      );
    }
    return actionError("Gagal menghapus pengguna. Coba lagi.");
  }

  await recordAudit({
    actorId: actor.id,
    action: "USER_DELETED",
    entity: "User",
    entityId: userId,
    metadata: { username: target.username, role: target.role },
  });

  revalidateUserViews();
  return actionSuccess(`Pengguna "${target.fullName}" telah dihapus.`);
}
