"use server";

import { revalidatePath } from "next/cache";
import { prisma } from "@/lib/db";
import { authorize, authorizeTeacher, authorizeAdmin, canManageOwnedResource } from "@/lib/auth/rbac";
import { recordAudit } from "@/lib/audit";
import { awardXp, evaluateAchievements, grantSkillXp } from "@/lib/gamification";
import { runTestSuite, type TestCase } from "@/lib/runner";
import { runSimulator, configFromChallenge } from "@/lib/simulator";
import { codingProjectSchema, codingRunSchema, simulatorRunSchema, fieldErrors } from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import type { SessionUser } from "@/lib/auth/session";
import type { CodingLanguage, Prisma } from "@prisma/client";

/**
 * Coding lab and robot simulator mutations.
 *
 * Code execution happens server-side through `lib/runner` (JavaScript/Python) or
 * `lib/simulator` (the ROBOT pseudo-language). Results are persisted so a
 * learner's history and the teacher's analytics are both real data.
 */

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

/**
 * Convert a plain result object into Prisma's JSON input type.
 *
 * `Prisma.InputJsonValue` demands an index signature, which our precise result
 * interfaces deliberately do not have. These values are ordinary JSON data
 * (strings, numbers, booleans, arrays), so the widening is safe and confined to
 * this single boundary rather than loosening the interfaces themselves.
 */
function toJson(value: unknown): Prisma.InputJsonValue {
  return value as Prisma.InputJsonValue;
}

/** Coerce the `tests` JSON column into typed cases, ignoring malformed rows. */
function parseTests(value: unknown): TestCase[] {
  if (!Array.isArray(value)) return [];
  return value.flatMap((item) => {
    if (item && typeof item === "object" && "name" in item && "test" in item) {
      const name = item.name;
      const test = item.test;
      if (typeof name === "string" && typeof test === "string") return [{ name, test }];
    }
    return [];
  });
}

// ---------------------------------------------------------------------------
// Coding projects
// ---------------------------------------------------------------------------

/** Run a learner's code against a project's test suite and persist the result. */
export async function runCodingProjectAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Kamu harus masuk untuk menjalankan kode."));
  }

  const parsed = codingRunSchema.safeParse({
    projectId: formData.get("projectId"),
    code: formData.get("code"),
  });

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

  const project = await prisma.codingProject.findUnique({
    where: { id: parsed.data.projectId },
    select: {
      id: true,
      title: true,
      language: true,
      tests: true,
      xpReward: true,
      status: true,
      skills: { select: { skill: { select: { slug: true } }, xp: true } },
    },
  });

  if (!project) return actionError("Proyek tidak ditemukan.");
  if (project.status !== "PUBLISHED" && actor.role === "STUDENT") {
    return actionError("Proyek ini belum diterbitkan.");
  }

  const tests = parseTests(project.tests);
  const language = project.language as CodingLanguage;

  // A project with no tests still runs — we just report its stdout.
  const suite =
    tests.length === 0
      ? { results: [], passed: 0, total: 0, stdout: "" }
      : await runTestSuite(parsed.data.code, tests, language);

  const allPassed = tests.length > 0 && suite.passed === suite.total;
  const score = tests.length === 0 ? 0 : Math.round((suite.passed / suite.total) * 100);
  const status = allPassed ? ("PASSED" as const) : ("FAILED" as const);

  await prisma.codingSubmission.create({
    data: {
      projectId: project.id,
      studentId: actor.id,
      code: parsed.data.code,
      language,
      status,
      passedTests: suite.passed,
      totalTests: suite.total,
      testResults: toJson(suite.results),
      score,
      stdout: suite.stdout.slice(0, 20000),
    },
    select: { id: true },
  });

  let xpAwarded = 0;
  const unlockedSkills: string[] = [];

  if (allPassed) {
    // XP is idempotent per project, so re-running a solved project pays once.
    const result = await awardXp({
      userId: actor.id,
      amount: project.xpReward,
      source: "CODING_PROJECT",
      reason: `Menyelesaikan proyek coding: ${project.title}`,
      refType: "coding_project",
      refId: project.id,
      idempotent: true,
    });
    xpAwarded = result.awarded;

    for (const entry of project.skills) {
      const granted = await grantSkillXp({
        userId: actor.id,
        skillSlug: entry.skill.slug,
        xp: entry.xp,
      });
      if (granted) unlockedSkills.push(granted.skillName);
    }

    await evaluateAchievements(actor.id);
  }

  await recordAudit({
    actorId: actor.id,
    action: "CODING_PROJECT_RUN",
    entity: "CodingProject",
    entityId: project.id,
    metadata: { passed: suite.passed, total: suite.total, allPassed },
  });

  revalidatePath(`/dashboard/coding/${project.id}`);
  revalidatePath("/dashboard/coding");
  revalidatePath("/dashboard/skills");
  revalidatePath("/dashboard");

  const parts = [
    allPassed
      ? `Semua ${suite.total} pengujian lulus!`
      : `${suite.passed} dari ${suite.total} pengujian lulus.`,
  ];
  if (xpAwarded > 0) parts.push(`+${xpAwarded} XP`);
  if (unlockedSkills.length > 0) parts.push(`Keterampilan: ${unlockedSkills.join(", ")}`);

  return allPassed
    ? actionSuccess(parts.join(" · "))
    : actionError(parts.join(" · "));
}

