// A SAVED CONTAINER, MADE PLAYABLE IN A BROWSER — WITHOUT RE-ENCODING
// (release 21 D3).
//
// The sites play an archived video in a native <video> fed by WebTorrent
// (D5). A browser plays mp4 (h264/vp9/av1 with aac/opus/mp3) and webm
// (vp9/vp8/av1 with opus/vorbis); it does not play Matroska, and an mp4 whose
// `moov` atom is at the back cannot start until the file's last pieces
// arrive. So each container is REMUXED — `ffmpeg -c copy`, every frame and
// sample bit-for-bit — into the browser's container with its index in front:
//
//   video          audio              source       →  playable
//   h264/vp9/av1   aac/opus/mp3/none  mp4/mkv/…    →  mp4  (+faststart)
//   vp9/vp8/av1    opus/vorbis/none   webm         →  webm (cues in front)
//   anything else (hevc, mpeg4, …, or no video)    →  not playable: a
//                                                    re-encode is a ruling,
//                                                    not a default
//
// The pilot archive's measured mix (release 21): 145 mp4 h264/aac (124 of
// them moov-at-back), 9 webm vp9/opus, 11 mkv vp9/aac, 2 mkv h264/opus, 1 mp4
// av1/aac, 1 mkv av1/opus — every one of them lossless under this table.
//
// Only the first real video stream (not cover art) and the first audio stream
// are kept; subtitles, data, attachments, global metadata and chapters are
// dropped — a published file carries the picture and the sound and nothing
// that names anyone. `+bitexact` keeps ffmpeg's version string out, so the
// same source remuxes to the same bytes, and so to the same infohash.
//
// PURE: the probe is parsed here from ffprobe's JSON; running ffprobe and
// ffmpeg is the controller's (controller/preparePlayable.ts).

export type ProbedStream = {
  codec_type?: string;
  codec_name?: string;
  disposition?: { attached_pic?: number };
};

export type MediaProbe = {
  // ffprobe's format_name ("mov,mp4,m4a,3gp,3g2,mj2", "matroska,webm").
  formatName: string;
  // The source file's extension, lower-case, no dot: ffprobe says
  // "matroska,webm" for both an .mkv and a .webm, and only the name tells
  // them apart.
  ext: string;
  vcodec: string | null;
  acodec: string | null;
};

export type PlayableDecision =
  | {
      playable: true;
      ext: "mp4" | "webm";
      mime: "video/mp4" | "video/webm";
      // The ffmpeg arguments between `-i <src>` and the output path.
      args: string[];
      reason: string;
    }
  | { playable: false; reason: string };

const MP4_VIDEO = new Set(["h264", "vp9", "av1"]);
const MP4_AUDIO = new Set(["aac", "opus", "mp3"]);
const WEBM_VIDEO = new Set(["vp9", "vp8", "av1"]);
const WEBM_AUDIO = new Set(["opus", "vorbis"]);

// ffprobe -show_streams -show_format -of json → the probe.
export function parseProbe(json: unknown, ext: string): MediaProbe {
  const j = (json ?? {}) as { streams?: ProbedStream[]; format?: { format_name?: string } };
  const streams = Array.isArray(j.streams) ? j.streams : [];
  const video = streams.find((s) => s.codec_type === "video" && !s.disposition?.attached_pic);
  const audio = streams.find((s) => s.codec_type === "audio");
  return {
    formatName: j.format?.format_name ?? "",
    ext: ext.replace(/^\./, "").toLowerCase(),
    vcodec: video?.codec_name ?? null,
    acodec: audio?.codec_name ?? null,
  };
}

const COMMON_ARGS = [
  "-map", "0:V:0",
  "-map", "0:a:0?",
  "-c", "copy",
  "-sn", "-dn",
  "-map_metadata", "-1",
  "-map_chapters", "-1",
  "-fflags", "+bitexact",
  "-flags:v", "+bitexact",
  "-flags:a", "+bitexact",
];

export function decidePlayable(p: MediaProbe): PlayableDecision {
  const v = p.vcodec;
  const a = p.acodec;
  const what = `${v ?? "no video"}/${a ?? "no audio"} in ${p.ext || p.formatName}`;
  if (!v) return { playable: false, reason: `${what}: no video stream` };
  const isWebm = p.ext === "webm";
  if (isWebm && WEBM_VIDEO.has(v) && (a === null || WEBM_AUDIO.has(a))) {
    return {
      playable: true,
      ext: "webm",
      mime: "video/webm",
      args: [...COMMON_ARGS, "-f", "webm", "-cues_to_front", "1"],
      reason: `${what} → webm, remuxed with its cues in front`,
    };
  }
  if (MP4_VIDEO.has(v) && (a === null || MP4_AUDIO.has(a))) {
    return {
      playable: true,
      ext: "mp4",
      mime: "video/mp4",
      args: [...COMMON_ARGS, "-f", "mp4", "-movflags", "+faststart"],
      reason: `${what} → mp4, remuxed with its index in front`,
    };
  }
  return {
    playable: false,
    reason: `${what}: no lossless remux a browser plays (a re-encode is an operator ruling)`,
  };
}

