#!/usr/bin/env node
// E2E fake for scripts/parakeet-stitch.mjs (the parakeet overlapping-segment
// wrapper). Mimics the args the parakeet app builds (transcriptionApps.ts):
//   parakeet-stitch.mjs --model <m> --output <tmpBase> [--segment <n>]
//                       [--device <d>] <audioFile>
// Output contract: write chough-native JSON to EXACTLY the --output path; print
// "segment X/Y" progress lines to stderr. Run from cwd == the video dir.
//
// Mirrors the real wrapper's resumable design: each window's payload is written
// to a per-audio work dir (".<audio>.parakeet/") as it completes; the stitched
// transcript is produced only when ALL windows are done (then the work dir is
// removed); re-running resumes from cached windows. On SIGTERM it stops without
// producing output (paused) — completed windows stay cached.
//
// Three modes by video dir (cwd):
//   * default: do both windows instantly and stitch.
//   * "slowop" dirs: window 0 is instant; window 1 waits — on SIGTERM it pauses
//     (no output, window 0 cached). A *resume* run (window 0 already cached)
//     finishes window 1 immediately and stitches.
//   * "hangterm" dirs: like slowop, but window 1 IGNORES SIGTERM, so the run
//     outlives execa's forceKillAfterDelay and is force-SIGKILLed (mimics a
//     parakeet window that takes longer than the 5s grace). `await child` then
//     REJECTS — which used to be mis-recorded as a failed transcription. Window 0
//     is still cached before the wait, so a resume run completes as for slowop.
import { mkdir, writeFile, rm } from "node:fs/promises";
import { existsSync } from "node:fs";
import path from "node:path";
import { installFixtureWatchdog } from "./_watchdog.mjs";

// Never outlive the run that spawned us — see _watchdog.mjs.
installFixtureWatchdog();

const argv = process.argv.slice(2);
function arg(flag) {
  const i = argv.indexOf(flag);
  return i < 0 ? undefined : argv[i + 1];
}

const out = arg("--output") ?? arg("-o");
const device = arg("--device");
const audio = argv[argv.length - 1];
if (!out) {
  process.stderr.write(`[fake-parakeet-stitch] missing --output\n`);
  process.exit(2);
}
if (device) process.stderr.write(`parakeet-stitch: device ${device}\n`);

const cwd = process.cwd().toLowerCase();
const slow = cwd.includes("slowop");
const hang = cwd.includes("hangterm");
const interruptible = slow || hang;
const workDir = path.resolve(`.${path.basename(audio)}.parakeet`);
const win = (i) => path.join(workDir, `win-${String(i).padStart(4, "0")}.json`);
const cue = (i) => ({
  start_time: i * 5,
  end_time: i * 5 + 5,
  text: `Synthetic parakeet output for ${audio} #${i + 1}`,
});

async function stitchAndFinish() {
  const chunk_data = [cue(0), cue(1)];
  await writeFile(
    out,
    JSON.stringify({
      duration_seconds: 10,
      chunks: 2,
      text: chunk_data.map((c) => c.text).join(" "),
      chunk_data,
    }),
  );
  await rm(workDir, { recursive: true, force: true });
  process.stderr.write(`parakeet-stitch: wrote 2 cues -> ${out}\n`);
  process.exit(0);
}

await mkdir(workDir, { recursive: true });
const resuming = existsSync(win(0));

// Window 0.
if (existsSync(win(0))) {
  process.stderr.write(`parakeet-stitch: segment 1/2 @0s — cached\n`);
} else {
  process.stderr.write(`parakeet-stitch: segment 1/2 @0s — transcribing\n`);
  await writeFile(win(0), JSON.stringify({ start: 0, cue: cue(0) }));
}

// Window 1.
if (existsSync(win(1))) {
  process.stderr.write(`parakeet-stitch: segment 2/2 @5s — cached\n`);
  await stitchAndFinish();
} else if (!interruptible || resuming) {
  // Fresh-and-fast, or resuming a paused run: finish window 1 now.
  process.stderr.write(`parakeet-stitch: segment 2/2 @5s — transcribing\n`);
  await writeFile(win(1), JSON.stringify({ start: 5, cue: cue(1) }));
  await stitchAndFinish();
} else {
  // Interruptible first run: window 1 waits (window 0 already cached above).
  // Backstop completes if never stopped.
  process.stderr.write(`parakeet-stitch: segment 2/2 @5s — transcribing\n`);
  if (hang) {
    // Swallow the graceful stop so execa must force-kill us after its delay —
    // `await child` rejects rather than resolving (the regression scenario).
    const ignore = () =>
      process.stderr.write(`parakeet-stitch: stop ignored — still working (will be force-killed)\n`);
    process.on("SIGTERM", ignore);
    process.on("SIGINT", ignore);
  } else {
    // Slow: on SIGTERM pause (no output) — window 0 stays cached for the resume run.
    const onPause = () => {
      process.stderr.write(`parakeet-stitch: paused after 1/2 window(s) — re-run to resume\n`);
      process.exit(0);
    };
    process.on("SIGTERM", onPause);
    process.on("SIGINT", onPause);
  }
  setTimeout(async () => {
    await writeFile(win(1), JSON.stringify({ start: 5, cue: cue(1) }));
    await stitchAndFinish();
  }, 30_000);
}