import { describe, expect, test } from "bun:test";
import { Stream } from "../stream";

describe("Stream", () => {
  test("enqueue then read resolves with the value", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    stream.enqueue(42);
    const result = await stream.next();
    expect(result).toEqual({ done: false, value: 42 });
  });

  test("enqueue multiple then drain in order", async () => {
    const stream = new Stream<string>();
    stream[Symbol.asyncIterator]();
    stream.enqueue("a");
    stream.enqueue("b");
    stream.enqueue("c");
    expect(await stream.next()).toEqual({ done: false, value: "a" });
    expect(await stream.next()).toEqual({ done: false, value: "b" });
    expect(await stream.next()).toEqual({ done: false, value: "c" });
  });

  test("next() blocks until enqueue provides a value", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    const promise = stream.next();
    // Not resolved yet — enqueue after a microtask
    stream.enqueue(99);
    const result = await promise;
    expect(result).toEqual({ done: false, value: 99 });
  });

  test("done() resolves pending reader with done:true", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    const promise = stream.next();
    stream.done();
    expect(await promise).toEqual({ done: true, value: undefined });
  });

  test("done() with no pending reader — subsequent next returns done:true", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    stream.done();
    expect(await stream.next()).toEqual({ done: true, value: undefined });
  });

  test("error() rejects pending reader", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    const promise = stream.next();
    stream.error(new Error("boom"));
    expect(promise).rejects.toThrow("boom");
  });

  test("error() after done — hasError is set but next returns done:true (isDone checked first)", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    stream.done();
    stream.error(new Error("late error"));
    // next() checks isDone before hasError, so it returns done:true
    expect(await stream.next()).toEqual({ done: true, value: undefined });
  });

  test("enqueue after done — queue is checked before isDone, value is consumed", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    stream.done();
    stream.enqueue(1);
    // next() checks queue.length > 0 first, so enqueued value is returned
    expect(await stream.next()).toEqual({ done: false, value: 1 });
    // After draining queue, done takes effect
    expect(await stream.next()).toEqual({ done: true, value: undefined });
  });

  test("return() marks stream as done and calls returned callback", async () => {
    let called = false;
    const stream = new Stream<number>(() => { called = true; });
    stream[Symbol.asyncIterator]();
    const result = await stream.return();
    expect(result).toEqual({ done: true, value: undefined });
    expect(called).toBe(true);
    // Subsequent next returns done
    expect(await stream.next()).toEqual({ done: true, value: undefined });
  });

  test("return() without callback still works", async () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    const result = await stream.return();
    expect(result).toEqual({ done: true, value: undefined });
  });

  test("Symbol.asyncIterator throws on second call", () => {
    const stream = new Stream<number>();
    stream[Symbol.asyncIterator]();
    expect(() => stream[Symbol.asyncIterator]()).toThrow(
      "Stream can only be iterated once"
    );
  });

  test("for-await-of iteration drains queued values then ends", async () => {
    const stream = new Stream<string>();
    stream.enqueue("x");
    stream.enqueue("y");
    stream.done();
    const results: string[] = [];
    for await (const value of stream) {
      results.push(value);
    }
    expect(results).toEqual(["x", "y"]);
  });

  test("for-await-of blocks until done", async () => {
    const stream = new Stream<number>();
    const results: number[] = [];

    const iterPromise = (async () => {
      for await (const v of stream) {
        results.push(v);
      }
    })();

    // Enqueue after a tick
    await Promise.resolve();
    stream.enqueue(1);
    stream.enqueue(2);
    stream.done();

    await iterPromise;
    expect(results).toEqual([1, 2]);
  });

  test("error during for-await-of rejects the loop", async () => {
    const stream = new Stream<number>();
    const iterPromise = (async () => {
      for await (const _ of stream) {
        // will error before any value
      }
    })();
    stream.error(new Error("stream broken"));
    expect(iterPromise).rejects.toThrow("stream broken");
  });

  test("concurrent enqueue from multiple sources does not lose data", async () => {
    const stream = new Stream<number>();
    // Rapid sequential enqueue
    for (let i = 0; i < 100; i++) {
      stream.enqueue(i);
    }
    stream.done();

    const results: number[] = [];
    for await (const v of stream) {
      results.push(v);
    }
    expect(results.length).toBe(100);
    expect(results[0]).toBe(0);
    expect(results[99]).toBe(99);
  });
});