import { spawn } from "node:child_process";
import { stat } from "node:fs/promises";
import { absOf, pickWindow, resolveClip, windowsFor } from "@/lib/report/serve.mjs";
import { MAX_DECODE_SPAN, wavHeader } from "@/lib/report/playback.mjs";
import { FFMPEG_BIN } from "umtool-report-to-video/build-video";

export const dynamic = "force-dynamic";

// A cached source window's SOUND, decoded, for the bench to play exactly.
//
// The bench plays every bounded range -- a selection, an edge, a line -- from
// a decoded buffer with Web Audio, because an <video> element stopped from
// `timeupdate` overran the end by up to a quarter of a second. This is that
// buffer: the same file /api/report/raw serves (picked by the same membership
// rule), as 16-bit PCM WAV, which every browser decodes without a codec.
//
// DECODED BY FFMPEG, NOT BY THE BROWSER. The build cuts with ffmpeg, so a cut
// set by ear has to be set against ffmpeg's timeline: a browser's own AAC
// decode may or may not honour the file's edit list, and the encoder's
// priming samples are tens of milliseconds -- the size of the error this
// exists to remove.
//
// `from`/`to` are ABSOLUTE source seconds, clamped to the file. A span longer
// than MAX_DECODE_SPAN is refused rather than served: a whole recording in the
// saved-video store is hours, and the bench asks for a window around the
// selection instead (decodeSpan).

/** Matches the build's `render.audioRate` default; the browser resamples anyway. */
const RATE = 48000;
const CHANNELS = 2;

export async function GET(request: Request) {
  const url = new URL(request.url);
  const r = await resolveClip(url.searchParams.get("project") ?? "", url.searchParams.get("clip") ?? "");
  if ("error" in r) return Response.json({ error: r.error }, { status: r.status });

  const windows = await windowsFor(r.project, r.clip);
  const win = pickWindow(windows, url.searchParams.get("file"));
  if (!win) return Response.json({ error: "no cached window for this clip" }, { status: 404 });
  const abs = absOf(win);
  if (!abs) return Response.json({ error: "outside the roots" }, { status: 400 });
  const st = await stat(abs).catch(() => null);
  if (!st) return Response.json({ error: "gone" }, { status: 404 });

  const num = (k: string, dflt: number) => {
    const v = url.searchParams.get(k);
    const n = v == null || v === "" ? dflt : Number(v);
    return Number.isFinite(n) ? n : Number.NaN;
  };
  const from = Math.max(win.from, num("from", win.from));
  const to = Math.min(win.to, num("to", win.to));
  if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) {
    return Response.json({ error: "bad span" }, { status: 400 });
  }
  if (to - from > MAX_DECODE_SPAN + 0.5) {
    return Response.json(
      { error: `asked for ${Math.round(to - from)} s; the bench decodes at most ${MAX_DECODE_SPAN} s at once` },
      { status: 400 },
    );
  }

  // Input seeking with a decode is sample-accurate in ffmpeg: it seeks to the
  // keyframe before and discards up to the requested time. The build's ffmpeg
  // (FFMPEG_BIN), so an override reaches this decode too; killed when the
  // request is aborted (the bench moved on to another window or left).
  const chunks: Buffer[] = [];
  let err = "";
  const code = await new Promise<number>((resolve) => {
    const ff = spawn(FFMPEG_BIN, [
      "-nostdin", "-v", "error",
      "-ss", (from - win.from).toFixed(6),
      "-i", abs,
      "-t", (to - from).toFixed(6),
      "-map", "a:0",
      "-ac", String(CHANNELS), "-ar", String(RATE),
      "-f", "s16le", "-acodec", "pcm_s16le", "-",
    ], { signal: request.signal });
    ff.stdout.on("data", (b: Buffer) => chunks.push(b));
    ff.stderr.on("data", (b: Buffer) => {
      err += b.toString();
    });
    ff.on("error", (e) => {
      err += String(e);
      resolve(-1);
    });
    ff.on("close", (c) => resolve(c ?? -1));
  });
  // Nobody is waiting for it: the decode was killed, say so and stop.
  if (request.signal.aborted) return new Response(null, { status: 499 });
  const pcm = Buffer.concat(chunks);
  const frameBytes = CHANNELS * 2;
  const dataBytes = pcm.length - (pcm.length % frameBytes);
  if (code !== 0 || dataBytes === 0) {
    // Said in the bench, which then plays through the element: the message is
    // the reason the playback is approximate.
    const why = /matches no streams|does not contain any stream/i.test(err)
      ? "this file has no audio track"
      : err.trim().split("\n").pop() || `ffmpeg exited ${code}`;
    return Response.json({ error: why }, { status: 422 });
  }

  const body = new Uint8Array(44 + dataBytes);
  body.set(wavHeader({ channels: CHANNELS, sampleRate: RATE, dataBytes }), 0);
  body.set(pcm.subarray(0, dataBytes), 44);
  return new Response(body, {
    headers: {
      "content-type": "audio/wav",
      // The window is in the file's name, so the same request is the same
      // sound: it may be cached for as long as the raw file is.
      "cache-control": "private, max-age=3600, immutable",
      // What was actually decoded, in absolute source seconds: the client
      // places the buffer on the source clock from these, not from what it
      // asked for.
      "x-audio-from": String(from),
      "x-audio-to": String(from + dataBytes / frameBytes / RATE),
      "x-window": win.name,
    },
  });
}