// Isolated component experiment; no application transport, feedback or policy.
const profiles = [[480, 270, 312500], [960, 540, 1250000], [1920, 1080, 5000000]];
const fps = 30;
const trace = [[2, 2], [2, 0], [0, 0], [1, 1], [2, 2], [2, 0], [2, 2]];
const phaseFrames = 32;
const now = () => performance.now();
const assert = (condition, message) => { if (!condition) throw Error(message); };
const summarize = (values) => {
  const sorted = [...values].sort((a, b) => a - b);
  return { mean: values.reduce((a, b) => a + b, 0) / values.length, p95: sorted[Math.ceil(sorted.length * .95) - 1], max: sorted.at(-1) };
};

function makeInput() {
  return Array.from({ length: 32 }, (_, frame) => {
    const data = new Uint8Array(1920 * 1080 * 3 / 2).fill(128);
    for (let y = 0; y < 1080; y++) for (let x = 0; x < 1920; x++) {
      const u = (x + frame * 4) % 128;
      const v = y % 128;
      data[y * 1920 + x] = 32 + ((u >> 3) ^ (v >> 3)) * 8 + ((u ^ v) & 31) * 2;
    }
    return data;
  });
}

function config(codec, layer) {
  const [width, height, bitrate] = profiles[layer];
  return { codec, width, height, bitrate, framerate: fps, latencyMode: "realtime",
    bitrateMode: "constant", hardwareAcceleration: "prefer-software",
    ...(codec.startsWith("avc") ? { avc: { format: "annexb" } } : {}) };
}

function encoder(codec, layer) {
  let result;
  let failure;
  const value = new VideoEncoder({ output: (chunk, metadata) => { result = { chunk, metadata }; }, error: (error) => { failure = error; } });
  value.configure(config(codec, layer));
  return {
    value,
    async encode(frame, keyFrame) {
      result = undefined;
      value.encode(frame, { keyFrame });
      await value.flush();
      if (failure) throw failure;
      assert(result?.chunk.timestamp === frame.timestamp, "Missing/out-of-order encoded frame");
      if (keyFrame) assert(result.chunk.type === "key", "Missing switch keyframe");
      return result;
    },
  };
}

function decoder(codec) {
  let complete;
  let reject;
  let layer = -1;
  let failure;
  const value = new VideoDecoder({
    output: (frame) => { const accept = complete; complete = undefined; if (accept) accept(frame); else frame.close(); },
    error: (error) => { failure = error; reject?.(error); },
  });
  return {
    value,
    async decode(packet, nextLayer) {
      if (layer !== nextLayer) {
        const [codedWidth, codedHeight] = profiles[nextLayer];
        value.configure({ codec, codedWidth, codedHeight, optimizeForLatency: true, hardwareAcceleration: "prefer-software" });
        layer = nextLayer;
      }
      if (failure) throw failure;
      const promise = new Promise((resolve, rejectPromise) => { complete = resolve; reject = rejectPromise; });
      value.decode(packet);
      const frame = await promise;
      assert(frame.displayWidth === profiles[nextLayer][0] && frame.displayHeight === profiles[nextLayer][1], "Wrong decoded dimensions");
      return frame;
    },
  };
}

function rawFrame(input, frame) {
  return new VideoFrame(input[frame % input.length], { format: "NV12", codedWidth: 1920, codedHeight: 1080,
    timestamp: Math.round(frame * 1e6 / fps), duration: Math.round(1e6 / fps) });
}

async function prepareIngress(codec, input) {
  const source = encoder(codec, 2);
  const packets = [];
  try {
    for (let i = 0; i < input.length; i++) {
      const frame = rawFrame(input, i);
      try {
        const { chunk } = await source.encode(frame, i === 0);
        const data = new Uint8Array(chunk.byteLength);
        chunk.copyTo(data);
        packets.push({ data, type: chunk.type });
      } finally { frame.close(); }
    }
    return packets;
  } finally { source.value.close(); }
}

