// The clip bench's bounded playback, as arithmetic.
//
// The bench used to play a range on the <video> element and stop it from
// `timeupdate`, which fires every 15–250 ms: what you heard ran past the end
// by up to a quarter of a second, and by a different amount every time. That
// is the difference between a cut that lands between two words and one that
// swallows the next syllable, and it could not be judged by ear.
//
// So a bounded range plays from the DECODED audio with Web Audio, the old
// um-triage chooser's technique: an AudioBufferSourceNode started at an exact
// buffer offset and stopped at an exact context time, sample-accurately. The
// picture follows along, muted. These are the numbers that decide where in the
// buffer to start, when to stop, where the playhead is, and when the finale's
// mute mark goes quiet. Pure: no DOM, no Web Audio, so they are unit-tested and
// the component only applies them.
//
// EVERYTHING IS IN ABSOLUTE SOURCE SECONDS except where a name says `wall`
// (seconds of the listener's time, which is source time divided by the rate)
// or `ctx` (the AudioContext's clock).

/** Decoding is per window, but never more than this many seconds at once. */
export const MAX_DECODE_SPAN = 120;

/**
 * Around the selection, when a window is too long to decode whole (a whole
 * recording fetched into the saved-video store): enough to drag an edge and
 * hear it without a second decode.
 */
export const DECODE_MARGIN = 30;

/**
 * How far ahead of "now" a playback is scheduled, in wall seconds.
 *
 * A start scheduled in the past is started late at the SAME offset, so every
 * time computed from it would be early by however late it was. Scheduling a
 * little ahead keeps `start` and `stop` on the clock they were computed on.
 */
export const START_LEAD = 0.03;

/**
 * The mute mark's fade, in source seconds: the BUILD's, so what the bench plays
 * is what the cut does -- a ramp that ENDS at the mark, silent from the mark on.
 * From `mute.mjs`, not `deck.mjs`: this module is in the bench's client bundle,
 * and deck.mjs would bring node:crypto and attribution with it.
 */
export { MUTE_FADE } from "umtool-report-to-video/mute";
import { MUTE_FADE } from "umtool-report-to-video/mute";

/** One Web Audio render quantum, in frames. */
export const RENDER_QUANTUM = 128;

const round3 = (n) => Math.round(n * 1000) / 1000;

/**
 * Which span of a cached window to decode.
 *
 * The whole window when it is short enough -- one decode then serves every
 * drag. A longer one decodes the selection plus a margin each side, clamped to
 * the window, and capped: a decode is held in memory as 32-bit floats, and two
 * minutes of stereo is already ~46 MB.
 *
 * @param {{from: number, to: number}} win the cached file's span
 * @param {{from: number, to: number}} want the range about to be played
 * @param {{max?: number, margin?: number}} [opts]
 * @returns {{from: number, to: number}}
 */
export function decodeSpan(win, want, { max = MAX_DECODE_SPAN, margin = DECODE_MARGIN } = {}) {
  if (win.to - win.from <= max) return { from: win.from, to: win.to };
  let from = Math.max(win.from, want.from - margin);
  let to = Math.min(win.to, Math.max(want.to, want.from) + margin);
  if (to - from > max) {
    // A selection wider than the cap: from its start, as much as fits.
    from = Math.max(win.from, Math.min(want.from, win.to - max));
    to = Math.min(win.to, from + max);
  }
  return { from: round3(from), to: round3(to) };
}

/**
 * Does a decoded span hold this whole range? A hair of tolerance, because the
 * decoded span's end is a frame count divided by a rate.
 *
 * @param {{from: number, to: number} | null} span
 * @param {number} from
 * @param {number} to
 */
export function covers(span, from, to) {
  if (!span) return false;
  return from >= span.from - 0.005 && to <= span.to + 0.005;
}

/**
 * Where in the buffer to start, how much source to play, and how long that
 * takes at this rate.
 *
 * `duration` is SOURCE seconds and `wall` is how long it lasts at `rate`. The
 * stop is scheduled at `start + wall` on the context's clock rather than
 * passed to `start()` as a duration: the spec reads that argument as buffer
 * content, but a stop time on the context clock means one thing at any rate.
 *
 * @param {{from: number, to: number}} span the decoded buffer's absolute span
 * @param {number} bufferSeconds the buffer's own duration
 * @param {number} from
 * @param {number} to
 * @param {number} [rate]
 * @returns {{offset: number, duration: number, wall: number} | null} null when
 *   nothing of the range is in the buffer
 */
export function bufferSchedule(span, bufferSeconds, from, to, rate = 1) {
  const r = rate > 0 ? rate : 1;
  const offset = Math.max(0, Math.min(bufferSeconds, from - span.from));
  const duration = Math.min(bufferSeconds - offset, to - Math.max(from, span.from));
  if (!(duration > 0)) return null;
  return { offset, duration, wall: duration / r };
}