// --- torrents ---------------------------------------------------------------

export const MIN_PIECE_LENGTH = 256 * 1024;
export const MAX_PIECE_LENGTH = 1024 * 1024;
// Aim for about this many pieces: a few thousand is what a browser peer
// handles comfortably, and a seek fetches at most one piece of slack.
const TARGET_PIECES = 2048;

// A power of two between 256 KiB and 1 MiB, scaled to the file: a 20 MB clip
// gets 256 KiB pieces, a 2 GB episode 1 MiB.
export function pieceLengthFor(bytes: number): number {
  let len = MIN_PIECE_LENGTH;
  while (len < MAX_PIECE_LENGTH && bytes / len > TARGET_PIECES) len *= 2;
  return len;
}

// A magnet for an infohash, its display name and the announce URLs a site
// names. The trackers are not in the info dict, so the same infohash can be
// announced anywhere later.
export function magnetFor(opts: { infoHash: string; name: string; trackers?: readonly string[] }): string {
  const parts = [`xt=urn:btih:${opts.infoHash}`, `dn=${encodeURIComponent(opts.name)}`];
  for (const tr of opts.trackers ?? []) parts.push(`tr=${encodeURIComponent(tr)}`);
  return `magnet:?${parts.join("&")}`;
}

// --- the manifest -----------------------------------------------------------

// `<root>/<slug>/playable.json`: what has been prepared, keyed by video id.
// A re-run compares `sourceSha256` and skips an entry whose files are there.
export type PlayableEntry = {
  // The saved container this was made from, by hash.
  sourceSha256: string;
  // Relative to `<root>/<slug>/`.
  file: string;
  torrent: string;
  ext: "mp4" | "webm";
  mime: "video/mp4" | "video/webm";
  bytes: number;
  infoHash: string;
  pieceLength: number;
  vcodec: string;
  acodec: string | null;
  preparedAt: string;
};

export type PlayableManifest = {
  version: 1;
  slug: string;
  entries: Record<string, PlayableEntry>;
};

export const PLAYABLE_MANIFEST_FILENAME = "playable.json";

export function emptyPlayableManifest(slug: string): PlayableManifest {
  return { version: 1, slug, entries: {} };
}

const HEX40 = /^[0-9a-f]{40}$/;
const HEX64 = /^[0-9a-f]{64}$/;

// Tolerant: a malformed entry is dropped (and so re-prepared), never fatal.
export function parsePlayableManifest(raw: unknown, slug: string): PlayableManifest {
  const out = emptyPlayableManifest(slug);
  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return out;
  const entries = (raw as { entries?: unknown }).entries;
  if (!entries || typeof entries !== "object" || Array.isArray(entries)) return out;
  for (const [id, e] of Object.entries(entries as Record<string, unknown>)) {
    if (!e || typeof e !== "object") continue;
    const r = e as Record<string, unknown>;
    if (
      typeof r.sourceSha256 !== "string" || !HEX64.test(r.sourceSha256) ||
      typeof r.file !== "string" || typeof r.torrent !== "string" ||
      (r.ext !== "mp4" && r.ext !== "webm") ||
      (r.mime !== "video/mp4" && r.mime !== "video/webm") ||
      typeof r.bytes !== "number" ||
      typeof r.infoHash !== "string" || !HEX40.test(r.infoHash) ||
      typeof r.pieceLength !== "number" ||
      typeof r.vcodec !== "string" ||
      (r.acodec !== null && typeof r.acodec !== "string") ||
      typeof r.preparedAt !== "string"
    ) {
      continue;
    }
    out.entries[id] = {
      sourceSha256: r.sourceSha256,
      file: r.file,
      torrent: r.torrent,
      ext: r.ext,
      mime: r.mime,
      bytes: r.bytes,
      infoHash: r.infoHash,
      pieceLength: r.pieceLength,
      vcodec: r.vcodec,
      acodec: r.acodec as string | null,
      preparedAt: r.preparedAt,
    };
  }
  return out;
}