async function run(codec, policy, role, input, ingress) {
  const encoders = [null, null, null];
  const receivers = [decoder(codec), decoder(codec)];
  const inputDecoder = role === "relay" ? decoder(codec) : null;
  let previous = [-1, -1];
  const encoded = [0, 0, 0];
  const generatedBytes = [0, 0, 0];
  const selectedBytes = [0, 0];
  const decoded = [0, 0];
  const switches = [];
  const phases = [];
  let creates = 0;
  let ingressDecodes = 0;
  const metrics = { management: [], input: [], encodeReady: [], allReceivers: [], processing: [] };
  const start = now();
  try {
    for (let index = 0; index < trace.length * phaseFrames; index++) {
      const phase = Math.floor(index / phaseFrames);
      const demand = trace[phase];
      const tick = now();
      const demanded = new Set(demand);
      const active = policy === "exact" ? demanded : new Set(Array.from({ length: Math.max(...demand) + 1 }, (_, i) => i));
      // A relay already has H. It never re-encodes H or starts lower encoders just for H/H.
      if (role === "relay") {
        active.delete(2);
        if (!demand.some((i) => i < 2)) active.clear();
      }
      const switched = demand.map((layer, child) => previous[child] !== layer);
      const keyframes = new Set(demand.filter((_, child) => switched[child]));
      for (let layer = 0; layer < 3; layer++) {
        if (active.has(layer) && !encoders[layer]) { encoders[layer] = encoder(codec, layer); creates++; keyframes.add(layer); }
        if (!active.has(layer) && encoders[layer]) { encoders[layer].value.close(); encoders[layer] = null; }
      }
      const afterManagement = now();
      let sourceFrame;
      const outputs = new Map();
      const deliveries = [];
      const deliver = async (layer, child, packetPromise) => {
        const packet = await packetPromise;
        assert(packet, "Missing demanded encoding");
        if (switched[child]) assert(packet.type === "key", "Switch did not start at a recovery frame");
        const frame = await receivers[child].decode(packet, layer);
        assert(frame.timestamp === Math.round(index * 1e6 / fps), "Wrong decoded timestamp");
        frame.close();
        decoded[child]++;
        selectedBytes[child] += packet.byteLength;
        const delivered = now();
        if (switched[child] && index > 0) switches.push({ index, child, layer, ms: delivered - tick, bytes: packet.byteLength });
        return delivered;
      };
      if (role === "relay") {
        const sourcePacket = ingress[index % ingress.length];
        const packet = new EncodedVideoChunk({ ...sourcePacket, timestamp: Math.round(index * 1e6 / fps) });
        outputs.set(2, Promise.resolve(packet));
        demand.forEach((layer, child) => { if (layer === 2) deliveries[child] = deliver(layer, child, outputs.get(layer)); });
        if (active.size) {
          sourceFrame = await inputDecoder.decode(packet, 2);
          ingressDecodes++;
        }
        // Demand phases align with input GOPs; real upstream PLI/network delay is not measured.
      } else {
        sourceFrame = rawFrame(input, index);
      }
      const afterInput = now();
      try {
        for (const layer of active) {
          outputs.set(layer, encoders[layer].encode(sourceFrame, keyframes.has(layer)).then(({ chunk }) => {
            encoded[layer]++;
            generatedBytes[layer] += chunk.byteLength;
            return chunk;
          }));
        }
        demand.forEach((layer, child) => { deliveries[child] ??= deliver(layer, child, outputs.get(layer)); });
        await Promise.all(outputs.values());
      } finally { sourceFrame?.close(); }
      const afterEncode = now();
      const decodedAt = await Promise.all(deliveries);
      const afterDecode = Math.max(...decodedAt);
      const row = { management: afterManagement - tick, input: afterInput - afterManagement,
        encodeReady: afterEncode - afterInput, allReceivers: afterDecode - tick, processing: now() - tick };
      for (const key of Object.keys(metrics)) metrics[key].push(row[key]);
      if (!phases[phase]) phases[phase] = { demand, frames: 0, work: [] };
      phases[phase].frames++;
      phases[phase].work.push(row.processing);
      previous = demand;
      const delay = start + (index + 1) * 1000 / fps - now();
      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
    }
    const expected = role === "host" ? policy === "exact" ? [96, 32, 160] : [224, 192, 160]
      : policy === "exact" ? [96, 32, 0] : [128, 96, 0];
    assert(encoded.every((count, layer) => count === expected[layer]), "Unexpected encode count");
    assert(decoded.every((count) => count === 224), "Missing receiver frames");
    assert(ingressDecodes === (role === "relay" ? 128 : 0), "Repeated or unnecessary input decode");
    return { codec, policy, role, encoded, decoded, ingressDecodes, creates, generatedBytes, selectedBytes, switches,
      elapsedMs: now() - start, metrics: Object.fromEntries(Object.entries(metrics).map(([key, values]) => [key, summarize(values)])),
      overFrameBudget: metrics.processing.filter((value) => value > 1000 / fps).length,
      phases: phases.map(({ demand, frames, work }) => ({ demand, frames, work: summarize(work) })) };
  } finally {
    for (const slot of [...encoders, ...receivers, inputDecoder]) if (slot && slot.value.state !== "closed") slot.value.close();
  }
}

self.onmessage = async () => {
  try {
    const input = makeInput();
    const results = [];
    const support = {};
    for (const codec of ["vp8", "avc1.420028"]) {
      support[codec] = (await VideoEncoder.isConfigSupported(config(codec, 2))).supported;
      if (!support[codec]) continue;
      const ingress = await prepareIngress(codec, input);
      for (let round = 1; round <= 2; round++) {
        for (const role of ["host", "relay"]) for (const policy of round === 1 ? ["exact", "envelope"] : ["envelope", "exact"]) {
          self.postMessage({ progress: `${codec} ${round} ${role} ${policy}` });
          results.push({ round, ...await run(codec, policy, role, input, ingress) });
        }
      }
    }
    self.postMessage({ completed: true, scope: "WebCodecs software preference; independent child decode; no RTP, network, hardware or perceptual acceptance",
      userAgent: navigator.userAgent, support, profiles, fps, phaseFrames, trace, results });
  } catch (error) { self.postMessage({ error: String(error.stack ?? error) }); }
};