// A REPORT'S VIDEO — `archilyzer reports attach-video <report.json> <video>`:
// the video encoded (or remuxed) to fit the publish limit, written beside the
// report as `video.mp4` with a poster, and `video` set in report.json.
//
// The limit is the one compose enforces on the report's video
// (lib/builtExport.ts PUBLISH_MAX_FILE_BYTES, 24 MiB — Pages allows 25 per
// file); a video over it fails compose ("report-video"). So:
//
//   - an mp4 already H.264 (+ AAC, or no audio) and under the limit is
//     REMUXED, not re-encoded: streams copied, `+faststart` so it plays
//     before it has loaded;
//   - anything else is ENCODED: H.264 + AAC at an average bitrate the
//     duration allows inside 96% of the limit (capped at 2.5 Mb/s of video,
//     no wider than 1280 px, narrower as the bitrate falls). A single pass
//     can land over its target, so a result over the limit is encoded again
//     at a bitrate scaled down by the overshoot, up to three times;
//   - a video so long that it would get under 100 kb/s of picture is refused
//     with its length — trim it, the encoder cannot make it watchable.
//
// The poster is the one given (png, jpg or webp), else the report's existing
// one when it is on disk, else a frame from 10% into the video. Nothing is
// written into report.json unless the video (and poster) are in place and
// its `video` validates.