/** Persist a run without asserting — used by the "Run" (not "Submit") button. */
export async function executeCodingSnippetAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Kamu harus masuk untuk menjalankan kode."));
  }

  const projectId = String(formData.get("projectId") ?? "");
  const code = String(formData.get("code") ?? "");
  if (!code.trim()) return actionError("Tulis kode terlebih dahulu.");

  const project = await prisma.codingProject.findUnique({
    where: { id: projectId },
    select: { id: true, language: true, tests: true },
  });
  if (!project) return actionError("Proyek tidak ditemukan.");

  const tests = parseTests(project.tests);
  const language = project.language as CodingLanguage;
  const suite =
    tests.length === 0
      ? { results: [], passed: 0, total: 0, stdout: "" }
      : await runTestSuite(code, tests, language);

  // Deliberately RUNNING, not PASSED/FAILED. "PASSED" is the marker every
  // solved-count and the XP/skill logic keys on (gamification, progress,
  // dashboard, lab summary all count `status: "PASSED"`), so recording a mere
  // test run as PASSED would mark the project solved — and credit the learner —
  // without ever pressing "Kirim Jawaban". RUNNING keeps a run out of those
  // counts; it is what distinguishes this button from the submit action.
  await prisma.codingSubmission.create({
    data: {
      projectId: project.id,
      studentId: actor.id,
      code,
      language,
      status: "RUNNING",
      passedTests: suite.passed,
      totalTests: suite.total,
      testResults: toJson(suite.results),
      score: tests.length === 0 ? 0 : Math.round((suite.passed / suite.total) * 100),
      stdout: suite.stdout.slice(0, 20000),
    },
  });

  revalidatePath(`/dashboard/coding/${project.id}`);
  return actionSuccess("Kode dijalankan.");
}

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

  // Tests arrive as parallel `testName[]` / `testBody[]` arrays.
  const testNames = formData.getAll("testName[]").map(String);
  const testBodies = formData.getAll("testBody[]").map(String);
  const tests = testNames
    .map((name, index) => ({ name: name.trim(), test: (testBodies[index] ?? "").trim() }))
    .filter((entry) => entry.name && entry.test);

  const parsed = codingProjectSchema.safeParse({
    title: formData.get("title"),
    description: formData.get("description") ?? "",
    brief: formData.get("brief") ?? "",
    language: formData.get("language") ?? "JAVASCRIPT",
    difficulty: formData.get("difficulty") ?? "BEGINNER",
    starterCode: formData.get("starterCode") ?? "",
    solutionCode: formData.get("solutionCode") ?? "",
    hints: String(formData.get("hints") ?? "")
      .split("\n")
      .map((line) => line.trim())
      .filter(Boolean),
    xpReward: formData.get("xpReward") ?? 50,
    status: formData.get("status") ?? "DRAFT",
    courseId: formData.get("courseId") ?? "",
    skillIds: formData.getAll("skillIds[]").map(String),
  });

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

  const data = parsed.data;
  const slug = await uniqueProjectSlug(data.title);

  // The course id arrives from the form; prove the actor may attach a project
  // to it, or a teacher could plant a project in another teacher's course.
  if (data.courseId) {
    const course = await prisma.course.findUnique({
      where: { id: data.courseId },
      select: { teacherId: true, classroom: { select: { teacherId: true } } },
    });
    const owns =
      course !== null &&
      (course.teacherId === actor.id ||
        course.classroom?.teacherId === actor.id ||
        actor.role === "ADMIN");
    if (!owns) {
      return actionError("Kursus yang dipilih bukan milikmu.");
    }
  }

  const project = await prisma.codingProject.create({
    data: {
      title: data.title,
      slug,
      description: data.description,
      brief: data.brief || null,
      language: data.language,
      difficulty: data.difficulty,
      starterCode: data.starterCode,
      solutionCode: data.solutionCode || null,
      hints: data.hints,
      xpReward: data.xpReward,
      status: data.status,
      courseId: data.courseId || null,
      createdById: actor.id,
      tests,
      skills: {
        create: data.skillIds.map((skillId) => ({ skillId, xp: 25 })),
      },
    },
    select: { id: true, title: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "CODING_PROJECT_CREATED",
    entity: "CodingProject",
    entityId: project.id,
    metadata: { title: project.title, tests: tests.length },
  });

  revalidatePath("/dashboard/coding");
  return actionSuccess(`Proyek "${project.title}" dibuat dengan ${tests.length} pengujian.`);
}

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

  const projectId = String(formData.get("projectId") ?? "");
  const existing = await prisma.codingProject.findUnique({
    where: { id: projectId },
    select: { createdById: true, title: true, slug: true },
  });
  if (!existing) return actionError("Proyek tidak ditemukan.");
  if (!canManageOwnedResource(actor, existing.createdById)) {
    return actionError("Kamu tidak berhak mengubah proyek ini.");
  }

  const testNames = formData.getAll("testName[]").map(String);
  const testBodies = formData.getAll("testBody[]").map(String);
  const tests = testNames
    .map((name, index) => ({ name: name.trim(), test: (testBodies[index] ?? "").trim() }))
    .filter((entry) => entry.name && entry.test);

  const parsed = codingProjectSchema.safeParse({
    title: formData.get("title"),
    description: formData.get("description") ?? "",
    brief: formData.get("brief") ?? "",
    language: formData.get("language") ?? "JAVASCRIPT",
    difficulty: formData.get("difficulty") ?? "BEGINNER",
    starterCode: formData.get("starterCode") ?? "",
    solutionCode: formData.get("solutionCode") ?? "",
    hints: String(formData.get("hints") ?? "")
      .split("\n")
      .map((line) => line.trim())
      .filter(Boolean),
    xpReward: formData.get("xpReward") ?? 50,
    status: formData.get("status") ?? "DRAFT",
    courseId: formData.get("courseId") ?? "",
    skillIds: formData.getAll("skillIds[]").map(String),
  });

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

  const data = parsed.data;
  const slug = data.title === existing.title ? existing.slug : await uniqueProjectSlug(data.title, projectId);

  await prisma.$transaction(async (tx) => {
    await tx.codingProject.update({
      where: { id: projectId },
      data: {
        title: data.title,
        slug,
        description: data.description,
        brief: data.brief || null,
        language: data.language,
        difficulty: data.difficulty,
        starterCode: data.starterCode,
        solutionCode: data.solutionCode || null,
        hints: data.hints,
        xpReward: data.xpReward,
        status: data.status,
        courseId: data.courseId || null,
        tests,
      },
    });

    // Replace the skill links wholesale — simpler and less error-prone than diffing.
    await tx.projectSkill.deleteMany({ where: { projectId } });
    if (data.skillIds.length > 0) {
      await tx.projectSkill.createMany({
        data: data.skillIds.map((skillId) => ({ projectId, skillId, xp: 25 })),
        skipDuplicates: true,
      });
    }
  });

  await recordAudit({
    actorId: actor.id,
    action: "CODING_PROJECT_UPDATED",
    entity: "CodingProject",
    entityId: projectId,
  });

  revalidatePath("/dashboard/coding");
  revalidatePath(`/dashboard/coding/${projectId}`);
  return actionSuccess("Proyek diperbarui.");
}

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

  const projectId = String(formData.get("projectId") ?? "");
  const existing = await prisma.codingProject.findUnique({
    where: { id: projectId },
    select: { createdById: true, _count: { select: { submissions: true } } },
  });
  if (!existing) return actionError("Proyek tidak ditemukan.");
  if (!canManageOwnedResource(actor, existing.createdById)) {
    return actionError("Kamu tidak berhak menghapus proyek ini.");
  }

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

  await recordAudit({
    actorId: actor.id,
    action: "CODING_PROJECT_DELETED",
    entity: "CodingProject",
    entityId: projectId,
    metadata: { submissions: existing._count.submissions },
  });

  revalidatePath("/dashboard/coding");
  return actionSuccess("Proyek dihapus.");
}

