import { invalidateProjects } from "@/lib/projects";
import { withEditNotes } from "@/lib/report/guard";
import {
  StaleToken,
  StructureRefused,
  duplicateEntry,
  insertEntry,
  manifestToken,
  moveEntry,
  removeEntry,
  removePost,
  undoStructural,
  updateFactcheck,
  updateTeaser,
  upsertPost,
} from "@/lib/report/manifest.mjs";
import { resolveReport } from "@/lib/report/serve.mjs";
import { deckOn } from "umtool-report-to-video/deck";
import { VERDICTS, resolveFactcheck } from "umtool-report-to-video/factcheck";

export const dynamic = "force-dynamic";

// The STRUCTURE of the cut: what is in the timeline and in what order, a
// teaser's lines, the posts, the fact-check's labels (lib/report/manifest.mjs,
// "STRUCTURE"). The window route deliberately cannot move an entry; this is
// the different button it points at.
//
// GET  ?project=<id>                  the token, the timeline's ids in order, the
//                                     teasers, the posts and the fact-check block
// POST { project, token, op, ... }    one op:
//   move       { id, at?, toIndex }          toIndex is the index AFTER the move
//   remove     { id, at? }
//   duplicate  { id, at? }
//   insert     { afterId: id | null, at?, entry: "<channel>/<video>@<start>-<end>" | { type, … } }
//   teaser     { id, at?, patch: { lines?, beat?, dip?, tail?, tailWait? } }
//   post       { post: { id, platform, date, text, url, … } }   add or replace
//   post-remove { id }
//   factcheck  { factcheck: { verdicts?, stamp?, tally? } | null }
//   undo       {}                              restore the newest auto snapshot
//
// Every op snapshots the manifest first (`revisions/<stamp>-auto-before-<op>`),
// is checked by the build's own validators, and on a GENERATED manifest leaves
// an `edit` note for the agent (lib/report/guard.ts). A stale token is a 409.

type Body = Record<string, unknown>;
const noStore = { "cache-control": "no-store" };

export async function GET(request: Request) {
  const url = new URL(request.url);
  const r = await resolveReport(url.searchParams.get("project") ?? "");
  if ("error" in r) return Response.json({ error: r.error }, { status: r.status });
  const entries = (r.manifest.timeline ?? []) as Record<string, unknown>[];
  const timeline = entries.map((e) => ({ id: String(e.id), type: String(e.type ?? "entry") }));
  // What the structure editors edit: each teaser as written, the posts, and
  // the fact-check block with every default filled (the form's placeholders).
  const teasers = entries
    .map((e, at) => ({ e, at }))
    .filter(({ e }) => e.type === "teaser")
    .map(({ e, at }) => ({ at, id: String(e.id), lines: e.lines ?? [], beat: e.beat ?? null, dip: e.dip ?? null, tail: e.tail ?? null, tailWait: e.tailWait ?? null }));
  const render = (r.manifest.render ?? {}) as Record<string, unknown>;
  return Response.json(
    {
      timeline,
      teasers,
      posts: Array.isArray(r.manifest.posts) ? r.manifest.posts : [],
      deckOn: deckOn(render),
      factcheck: (render.chrome as { factcheck?: unknown } | undefined)?.factcheck ?? null,
      factcheckResolved: resolveFactcheck(render),
      verdicts: VERDICTS,
      generatedBy: r.manifest.generatedBy ?? null,
      token: await manifestToken(r.project.dir),
    },
    { headers: noStore },
  );
}

const atOf = (v: unknown) => (v === undefined || v === null || v === "" ? null : Number(v));

export async function POST(request: Request) {
  let body: Body;
  try {
    body = await request.json();
  } catch {
    return Response.json({ error: "expected JSON" }, { status: 400 });
  }
  const r = await resolveReport(String(body.project ?? ""));
  if ("error" in r) return Response.json({ error: r.error }, { status: r.status });
  const dir = r.project.dir;
  // A string, or no guard at all: `String(null)` would be the token "null",
  // which matches no file and refuses every write.
  const token = typeof body.token === "string" ? body.token : null;
  const id = String(body.id ?? "");
  const at = atOf(body.at);

  const run = (): Promise<Record<string, unknown>> => {
    switch (body.op) {
      case "move":
        return moveEntry(dir, id, Number(body.toIndex), { token, at });
      case "remove":
        return removeEntry(dir, id, { token, at });
      case "duplicate":
        return duplicateEntry(dir, id, { token, at });
      case "insert":
        return insertEntry(dir, body.afterId ? String(body.afterId) : null, body.entry, { token, at });
      case "teaser":
        return updateTeaser(dir, id, body.patch as Record<string, unknown>, { token, at });
      case "post":
        return upsertPost(dir, body.post as Record<string, unknown>, { token });
      case "post-remove":
        return removePost(dir, id, { token });
      case "factcheck":
        return updateFactcheck(dir, (body.factcheck ?? null) as Record<string, unknown> | null, { token });
      case "undo":
        return undoStructural(dir, { token });
      default:
        throw new Error("op must be move, remove, duplicate, insert, teaser, post, post-remove, factcheck or undo");
    }
  };

  try {
    const { result, editNotes } = await withEditNotes(r.project, run);
    // revisions/ changed: the project page lists them.
    invalidateProjects();
    return Response.json({ ok: true, ...result, editNotes }, { headers: noStore });
  } catch (e) {
    if (e instanceof StaleToken) {
      return Response.json({ error: e.message, expected: e.expected, got: e.got, stale: true }, { status: 409 });
    }
    if (e instanceof StructureRefused) {
      return Response.json({ error: e.message, errors: e.errors }, { status: 400 });
    }
    return Response.json({ error: e instanceof Error ? e.message : String(e) }, { status: 400 });
  }
}