/**
 * The playhead, in source seconds, from the audio clock.
 *
 * @param {number} from where the playback started, in source seconds
 * @param {number} t0 the context time it started at
 * @param {number} now the context time now
 * @param {number} rate
 * @param {number} duration source seconds the playback lasts
 */
export function playheadAt(from, t0, now, rate, duration) {
  const r = rate > 0 ? rate : 1;
  const played = Math.max(0, Math.min(duration, (now - t0) * r));
  return from + played;
}

/**
 * When the mute mark silences a playback of [from, to], as offsets in WALL
 * seconds from its start.
 *
 *   null                     the mark is not in this range (or there is none)
 *   { at: 0, fade: 0 }       the range starts at or after the mark: silent
 *                            from the first sample, the picture still plays
 *   { at, fade }             full level until `at`, then a linear ramp to
 *                            nothing over `fade`, reaching it AT the mark
 *                            (as the build's afade does); a range that starts
 *                            inside the fade ramps from its first sample
 *
 * @param {number | null | undefined} muteFrom
 * @param {number} from
 * @param {number} to
 * @param {number} [rate]
 * @param {number} [fade] source seconds
 * @returns {{at: number, fade: number} | null}
 */
export function muteRamp(muteFrom, from, to, rate = 1, fade = MUTE_FADE) {
  if (muteFrom == null || !Number.isFinite(muteFrom)) return null;
  const r = rate > 0 ? rate : 1;
  if (muteFrom >= to) return null;
  if (muteFrom <= from) return { at: 0, fade: 0 };
  const st = Math.max(from, muteFrom - fade);
  return { at: (st - from) / r, fade: (muteFrom - st) / r };
}

/**
 * The element fallback's stop test, run once per animation frame.
 *
 * Stopping at the first frame PAST the end overruns by up to a frame (and the
 * element's own clock reports late on top of that). Stopping as soon as the
 * end is less than half a frame away splits the error both ways instead: never
 * more than half a frame early or late, at any rate.
 *
 * @param {number} t the element's position, in source seconds
 * @param {number} stopAt
 * @param {number} [rate]
 * @param {number} [frame] wall seconds per animation frame
 */
export function elementShouldStop(t, stopAt, rate = 1, frame = 1 / 60) {
  const r = rate > 0 ? rate : 1;
  return t + (frame * r) / 2 >= stopAt;
}

/**
 * A mute mark as the WRITER reads it: a number of source seconds inside the
 * clip's extent, rounded like an edge -- or `null` to delete the key.
 *
 * `null` and `""` mean "no mark". Anything else must be a finite number in
 * [start, end] (a hair of tolerance, the same 0.02 the cut's check allows).
 *
 * @param {unknown} raw
 * @param {number} start
 * @param {number} end
 * @returns {number | null}
 */
export function parseMuteFrom(raw, start, end) {
  if (raw === null || raw === "") return null;
  const v = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw.trim()) : Number.NaN;
  if (!Number.isFinite(v)) {
    throw new Error(`muteFrom must be a number of source seconds, or empty to clear it (got \`${String(raw)}\`)`);
  }
  if (v < start - 0.02 || v > end + 0.02) {
    throw new Error(
      `muteFrom ${v} must lie inside the clip ${start}–${end} — the mark mutes from there to the clip's end`,
    );
  }
  return Math.round(Math.min(end, Math.max(start, v)) * 100) / 100;
}

/**
 * A RIFF/WAVE header for interleaved 16-bit PCM.
 *
 * Written by hand because ffmpeg writing WAV to a pipe cannot seek back to fill
 * in the sizes, and a header that says "unknown length" is one more thing a
 * decoder may or may not forgive.
 *
 * @param {{channels: number, sampleRate: number, dataBytes: number}} f
 * @returns {Uint8Array} 44 bytes
 */
export function wavHeader({ channels, sampleRate, dataBytes }) {
  const b = new Uint8Array(44);
  const v = new DataView(b.buffer);
  const tag = (at, s) => {
    for (let i = 0; i < 4; i += 1) b[at + i] = s.charCodeAt(i);
  };
  tag(0, "RIFF");
  v.setUint32(4, 36 + dataBytes, true);
  tag(8, "WAVE");
  tag(12, "fmt ");
  v.setUint32(16, 16, true);
  v.setUint16(20, 1, true); // PCM
  v.setUint16(22, channels, true);
  v.setUint32(24, sampleRate, true);
  v.setUint32(28, sampleRate * channels * 2, true);
  v.setUint16(32, channels * 2, true);
  v.setUint16(34, 16, true);
  tag(36, "data");
  v.setUint32(40, dataBytes, true);
  return b;
}