async function uniqueProjectSlug(title: string, excludeId?: string): Promise<string> {
  const base =
    title
      .toLowerCase()
      .replace(/[^a-z0-9\s-]/g, "")
      .trim()
      .replace(/\s+/g, "-")
      .slice(0, 60) || "proyek";

  let candidate = base;
  let suffix = 2;
  for (;;) {
    const clash = await prisma.codingProject.findUnique({
      where: { slug: candidate },
      select: { id: true },
    });
    if (!clash || clash.id === excludeId) return candidate;
    candidate = `${base}-${suffix}`;
    suffix += 1;
  }
}

// ---------------------------------------------------------------------------
// Robot simulator
// ---------------------------------------------------------------------------

export async function runSimulatorAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorize("STUDENT");
  } catch (error) {
    return actionError(messageOf(error, "Kamu harus masuk untuk menjalankan program."));
  }

  const parsed = simulatorRunSchema.safeParse({
    challengeId: formData.get("challengeId"),
    program: formData.get("program"),
  });

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

  const challenge = await prisma.simulatorChallenge.findUnique({
    where: { id: parsed.data.challengeId },
    select: {
      id: true,
      title: true,
      xpReward: true,
      status: true,
      gridWidth: true,
      gridHeight: true,
      walls: true,
      startX: true,
      startY: true,
      startDir: true,
      goalX: true,
      goalY: true,
      stars: true,
      maxSteps: true,
    },
  });

  if (!challenge) return actionError("Misi tidak ditemukan.");
  if (challenge.status !== "PUBLISHED" && actor.role === "STUDENT") {
    return actionError("Misi ini belum diterbitkan.");
  }

  // `runSimulator` is pure, so a malformed program is reported rather than thrown.
  const result = runSimulator(parsed.data.program, configFromChallenge(challenge));

  await prisma.simulatorAttempt.create({
    data: {
      challengeId: challenge.id,
      userId: actor.id,
      program: parsed.data.program,
      success: result.success,
      stepsUsed: result.stepsUsed,
      starsEarned: result.starsCollected,
      score: result.score,
      trace: toJson(result.trace.slice(0, 500)),
    },
  });

  let xpAwarded = 0;
  if (result.success) {
    const award = await awardXp({
      userId: actor.id,
      amount: challenge.xpReward,
      source: "SIMULATOR",
      reason: `Menyelesaikan misi simulator: ${challenge.title}`,
      refType: "simulator_challenge",
      refId: challenge.id,
      idempotent: true,
    });
    xpAwarded = award.awarded;
    await evaluateAchievements(actor.id);
  }

  await recordAudit({
    actorId: actor.id,
    action: "SIMULATOR_RUN",
    entity: "SimulatorChallenge",
    entityId: challenge.id,
    metadata: {
      success: result.success,
      stepsUsed: result.stepsUsed,
      stars: result.starsCollected,
    },
  });

  revalidatePath(`/dashboard/lab/${challenge.id}`);
  revalidatePath("/dashboard/lab");
  revalidatePath("/dashboard");

  if (result.error) {
    return actionError(result.error);
  }

  if (!result.success) {
    return actionError(result.message);
  }

  const parts = [result.message];
  if (xpAwarded > 0) parts.push(`+${xpAwarded} XP`);

  return actionSuccess(parts.join(" · "));
}

