import path from "node:path";
import { SONG_DATA, dataFile, stateFile } from "./paths";
import { readJson, withStateLock, writeJsonAtomic } from "./state";

// ---------------------------------------------------------------------------
// Trimming the SOURCE CLIPS a song is built from.
//
// Two kinds of source clip, and only one of them needs anything built:
//
//   um clips    already fully editable. /sort, /salvage and /verify are the
//               Waveform over wav48/<video>.wav with an unbounded window, and a
//               re-trimmed window is written back through applyVerdict. The
//               browse pages link INTO that (`/sort?only=<clipId>`) rather than
//               growing a second editor for the same job.
//
//   MK hooks    no server-side editor at all. mk-hooks.html is a file:// page
//               whose export has to be hand-carried to apply-hook-trims.mjs.
//               That is what this is.
//
// The editor works in STEM SECONDS throughout, which is what makes a trim
// widenable. The catalogue window for hook-22 opens at 97.54 when "Scorpion!"
// starts at 97.10, so the clip is a fragment and no amount of trimming INSIDE
// it recovers the syllable -- the first UI could only cut further in, and that
// fix had to be hand-written.
// ---------------------------------------------------------------------------

export type TrimSet = {
  id: string;
  label: string;
  /** SONG_DATA-relative. */
  stem: string;
  /**
   * hooks-VERB, never hooks.
   *
   * pick-take scored hooks-verb and the -best copies came from it, so a trim
   * taken against anything else is a trim of different audio. apply-hook-trims
   * defaults HOOKDIR to `mkvocals/hooks`, so this must always be passed
   * explicitly -- it is never a default.
   */
  hookDir: string;
  catalogue: string;
  /** In the repo, beside accepted.json — small, hand-edited, worth keeping. */
  trimsFile: string;
  /** input -> output pairs for `pick-take --apply`. */
  overlays: { from: string; to: string }[];
};

export const TRIM_SETS: Record<string, TrimSet> = {
  "mk-hooks": {
    id: "mk-hooks",
    label: "Mortal Kombat vocal hooks",
    stem: "mkvocals/stem48.wav",
    hookDir: "mkvocals/hooks-verb",
    catalogue: "mkvocals/hooks-verb/mk-vocals.json",
    trimsFile: stateFile("mk-trims.json"),
    overlays: [
      { from: "mk-overlays-fatal5.json", to: "mk-overlays-fatal5-best.json" },
      { from: "mk-overlays-short-fatal.json", to: "mk-overlays-short-best.json" },
    ],
  },
};

export const isTrimSet = (v: string): boolean => Object.hasOwn(TRIM_SETS, v);

export type Hook = {
  id: string;
  file: string;
  /** Stem seconds. */
  srcStart: number;
  srcEnd: number;
  dur: number;
  text: string;
  peakDb?: number;
  rmsDb?: number;
};

export type Catalogue = { stem?: string; sr?: number; hooks: Hook[] };

/**
 * One exported trim, in exactly the shape apply-hook-trims.mjs consumes.
 *
 * Without `source` the times are CLIP-RELATIVE and it runs an atrim on the hook
 * file. With `source:"stem"` they are STEM seconds and it re-cuts from
 * stem48.wav -- which can widen past the catalogue window but LOSES THE REVERB
 * baked into hooks-verb. So the editor emits clip-relative whenever the
 * selection lies inside the catalogue window, and stem only when it escapes.
 * Always emitting stem would quietly re-cut every trimmed hook from the dry
 * stem: simpler, and wrong in a way you only hear.
 */
export type TrimEntry = {
  id?: string;
  file: string;
  source?: "stem";
  start: number;
  end: number;
};

export const stemPath = (set: TrimSet) => dataFile(...set.stem.split("/"));
export const hookPath = (set: TrimSet, file: string) => dataFile(...set.hookDir.split("/"), file);
export const cataloguePath = (set: TrimSet) => dataFile(...set.catalogue.split("/"));

export async function readCatalogue(set: TrimSet): Promise<Catalogue> {
  const j = await readJson<Catalogue>(cataloguePath(set), { hooks: [] });
  return { ...j, hooks: Array.isArray(j.hooks) ? j.hooks : [] };
}

export async function readTrims(set: TrimSet): Promise<TrimEntry[]> {
  const j = await readJson<TrimEntry[]>(set.trimsFile, []);
  return Array.isArray(j) ? j : [];
}

/**
 * Turn a selection in STEM seconds into the entry apply-hook-trims wants.
 *
 * `null` means the selection is the catalogue window unchanged — there is
 * nothing to trim, and writing an entry for it would make the file grow rows
 * that do nothing.
 */
export function toEntry(hook: Hook, from: number, to: number, epsilon = 0.005): TrimEntry | null {
  const insideStart = from >= hook.srcStart - epsilon;
  const insideEnd = to <= hook.srcEnd + epsilon;
  if (Math.abs(from - hook.srcStart) < epsilon && Math.abs(to - hook.srcEnd) < epsilon) return null;
  if (insideStart && insideEnd) {
    return {
      id: hook.id,
      file: hook.file,
      start: +(from - hook.srcStart).toFixed(4),
      end: +(to - hook.srcStart).toFixed(4),
    };
  }
  return { id: hook.id, file: hook.file, source: "stem", start: +from.toFixed(4), end: +to.toFixed(4) };
}

