"use server";

import { revalidatePath } from "next/cache";
import { prisma } from "@/lib/db";
import { authorizeAdmin } from "@/lib/auth/rbac";
import { recordAudit } from "@/lib/audit";
import { knowledgeEntrySchema, fieldErrors } from "@/lib/validation";
import { actionError, actionSuccess, type ActionState } from "@/lib/action-state";
import { rankEntries, type RankableEntry } from "@/lib/ai/knowledge";
import { loadRankableEntries } from "@/lib/queries/knowledge";

/**
 * Assistant knowledge management.
 *
 * Every action re-authorizes as ADMIN server-side. The knowledge base is public
 * facing, so a bad edit here is visible to every visitor — changes are audited
 * and the console can preview the effect before publishing.
 */

const AI_PATH = "/dashboard/ai";

function revalidateKnowledgeViews(): void {
  revalidatePath(AI_PATH);
}

/**
 * Read the published flag from a form.
 *
 * An unchecked checkbox submits nothing at all, so absence means "off" rather
 * than "unset" — the field is always explicitly on or off.
 */
function publishedFromForm(formData: FormData): boolean {
  return formData.get("published") === "true";
}

export async function createKnowledgeAction(
  _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 = knowledgeEntrySchema.safeParse({
    topic: formData.get("topic"),
    keywords: formData.get("keywords"),
    answer: formData.get("answer"),
    priority: formData.get("priority"),
    published: publishedFromForm(formData),
  });

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

  const entry = await prisma.knowledgeEntry.create({
    data: {
      topic: parsed.data.topic,
      keywords: parsed.data.keywords,
      answer: parsed.data.answer,
      priority: parsed.data.priority,
      published: parsed.data.published,
      createdById: actor.id,
    },
    select: { id: true },
  });

  await recordAudit({
    actorId: actor.id,
    action: "KNOWLEDGE_CREATE",
    entity: "KnowledgeEntry",
    entityId: entry.id,
    metadata: { topic: parsed.data.topic },
  });

  revalidateKnowledgeViews();
  return actionSuccess("Pengetahuan berhasil ditambahkan.");
}

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

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

  const existing = await prisma.knowledgeEntry.findUnique({
    where: { id },
    select: { id: true, topic: true },
  });
  if (!existing) return actionError("Pengetahuan tidak ditemukan.");

  const parsed = knowledgeEntrySchema.safeParse({
    topic: formData.get("topic"),
    keywords: formData.get("keywords"),
    answer: formData.get("answer"),
    priority: formData.get("priority"),
    published: publishedFromForm(formData),
  });

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

  await prisma.knowledgeEntry.update({
    where: { id },
    data: {
      topic: parsed.data.topic,
      keywords: parsed.data.keywords,
      answer: parsed.data.answer,
      priority: parsed.data.priority,
      published: parsed.data.published,
    },
  });

  await recordAudit({
    actorId: actor.id,
    action: "KNOWLEDGE_UPDATE",
    entity: "KnowledgeEntry",
    entityId: id,
    metadata: { from: existing.topic, to: parsed.data.topic },
  });

  revalidateKnowledgeViews();
  return actionSuccess("Perubahan disimpan.");
}

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

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

  const existing = await prisma.knowledgeEntry.findUnique({
    where: { id },
    select: { topic: true },
  });
  if (!existing) return actionError("Pengetahuan tidak ditemukan.");

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

  await recordAudit({
    actorId: actor.id,
    action: "KNOWLEDGE_DELETE",
    entity: "KnowledgeEntry",
    entityId: id,
    metadata: { topic: existing.topic },
  });

  revalidateKnowledgeViews();
  return actionSuccess(`"${existing.topic}" dihapus.`);
}

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

  const id = String(formData.get("id") ?? "");
  const published = String(formData.get("published") ?? "") === "true";
  if (!id) return actionError("Pengetahuan tidak ditemukan.");

  const existing = await prisma.knowledgeEntry.findUnique({
    where: { id },
    select: { topic: true },
  });
  if (!existing) return actionError("Pengetahuan tidak ditemukan.");

  await prisma.knowledgeEntry.update({ where: { id }, data: { published } });

  await recordAudit({
    actorId: actor.id,
    action: published ? "KNOWLEDGE_PUBLISH" : "KNOWLEDGE_UNPUBLISH",
    entity: "KnowledgeEntry",
    entityId: id,
    metadata: { topic: existing.topic },
  });

  revalidateKnowledgeViews();
  return actionSuccess(published ? "Pengetahuan diaktifkan." : "Pengetahuan dinonaktifkan.");
}

/** Dismiss a logged gap once an entry has been written for it. */
export async function resolveUnansweredAction(
  _previous: ActionState,
  formData: FormData
): Promise<ActionState> {
  let actor;
  try {
    actor = await authorizeAdmin();
  } catch (error) {
    return actionError(error instanceof Error ? error.message : "Tidak diizinkan.");
  }

  const id = String(formData.get("id") ?? "");
  const resolved = String(formData.get("resolved") ?? "true") === "true";
  if (!id) return actionError("Pertanyaan tidak ditemukan.");

  const existing = await prisma.unansweredQuestion.findUnique({
    where: { id },
    select: { question: true },
  });
  if (!existing) return actionError("Pertanyaan tidak ditemukan.");

  await prisma.unansweredQuestion.update({
    where: { id },
    data: { resolvedAt: resolved ? new Date() : null },
  });

  await recordAudit({
    actorId: actor.id,
    action: resolved ? "UNANSWERED_RESOLVE" : "UNANSWERED_REOPEN",
    entity: "UnansweredQuestion",
    entityId: id,
    metadata: { question: existing.question.slice(0, 120) },
  });

  revalidateKnowledgeViews();
  return actionSuccess(resolved ? "Ditandai selesai." : "Dibuka kembali.");
}

export interface PreviewResult {
  answer: string | null;
  sources: { id: string; label: string }[];
  mode: "ai" | "kb";
}

/**
 * Dry-run a question against the live knowledge base.
 *
 * Uses the same ranker as the public endpoint, so the admin sees exactly what a
 * visitor would get — including the unanswered path.
 */
export async function previewAnswerAction(question: string): Promise<PreviewResult> {
  await authorizeAdmin();

  const clean = question.trim().slice(0, 600);
  if (clean.length === 0) return { answer: null, sources: [], mode: "kb" };

  const entries: RankableEntry[] = await loadRankableEntries();
  const matches = rankEntries(entries, clean);

  if (matches.length === 0) return { answer: null, sources: [], mode: "kb" };

  const chosen = matches.slice(0, 2);
  return {
    answer: chosen.map((m) => m.entry.answer).join("\n\n"),
    sources: chosen.map((m) => ({ id: m.entry.id, label: m.entry.topic })),
    mode: "kb",
  };
}