export async function createSimulatorChallengeAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor: SessionUser;
  try {
    actor = await authorizeAdmin();
  } catch (error) {
    return actionError(messageOf(error, "Hanya administrator yang dapat membuat misi."));
  }

  const title = String(formData.get("title") ?? "").trim();
  if (title.length < 3) {
    return actionError("Judul misi minimal 3 karakter.", { title: "Judul terlalu pendek." });
  }

  const gridWidth = clampInt(formData.get("gridWidth"), 3, 20, 8);
  const gridHeight = clampInt(formData.get("gridHeight"), 3, 20, 8);
  const startX = clampInt(formData.get("startX"), 0, gridWidth - 1, 0);
  const startY = clampInt(formData.get("startY"), 0, gridHeight - 1, 0);
  const goalX = clampInt(formData.get("goalX"), 0, gridWidth - 1, gridWidth - 1);
  const goalY = clampInt(formData.get("goalY"), 0, gridHeight - 1, gridHeight - 1);
  const maxSteps = clampInt(formData.get("maxSteps"), 10, 500, 60);
  const parSteps = clampInt(formData.get("parSteps"), 1, maxSteps, Math.min(20, maxSteps));

  const walls = parseCoordinateLines(String(formData.get("walls") ?? ""), gridWidth, gridHeight);
  const stars = parseCoordinateLines(String(formData.get("stars") ?? ""), gridWidth, gridHeight);

  const slug = await uniqueChallengeSlug(title);

  const challenge = await prisma.simulatorChallenge.create({
    data: {
      slug,
      title,
      description: String(formData.get("description") ?? ""),
      difficulty: (String(formData.get("difficulty") ?? "BEGINNER") as "BEGINNER" | "INTERMEDIATE" | "ADVANCED"),
      gridWidth,
      gridHeight,
      walls,
      startX,
      startY,
      startDir: String(formData.get("startDir") ?? "east"),
      goalX,
      goalY,
      stars,
      maxSteps,
      parSteps,
      starterCode: String(formData.get("starterCode") ?? ""),
      solutionCode: String(formData.get("solutionCode") ?? "") || null,
      hints: String(formData.get("hints") ?? "")
        .split("\n")
        .map((line) => line.trim())
        .filter(Boolean),
      xpReward: clampInt(formData.get("xpReward"), 0, 1000, 40),
      status: (String(formData.get("status") ?? "PUBLISHED") as "DRAFT" | "PUBLISHED" | "ARCHIVED"),
    },
    select: { id: true, title: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "SIMULATOR_CHALLENGE_CREATED",
    entity: "SimulatorChallenge",
    entityId: challenge.id,
    metadata: { title: challenge.title },
  });

  revalidatePath("/dashboard/lab");
  return actionSuccess(`Misi "${challenge.title}" dibuat.`);
}