/** The stem-second window an entry describes, for drawing it back. */
export function toWindow(hook: Hook, entry: TrimEntry | undefined): { from: number; to: number } {
  if (!entry) return { from: hook.srcStart, to: hook.srcEnd };
  if (entry.source === "stem") return { from: entry.start, to: entry.end };
  return { from: hook.srcStart + entry.start, to: hook.srcStart + entry.end };
}

/**
 * Replace the whole array under one lock.
 *
 * It is ~15 entries and hand-editable, so it is written whole rather than
 * merged per entry: a partial merge against a file someone has edited outside
 * this app is exactly the lost-update lib/state.ts exists to prevent. Two open
 * tabs are still last-write-wins on the array -- withStateLock makes that
 * atomic, not correct, which is acceptable for a single-user local tool.
 */
export async function writeTrims(set: TrimSet, entries: TrimEntry[]): Promise<TrimEntry[]> {
  const clean = entries
    .filter((e) => e && e.file && Number.isFinite(e.start) && Number.isFinite(e.end) && e.end > e.start)
    .map((e) => ({
      ...(e.id ? { id: e.id } : {}),
      file: path.basename(e.file),
      ...(e.source === "stem" ? { source: "stem" as const } : {}),
      start: +Number(e.start).toFixed(4),
      end: +Number(e.end).toFixed(4),
    }));
  await withStateLock(async () => {
    await writeJsonAtomic(set.trimsFile, clean);
  });
  return clean;
}

// ---------------------------------------------------------------------------
// The rebuild chain, as data.
//
// THE ORDER IS THE TRAP, and it is why this is a recipe rather than a text box.
//
// The shipped overlays point at mkvocals/hooks-best/, where hook-01/02/03 are
// copies of the WINNING TAKE. HOOKDIR overrides by BASENAME, so pointing step 3
// at a trimmed directory silently restores each occurrence's own take and
// throws the take selection away. specs/mortal-kombat.md documents this
// precisely. The route that keeps both is:
//
//   apply-hook-trims (HOOKDIR=hooks-verb)  ->  pick-take --apply  ->  re-mix
//
// Every output is STAMPED, so nothing overwrites a shipped input and a
// half-finished run cannot corrupt the directory the shipped overlays name.
// ---------------------------------------------------------------------------

export type Step = {
  label: string;
  argv: string[];
  cwd: string;
  env: Record<string, string>;
  /**
   * How long this step may run, overriding the default.
   *
   * Per-step because the default is 15 minutes and exists to catch the
   * accidental hour-long job -- while a 19-clip crossfaded build legitimately
   * runs 20 to 40. Raising the default to fit the build would remove the guard
   * for everything else, so the build asks for what it needs instead.
   */
  timeoutMs?: number;
  /** Lines matching this are progress events, not log noise. */
  ndjson?: boolean;
};

/** Env keys a request may never set. The recipe owns both, for the reason above. */
export const ENV_DENY = ["HOOKDIR", "TAKE_DIR"];

/**
 * `body` is the ALREADY-RENDERED song, without overlays, that step 3 mixes onto
 * -- mk-mix-hooks.mjs takes it as its first argument. Nothing on disk records
 * which render that is for a given cut, so it is a parameter the user supplies
 * rather than something guessed at here.
 *
 * Directory arguments are SONG_DATA-relative because both scripts resolve them
 * that way (pick-take.mjs's `abs()`, apply-hook-trims' `path.join(SONG_DATA,
 * OUTDIR)`). File arguments are ABSOLUTE, because cwd is SONG_CODE while the
 * overlays live in SONG_DATA and a bare name would resolve against the wrong one.
 */
export function hookRecipe(
  set: TrimSet,
  stamp: string,
  body: string,
  overlayIndex = 0,
): Step[] {
  const pair = set.overlays[overlayIndex] ?? set.overlays[0];
  const trimDir = `mkvocals/hooks-trim-${stamp}`;
  const takeDir = `mkvocals/hooks-best-${stamp}`;
  const outOverlays = dataFile(pair.to.replace(/\.json$/, `-${stamp}.json`));
  const cwd = path.join(/* turbopackIgnore: true */ process.cwd(), "song");
  const base = { SONG_DIR: SONG_DATA };

  return [
    {
      label: "apply the trims to a new hook directory",
      // HOOKDIR must be hooks-verb: the script defaults to `mkvocals/hooks`,
      // which is NOT what pick-take scored.
      argv: ["node", "apply-hook-trims.mjs", set.trimsFile, trimDir],
      cwd,
      env: { ...base, HOOKDIR: set.hookDir },
    },
    {
      label: "re-pick the best take, into a stamped directory",
      // TAKE_DIR is stamped, never the shipped mkvocals/hooks-best: a
      // half-finished run must not be able to corrupt the directory the
      // shipped overlays point at. The overlays OUTPUT is a new file too --
      // pick-take mutates what it reads, so aiming it at its own input would
      // make a re-run non-idempotent.
      argv: [
        "node", "pick-take.mjs",
        `${trimDir}/mk-vocals.json`, trimDir,
        "--apply", dataFile(pair.from), outOverlays,
      ],
      cwd,
      env: { ...base, TAKE_DIR: takeDir },
    },
    {
      label: "re-mix the hooks onto the body",
      // NO HOOKDIR HERE. This is the whole point of the chain: the overlays
      // written by step 2 already name the winning takes by path, and setting
      // HOOKDIR would override them BY BASENAME and undo the take selection.
      argv: ["node", "mk-mix-hooks.mjs", body, outOverlays, dataFile(`mkvocals/mk-hooks-${stamp}.wav`)],
      cwd,
      env: { ...base },
    },
  ];
}