import { describe, expect, test } from "bun:test";

import { AsyncLock, AsyncQueue } from "./async";

describe("AsyncLock", () => {
  test("serializes critical sections in FIFO order", async () => {
    const lock = new AsyncLock();
    const order: number[] = [];
    const run = async (id: number): Promise<void> => {
      const release = await lock.acquire();
      order.push(id);
      // Yield a macrotask so overlapping sections would interleave if unlocked.
      await new Promise((resolve) => setTimeout(resolve, 1));
      order.push(-id);
      release();
    };
    await Promise.all([run(1), run(2), run(3)]);
    // Each section runs to completion (id then -id) before the next starts, and
    // waiters resume in the order they queued.
    expect(order).toEqual([1, -1, 2, -2, 3, -3]);
  });

  test("the release closure is idempotent — a double-call cannot free two waiters", async () => {
    const lock = new AsyncLock();
    const first = await lock.acquire();
    let bAcquired = false;
    let cAcquired = false;
    void lock.acquire().then(() => {
      bAcquired = true;
    });
    void lock.acquire().then(() => {
      cAcquired = true;
    });
    first();
    first(); // second call must be a no-op
    await new Promise((resolve) => setTimeout(resolve, 1));
    // Only one waiter may hold the lock; the double-release must not admit both.
    expect(bAcquired).toBe(true);
    expect(cAcquired).toBe(false);
  });

  test("second acquire blocks until the first releases", async () => {
    const lock = new AsyncLock();
    const first = await lock.acquire();
    let secondAcquired = false;
    const second = lock.acquire().then((release) => {
      secondAcquired = true;
      return release;
    });
    await new Promise((resolve) => setTimeout(resolve, 1));
    expect(secondAcquired).toBe(false);
    first();
    (await second)();
    expect(secondAcquired).toBe(true);
  });
});

describe("AsyncQueue", () => {
  test("returns a buffered item immediately", async () => {
    const queue = new AsyncQueue<number>(4);
    queue.push(7);
    expect(await queue.shift()).toBe(7);
  });

  test("a pending shift wakes on the next push (no lost wakeup)", async () => {
    const queue = new AsyncQueue<string>(4);
    const pending = queue.shift();
    queue.push("hello");
    expect(await pending).toBe("hello");
  });

  test("push delivers to a waiter FIFO and bypasses the buffer", async () => {
    const queue = new AsyncQueue<number>(4);
    const a = queue.shift();
    const b = queue.shift();
    queue.push(1);
    queue.push(2);
    expect(await a).toBe(1);
    expect(await b).toBe(2);
    expect(queue.size).toBe(0);
  });

  test("evicts oldest when over capacity", () => {
    const queue = new AsyncQueue<number>(2);
    queue.push(1);
    queue.push(2);
    queue.push(3);
    expect(queue.evictions).toBe(1);
    expect(queue.size).toBe(2);
  });

  test("close rejects pending shifts and drops later pushes", async () => {
    const queue = new AsyncQueue<number>(4);
    const pending = queue.shift();
    queue.close();
    await expect(pending).rejects.toThrow("Queue closed");
    expect(queue.push(1)).toBe(false);
  });

  test("aborting a pending shift rejects it and removes the resolver", async () => {
    const queue = new AsyncQueue<number>(4);
    const controller = new AbortController();
    const pending = queue.shift(controller.signal);
    controller.abort();
    await expect(pending).rejects.toThrow("Queue aborted");
    // The aborted waiter must not steal the next pushed item.
    queue.push(42);
    expect(await queue.shift()).toBe(42);
  });

  test("shift on a closed drained queue rejects instead of hanging", async () => {
    const queue = new AsyncQueue<number>(4);
    queue.close();
    await expect(queue.shift()).rejects.toThrow("Queue closed");
  });

  test("shift with an already-aborted signal rejects instead of hanging", async () => {
    const queue = new AsyncQueue<number>(4);
    const controller = new AbortController();
    controller.abort();
    await expect(queue.shift(controller.signal)).rejects.toThrow("Queue aborted");
    // No resolver leaked: a normal push/shift still works.
    queue.push(5);
    expect(await queue.shift()).toBe(5);
  });
});