/** Clamp a numeric form field into an inclusive range. */
function clampInt(value: FormDataEntryValue | null, min: number, max: number, fallback: number): number {
  const parsed = Number(value);
  if (!Number.isFinite(parsed)) return fallback;
  return Math.min(max, Math.max(min, Math.round(parsed)));
}

/** Parse "x,y" lines into coordinate pairs, dropping out-of-bounds entries. */
function parseCoordinateLines(text: string, width: number, height: number): [number, number][] {
  return text
    .split(/\r?\n/)
    .map((line) => line.trim())
    .filter(Boolean)
    .flatMap((line) => {
      const [rawX, rawY] = line.split(",").map((part) => Number(part.trim()));
      if (!Number.isFinite(rawX) || !Number.isFinite(rawY)) return [];
      const x = Math.round(rawX);
      const y = Math.round(rawY);
      if (x < 0 || x >= width || y < 0 || y >= height) return [];
      return [[x, y] as [number, number]];
    });
}

async function uniqueChallengeSlug(title: string): Promise<string> {
  const base =
    title
      .toLowerCase()
      .replace(/[^a-z0-9\s-]/g, "")
      .trim()
      .replace(/\s+/g, "-")
      .slice(0, 60) || "misi";

  let candidate = base;
  let suffix = 2;
  for (;;) {
    const clash = await prisma.simulatorChallenge.findUnique({
      where: { slug: candidate },
      select: { id: true },
    });
    if (!clash) return candidate;
    candidate = `${base}-${suffix}`;
    suffix += 1;
  }
}