import { copyFile, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
import path from "node:path";
import { execa } from "execa";
import { PUBLISH_MAX_FILE_BYTES, publishFileSizeProblem } from "../lib/builtExport";
import { parseReport } from "../lib/report/validate";

export const REPORT_VIDEO_NAME = "video.mp4";
export const REPORT_POSTER_NAME = "poster.jpg";
// The share of the limit an encode aims at: the rest is container overhead
// and the encoder's own overshoot.
export const ATTACH_TARGET_FRACTION = 0.96;
export const MAX_VIDEO_KBPS = 2500;
export const MIN_VIDEO_KBPS = 100;
const MAX_ENCODE_ATTEMPTS = 3;
const POSTER_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp"]);

export type VideoProbe = {
  durationSec: number;
  formatName: string;
  videoCodec: string | null;
  audioCodec: string | null;
  width: number | null;
};

export type EncodePlan =
  | { mode: "remux" }
  | { mode: "encode"; videoKbps: number; audioKbps: number; maxWidth: number }
  | { mode: "refuse"; reason: string };

// What to do with a video of `bytes` described by `probe`, to fit `limitBytes`.
export function encodePlan(probe: VideoProbe, bytes: number, limitBytes = PUBLISH_MAX_FILE_BYTES): EncodePlan {
  if (!probe.videoCodec) return { mode: "refuse", reason: "it has no video stream" };
  if (!(probe.durationSec > 0)) return { mode: "refuse", reason: "its duration cannot be read" };
  const isMp4 = /(^|,)(mp4|mov)(,|$)/.test(probe.formatName);
  if (
    isMp4 &&
    probe.videoCodec === "h264" &&
    (probe.audioCodec === null || probe.audioCodec === "aac") &&
    bytes <= limitBytes
  ) {
    return { mode: "remux" };
  }
  const totalKbps = Math.floor((limitBytes * ATTACH_TARGET_FRACTION * 8) / 1000 / probe.durationSec);
  const audioKbps = probe.audioCodec === null ? 0 : totalKbps >= 1000 ? 128 : 64;
  // ~2% for the container.
  const videoKbps = Math.min(MAX_VIDEO_KBPS, Math.floor((totalKbps - audioKbps) * 0.98));
  if (videoKbps < MIN_VIDEO_KBPS) {
    const minutes = (probe.durationSec / 60).toFixed(1);
    return {
      mode: "refuse",
      reason:
        `at ${minutes} min it would get ${Math.max(0, videoKbps)} kb/s of picture inside ` +
        `${(limitBytes / (1024 * 1024)).toFixed(0)} MiB (at least ${MIN_VIDEO_KBPS} is watchable) — trim it`,
    };
  }
  const maxWidth = videoKbps >= 1200 ? 1280 : videoKbps >= 500 ? 854 : 640;
  return { mode: "encode", videoKbps, audioKbps, maxWidth };
}

export function encodeArgs(src: string, dst: string, plan: Exclude<EncodePlan, { mode: "refuse" }>): string[] {
  const head = ["-nostdin", "-hide_banner", "-v", "error", "-y", "-i", src];
  if (plan.mode === "remux") return [...head, "-map", "0:v:0", "-map", "0:a:0?", "-c", "copy", "-movflags", "+faststart", dst];
  const v = plan.videoKbps;
  return [
    ...head,
    "-map", "0:v:0",
    "-map", "0:a:0?",
    "-vf", `scale='min(${plan.maxWidth},iw)':-2`,
    "-c:v", "libx264",
    "-preset", "medium",
    "-b:v", `${v}k`,
    "-maxrate", `${Math.round(v * 1.5)}k`,
    "-bufsize", `${v * 2}k`,
    "-pix_fmt", "yuv420p",
    ...(plan.audioKbps > 0 ? ["-c:a", "aac", "-b:a", `${plan.audioKbps}k`, "-ac", "2"] : ["-an"]),
    "-movflags", "+faststart",
    dst,
  ];
}

export function posterArgs(src: string, dst: string, atSec: number): string[] {
  return [
    "-nostdin", "-hide_banner", "-v", "error", "-y",
    "-ss", String(Math.max(0, Math.round(atSec * 100) / 100)),
    "-i", src,
    "-frames:v", "1",
    "-vf", "scale='min(1280,iw)':-2",
    "-q:v", "3",
    dst,
  ];
}

export async function probeVideo(ffprobeBin: string, file: string): Promise<VideoProbe> {
  const { stdout } = await execa(ffprobeBin, [
    "-v", "error", "-print_format", "json", "-show_format", "-show_streams", file,
  ]);
  const doc = JSON.parse(stdout) as {
    format?: { duration?: string; format_name?: string };
    streams?: { codec_type?: string; codec_name?: string; width?: number; duration?: string }[];
  };
  const streams = doc.streams ?? [];
  const video = streams.find((s) => s.codec_type === "video");
  const audio = streams.find((s) => s.codec_type === "audio");
  const duration = Number(doc.format?.duration ?? video?.duration ?? NaN);
  return {
    durationSec: Number.isFinite(duration) ? duration : 0,
    formatName: doc.format?.format_name ?? "",
    videoCodec: video?.codec_name ?? null,
    audioCodec: audio?.codec_name ?? null,
    width: video?.width ?? null,
  };
}

export type AttachVideoOptions = {
  reportFile: string;
  video: string;
  poster?: string;
  caption?: string;
  ffmpegBin: string;
  ffprobeBin: string;
  limitBytes?: number;
  onLog?: (line: string) => void;
};

export type AttachedVideo = {
  video: { src: string; poster?: string; caption?: string };
  bytes: number;
  mode: "remux" | "encode";
  attempts: number;
};

export class AttachVideoError extends Error {}

const sizeOf = async (p: string) => (await stat(p).catch(() => null))?.size ?? null;

export async function attachReportVideo(opts: AttachVideoOptions): Promise<AttachedVideo> {
  const log = opts.onLog ?? (() => {});
  const limit = opts.limitBytes ?? PUBLISH_MAX_FILE_BYTES;
  const dir = path.dirname(path.resolve(opts.reportFile));

  // The report first: nothing is encoded for a file that is not one.
  let raw: Record<string, unknown>;
  try {
    raw = JSON.parse(await readFile(opts.reportFile, "utf8")) as Record<string, unknown>;
  } catch (err) {
    throw new AttachVideoError(`${opts.reportFile} is not readable JSON (${(err as Error).message})`);
  }
  if (!parseReport(raw).ok) throw new AttachVideoError(`${opts.reportFile} is not a report (archilyzer reports check)`);

  const srcBytes = await sizeOf(opts.video);
  if (srcBytes === null) throw new AttachVideoError(`${opts.video} does not exist`);
  if (opts.poster !== undefined) {
    if (!POSTER_EXTS.has(path.extname(opts.poster).toLowerCase())) {
      throw new AttachVideoError(`the poster must be a png, jpg or webp: ${opts.poster}`);
    }
    if ((await sizeOf(opts.poster)) === null) throw new AttachVideoError(`${opts.poster} does not exist`);
  }

  const probe = await probeVideo(opts.ffprobeBin, opts.video);
  let plan = encodePlan(probe, srcBytes, limit);
  if (plan.mode === "refuse") throw new AttachVideoError(`${opts.video} cannot be attached: ${plan.reason}`);
  log(
    plan.mode === "remux"
      ? `${path.basename(opts.video)}: H.264 and under the limit — remuxing (+faststart)`
      : `${path.basename(opts.video)}: ${probe.durationSec.toFixed(1)} s ${probe.videoCodec}/${probe.audioCodec ?? "no audio"} — encoding at ${plan.videoKbps} kb/s video, ${plan.audioKbps} kb/s audio, ≤${plan.maxWidth} px wide`,
  );

  const dst = path.join(dir, REPORT_VIDEO_NAME);
  const tmp = path.join(dir, `.${REPORT_VIDEO_NAME}.${process.pid}.tmp.mp4`);
  let bytes = 0;
  let attempts = 0;
  try {
    for (;;) {
      attempts++;
      await execa(opts.ffmpegBin, encodeArgs(opts.video, tmp, plan));
      bytes = (await sizeOf(tmp)) ?? 0;
      if (bytes > 0 && bytes <= limit) break;
      if (plan.mode !== "encode" || attempts >= MAX_ENCODE_ATTEMPTS) {
        throw new AttachVideoError(
          publishFileSizeProblem(REPORT_VIDEO_NAME, bytes) ?? `ffmpeg wrote nothing for ${opts.video}`,
        );
      }
      const scaled = Math.floor(plan.videoKbps * ((limit * ATTACH_TARGET_FRACTION) / bytes) * 0.95);
      if (scaled < MIN_VIDEO_KBPS) {
        throw new AttachVideoError(`${opts.video} does not fit the limit above ${MIN_VIDEO_KBPS} kb/s of picture — trim it`);
      }
      log(`  ${(bytes / (1024 * 1024)).toFixed(1)} MiB is over the limit — again at ${scaled} kb/s`);
      plan = { ...plan, videoKbps: scaled };
    }
    await rename(tmp, dst);
  } finally {
    await rm(tmp, { force: true });
  }
  log(`  ${REPORT_VIDEO_NAME}: ${(bytes / (1024 * 1024)).toFixed(2)} MiB (limit ${(limit / (1024 * 1024)).toFixed(0)} MiB)`);

  // The poster: given, kept, or drawn from the video.
  const existing = (raw.video as { poster?: unknown; caption?: unknown } | undefined) ?? undefined;
  let poster: string | undefined;
  if (opts.poster !== undefined) {
    poster = `poster${path.extname(opts.poster).toLowerCase()}`;
    if (path.resolve(opts.poster) !== path.join(dir, poster)) await copyFile(opts.poster, path.join(dir, poster));
  } else if (typeof existing?.poster === "string" && (await sizeOf(path.join(dir, existing.poster))) !== null) {
    poster = existing.poster;
  } else {
    poster = REPORT_POSTER_NAME;
    await execa(opts.ffmpegBin, posterArgs(dst, path.join(dir, poster), probe.durationSec * 0.1));
  }
  const posterProblem = publishFileSizeProblem(poster, (await sizeOf(path.join(dir, poster))) ?? 0);
  if (posterProblem) throw new AttachVideoError(posterProblem);

  const caption = opts.caption ?? (typeof existing?.caption === "string" ? existing.caption : undefined);
  const video = { src: REPORT_VIDEO_NAME, poster, ...(caption ? { caption } : {}) };
  const next = { ...raw, video };
  // Only the video's own problems refuse the write: a report with others (a
  // draft's dangling link) gets its video all the same, and `reports check`
  // says the rest.
  const parsed = parseReport(next);
  const videoProblems = parsed.problems.filter((p) => p.path === "video" || p.path.startsWith("video."));
  if (!parsed.ok || videoProblems.length > 0) {
    const first = videoProblems[0] ?? parsed.problems[0];
    throw new AttachVideoError(`report.json would not validate with the video: ${first ? `${first.path}: ${first.message}` : "?"}`);
  }
  const tmpJson = `${opts.reportFile}.${process.pid}.tmp`;
  await writeFile(tmpJson, `${JSON.stringify(next, null, 2)}\n`);
  await rename(tmpJson, opts.reportFile);
  return { video, bytes, mode: plan.mode, attempts };
}