#!/usr/bin/env node
// A stand-in for the editor's POST /api/media/fetch-window.
//
// The suite must not run a real editor: it would boot the runners against
// whatever corpus it found, and the whole point of the endpoint is that it
// spends somebody's bandwidth. So this answers the contract — bearer token,
// 202 + jobId, poll to done — and writes a real mp4 into the fixture's corpus
// at the path the editor would have used:
//
//   <CHANNELS_DIR>/<slug>/data/<video>/clips/<from>-<to>.mp4
//
// It records every request so a spec can assert the provenance actually
// crossed the wire, which is the part that cannot be inferred from the file.
//
// Modelled on e2e/fixtures/ollama-stub.mjs in the editor: a second webServer
// entry, ready when its own endpoint answers.

import http from "node:http";
import { spawnSync } from "node:child_process";
import { mkdirSync, writeFileSync, statSync } from "node:fs";
import path from "node:path";
import { portFor } from "yt-dlp-transcript-common/lib/ports.mjs";

const PORT = portFor("EDITOR_STUB_PORT");
const CHANNELS = process.env.CHANNELS_DIR ?? "";
const TOKEN = process.env.WORKER_TOKEN ?? "";
// Where the spec reads what was asked for.
const LOG = process.env.E2E_EDITOR_STUB_LOG ?? path.join(process.cwd(), "editor-stub.requests.json");

const requests = [];
const jobs = new Map();
let nextJob = 1;

// BEST-EFFORT, and it has to be. This process and make-fixture.mjs are started
// by playwright in parallel, and make-fixture rm -rf's the fixture root — so on
// a fresh checkout the directory this writes into may not exist yet, and a
// throw here would kill the stub before a single spec ran.
function record() {
  try {
    mkdirSync(path.dirname(LOG), { recursive: true });
    writeFileSync(LOG, JSON.stringify(requests, null, 2) + "\n");
  } catch {
    /* the fixture root is mid-rebuild; the next request rewrites it */
  }
}
record();

function json(res, status, body) {
  const s = JSON.stringify(body);
  res.writeHead(status, {
    "content-type": "application/json",
    "content-length": Buffer.byteLength(s),
  });
  res.end(s);
}

// A real container, because the bench serves it with byte ranges and the
// project page probes it. Same generator the fixture's yt-dlp stub uses, so a
// window fetched here and one fetched locally are the same kind of file.
function writeWindow(dir, name, seconds) {
  mkdirSync(dir, { recursive: true });
  const out = path.join(dir, name);
  const dur = Math.max(1, seconds);
  const r = spawnSync(
    "ffmpeg",
    [
      "-nostdin", "-v", "error", "-y",
      "-f", "lavfi", "-i", `color=c=darkblue:size=320x180:rate=15:duration=${dur}`,
      "-f", "lavfi", "-i", `sine=frequency=330:duration=${dur}`,
      "-t", String(dur),
      "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac",
      "-ar", "48000", "-ac", "2", out,
    ],
    { stdio: "inherit" },
  );
  if (r.status !== 0) throw new Error(`ffmpeg failed writing ${out}`);
  return out;
}

