import { test } from "node:test";
import assert from "node:assert/strict";
import { makeSafeController } from "./safeStreamController";

// Run with:
//   pnpm --filter yt-dlp-transcript-common exec tsx --test lib/safeStreamController.test.ts
//
// The guard the media file route and the job log streams wrap their
// controllers in. A consumer that goes away (a scrubbing <audio> cancelling its
// range request) closes the stream under the producer; a raw controller then
// throws ERR_INVALID_STATE from inside the encoder's pipeline, where it leaks as
// an uncaughtException. The safe one goes quiet instead.

function stream() {
  const safe = makeSafeController<Uint8Array>();
  let raw!: ReadableStreamDefaultController<Uint8Array>;
  const rs = new ReadableStream<Uint8Array>({
    start(c) {
      raw = c;
      safe.setController(c);
    },
  });
  return { safe, raw: () => raw, rs };
}

test("a raw controller throws once the stream is closed — the hazard", () => {
  const { raw } = stream();
  raw().close();
  assert.throws(() => raw().enqueue(new Uint8Array(1)), {
    code: "ERR_INVALID_STATE",
  });
});

test("after a cancel, enqueue/close/error are no-ops", async () => {
  const { safe, rs } = stream();
  await rs.cancel();
  safe.markClosed();
  safe.safeEnqueue(new Uint8Array(1));
  safe.safeClose();
  safe.safeError(new Error("late"));
  assert.equal(safe.isClosed(), true);
});

test("a stream closed under it is noticed at the next enqueue, without a throw", () => {
  const { safe, raw } = stream();
  // Closed by someone else — the guard has not been told.
  raw().close();
  assert.equal(safe.isClosed(), false);
  safe.safeEnqueue(new Uint8Array(1));
  assert.equal(safe.isClosed(), true);
  safe.safeClose();
  safe.safeError(new Error("late"));
});

test("close and error each happen once", async () => {
  const { safe, rs } = stream();
  const reader = rs.getReader();
  safe.safeEnqueue(new Uint8Array([1, 2]));
  safe.safeClose();
  safe.safeClose();
  safe.safeError(new Error("after close"));
  assert.deepEqual((await reader.read()).value, new Uint8Array([1, 2]));
  assert.equal((await reader.read()).done, true);
});