import { describe, expect, it, beforeEach } from "@effect/vitest";

import {
  acquireBuildSlot,
  releaseBuildSlot,
  resetBuildSlotsForTest,
  currentActiveBuildsForTest,
  currentQueueLengthForTest,
} from "./session-build-semaphore";

describe("session-build-semaphore", () => {
  beforeEach(() => {
    resetBuildSlotsForTest();
  });

  it("grants up to the cap immediately, with no wait", async () => {
    const results = await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);
    expect(results).toEqual([
      { acquired: true, waitMs: 0, timedOut: false },
      { acquired: true, waitMs: 0, timedOut: false },
      { acquired: true, waitMs: 0, timedOut: false },
      { acquired: true, waitMs: 0, timedOut: false },
    ]);
    expect(currentActiveBuildsForTest()).toBe(4);
    expect(currentQueueLengthForTest()).toBe(0);
  });

  it("queues a build past the cap until a slot is released", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);
    expect(currentActiveBuildsForTest()).toBe(4);

    let fifthResolved = false;
    const fifth = acquireBuildSlot().promise.then((result) => {
      fifthResolved = true;
      return result;
    });

    expect(currentQueueLengthForTest()).toBe(1);
    // Nothing releases the pending fifth build without an explicit release —
    // it must not resolve on its own.
    await Promise.resolve();
    await Promise.resolve();
    expect(fifthResolved).toBe(false);

    releaseBuildSlot();
    const result = await fifth;
    expect(fifthResolved).toBe(true);
    expect(result.acquired).toBe(true);
    expect(result.timedOut).toBe(false);
    expect(result.waitMs).toBeGreaterThanOrEqual(0);
    // The freed slot went straight to the waiter — total active stays at cap.
    expect(currentActiveBuildsForTest()).toBe(4);
    expect(currentQueueLengthForTest()).toBe(0);
  });

  it("releases queued waiters in FIFO order", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);

    const order: number[] = [];
    const second = acquireBuildSlot().promise.then(() => order.push(2));
    const third = acquireBuildSlot().promise.then(() => order.push(3));
    const fourth = acquireBuildSlot().promise.then(() => order.push(4));
    expect(currentQueueLengthForTest()).toBe(3);

    releaseBuildSlot();
    await second;
    releaseBuildSlot();
    await third;
    releaseBuildSlot();
    await fourth;

    expect(order).toEqual([2, 3, 4]);
  });

  it("never deadlocks: releasing a slot always makes forward progress for the next waiter", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);

    // 6 more builds arrive while all 4 slots are held — all 6 queue.
    const queued = Array.from({ length: 6 }, () => acquireBuildSlot().promise);
    expect(currentQueueLengthForTest()).toBe(6);

    // The 4 in-flight builds finish one at a time; each release must hand its
    // slot straight to the next queued waiter rather than sitting idle.
    for (let i = 0; i < 4; i++) releaseBuildSlot();
    await Promise.all(queued.slice(0, 4));
    expect(currentActiveBuildsForTest()).toBe(4);
    expect(currentQueueLengthForTest()).toBe(2);

    // Those 4 finish too, freeing the last 2 queued waiters.
    for (let i = 0; i < 4; i++) releaseBuildSlot();
    await Promise.all(queued.slice(4));
    expect(currentActiveBuildsForTest()).toBe(2);
    expect(currentQueueLengthForTest()).toBe(0);

    // And the last 2 finish, draining the semaphore completely.
    releaseBuildSlot();
    releaseBuildSlot();
    expect(currentActiveBuildsForTest()).toBe(0);
    expect(currentQueueLengthForTest()).toBe(0);
  });

  it("does not go negative when released more times than acquired", () => {
    releaseBuildSlot();
    releaseBuildSlot();
    expect(currentActiveBuildsForTest()).toBe(0);
  });

  it("cancelling a queued waiter dequeues it, and a subsequent release goes to the next waiter", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);
    expect(currentActiveBuildsForTest()).toBe(4);

    const cancelled = acquireBuildSlot();
    let cancelledSettled = false;
    void cancelled.promise.then(() => {
      cancelledSettled = true;
    });

    const next = acquireBuildSlot();
    let nextResult: Awaited<typeof next.promise> | undefined;
    void next.promise.then((r) => {
      nextResult = r;
    });

    expect(currentQueueLengthForTest()).toBe(2);

    // Interrupted before it was ever granted a slot (e.g. client disconnect
    // while queued) — this must not hand it a slot later, and must not block
    // the waiter behind it.
    cancelled.cancel();
    expect(currentQueueLengthForTest()).toBe(1);

    releaseBuildSlot();
    await next.promise;

    // The cancelled waiter's promise never resolves and never gets a slot;
    // the freed slot went straight to the next waiter instead.
    await Promise.resolve();
    await Promise.resolve();
    expect(cancelledSettled).toBe(false);
    expect(nextResult).toEqual({ acquired: true, waitMs: expect.any(Number), timedOut: false });
    expect(currentActiveBuildsForTest()).toBe(4);
    expect(currentQueueLengthForTest()).toBe(0);
  });

  it("cancel-after-grant releases the slot instead of leaking it", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);
    expect(currentActiveBuildsForTest()).toBe(4);

    // Queues, then gets granted a slot by the release below.
    const grantedThenAbandoned = acquireBuildSlot();
    releaseBuildSlot();
    const result = await grantedThenAbandoned.promise;
    expect(result.acquired).toBe(true);
    // Still at the cap: the freed slot was handed straight to this waiter.
    expect(currentActiveBuildsForTest()).toBe(4);

    // The caller never gets to consume the grant (e.g. its fiber was
    // interrupted in the same tick the grant happened) and cancels instead —
    // this must give the slot back rather than leaking it forever.
    grantedThenAbandoned.cancel();
    expect(currentActiveBuildsForTest()).toBe(3);

    // Idempotent: a second cancel must not release it again.
    grantedThenAbandoned.cancel();
    expect(currentActiveBuildsForTest()).toBe(3);

    // And the freed slot is usable by a fresh acquire.
    const fresh = await acquireBuildSlot().promise;
    expect(fresh).toEqual({ acquired: true, waitMs: 0, timedOut: false });
    expect(currentActiveBuildsForTest()).toBe(4);
  });

  it("cancelling an immediately-granted (never-queued) slot releases it exactly once", async () => {
    const handle = acquireBuildSlot();
    await handle.promise;
    expect(currentActiveBuildsForTest()).toBe(1);

    handle.cancel();
    expect(currentActiveBuildsForTest()).toBe(0);

    // Idempotent.
    handle.cancel();
    expect(currentActiveBuildsForTest()).toBe(0);
  });

  it("proceeds without a slot when the queue wait exceeds the timeout, and does not count it as active", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);
    expect(currentActiveBuildsForTest()).toBe(4);

    const timedOutHandle = acquireBuildSlot(10);
    const result = await timedOutHandle.promise;

    expect(result).toEqual({ acquired: false, waitMs: expect.any(Number), timedOut: true });
    expect(result.waitMs).toBeGreaterThanOrEqual(10);
    // A timed-out waiter never counted against the cap.
    expect(currentActiveBuildsForTest()).toBe(4);
    expect(currentQueueLengthForTest()).toBe(0);

    // A timed-out waiter never held a slot, so cancelling it must not
    // release one that was never granted.
    timedOutHandle.cancel();
    expect(currentActiveBuildsForTest()).toBe(4);

    // The 4 originally-held slots are still releasable normally.
    releaseBuildSlot();
    releaseBuildSlot();
    releaseBuildSlot();
    releaseBuildSlot();
    expect(currentActiveBuildsForTest()).toBe(0);
  });

  it("a waiter that times out is removed from the queue and does not block waiters behind it", async () => {
    await Promise.all([
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
      acquireBuildSlot().promise,
    ]);

    const timesOut = acquireBuildSlot(10);
    const staysQueued = acquireBuildSlot();
    expect(currentQueueLengthForTest()).toBe(2);

    const timedOutResult = await timesOut.promise;
    expect(timedOutResult.timedOut).toBe(true);
    // Only the timed-out waiter left the queue; the other is still waiting.
    expect(currentQueueLengthForTest()).toBe(1);

    releaseBuildSlot();
    const staysQueuedResult = await staysQueued.promise;
    expect(staysQueuedResult).toEqual({
      acquired: true,
      waitMs: expect.any(Number),
      timedOut: false,
    });
    expect(currentQueueLengthForTest()).toBe(0);
  });
});