const server = http.createServer((req, res) => {
  const url = new URL(req.url ?? "/", `http://127.0.0.1:${PORT}`);

  if (url.pathname === "/health") return json(res, 200, { ok: true });

  const auth = req.headers.authorization ?? "";
  if (!TOKEN || auth !== `Bearer ${TOKEN}`) {
    req.resume();
    return json(res, 401, { error: "missing bearer token" });
  }

  // THE OPS DOOR, stubbed alongside the media one.
  //
  // /api/report/tag forwards to the editor's /api/ops/tag-videos, and what a
  // spec needs to prove is the part no file on disk shows: that the archive's
  // ids (not the manifest's local ones), the op, the provenance and the bearer
  // token crossed the wire. `changed` is deliberately NOT the same number as
  // the videos sent — the real editor reports what actually moved, and the UI
  // must print the editor's number rather than its own count.
  if (req.method === "GET" && url.pathname === "/api/ops/tags") {
    req.resume();
    return json(res, 200, {
      ok: true,
      tags: [
        { id: "eva-collab", label: "Collab", pinned: 0, suppressed: 0 },
        { id: "eva-topic", label: "Discussed", pinned: 0, suppressed: 0 },
      ],
    });
  }

  if (req.method === "POST" && url.pathname === "/api/ops/tag-videos") {
    let raw = "";
    req.on("data", (c) => (raw += c));
    req.on("end", () => {
      let body;
      try {
        body = JSON.parse(raw);
      } catch {
        return json(res, 400, { ok: false, error: "malformed JSON body" });
      }
      requests.push({ route: "tag-videos", ...body, authorization: auth });
      record();
      if (!body.tag || !Array.isArray(body.videos) || body.videos.length === 0) {
        return json(res, 400, { ok: false, error: "tag and videos are required" });
      }
      // One fewer than asked for, so a spec that echoed its own count instead
      // of the editor's would fail.
      return json(res, 200, { ok: true, changed: Math.max(0, body.videos.length - 1) });
    });
    return;
  }

  // GET /api/media/fetch-window/<jobId>
  const poll = /^\/api\/media\/fetch-window\/(.+)$/.exec(url.pathname);
  if (req.method === "GET" && poll) {
    req.resume();
    const job = jobs.get(poll[1]);
    if (!job) return json(res, 404, { error: "no such job" });
    // One poll of latency, so the spec exercises the queued -> done path
    // rather than only the already-finished one.
    if (!job.polled) {
      job.polled = true;
      return json(res, 200, { status: "running", jobId: poll[1] });
    }
    if (job.fail) {
      return json(res, 200, { status: "failed", jobId: poll[1], error: job.fail });
    }
    return json(res, 200, {
      status: "done",
      jobId: poll[1],
      file: job.file,
      bytes: statSync(job.file).size,
      from: job.from,
      to: job.to,
    });
  }

  if (req.method !== "POST" || url.pathname !== "/api/media/fetch-window") {
    req.resume();
    return json(res, 404, { error: "not found" });
  }

  let raw = "";
  req.on("data", (c) => (raw += c));
  req.on("end", () => {
    let body;
    try {
      body = JSON.parse(raw);
    } catch {
      return json(res, 400, { error: "malformed JSON body" });
    }
    requests.push({ ...body, authorization: auth });
    record();

    if (!body.requestedBy) {
      return json(res, 400, { error: "requestedBy is required" });
    }
    // A sentinel so a spec can drive the refusal path without a real 429.
    if (String(body.clipId ?? "").includes("cooldown")) {
      return json(res, 409, {
        error: "youtube is in a rate-limit cooldown (42s remaining).",
        cooldownMs: 42_000,
        platform: "youtube",
      });
    }

    const dir = path.join(CHANNELS, body.channelSlug, "data", body.videoId, "clips");
    const name = `${Number(body.from).toFixed(2)}-${Number(body.to).toFixed(2)}.mp4`;
    const id = `stub-job-${nextJob++}`;
    let file;
    try {
      file = writeWindow(dir, name, Number(body.to) - Number(body.from));
    } catch (err) {
      jobs.set(id, { fail: String(err.message), polled: false });
      return json(res, 202, { cached: false, jobId: id, file: null, from: body.from, to: body.to });
    }
    // The provenance sidecar the editor writes, so a corpus built by the stub
    // reads back the same way a real one does.
    writeFileSync(
      path.join(dir, name.replace(/\.mp4$/, ".json")),
      JSON.stringify(
        {
          requestedBy: body.requestedBy,
          manifest: body.manifest,
          clipId: body.clipId,
          reason: body.reason,
          pad: body.pad,
          bytes: statSync(file).size,
          fetchedAt: new Date().toISOString(),
        },
        null,
        2,
      ) + "\n",
    );
    jobs.set(id, { file, from: body.from, to: body.to, polled: false });
    json(res, 202, { cached: false, jobId: id, file, from: body.from, to: body.to });
  });
});

server.listen(PORT, "127.0.0.1", () => {
  process.stdout.write(`[editor-stub] listening on ${PORT}, corpus ${CHANNELS}\n`);
});