/**
 * mapWithConcurrency — bounded async fan-out.
 *
 * The /issues and /pulls dashboards enriched their candidate lists with
 * `for (const c of candidates) { await enrich(c) }`, serialising one DB
 * round-trip per item: up to 600 sequential queries per /issues page load
 * (2 per issue × 300 candidates). Latency was N × RTT.
 *
 * A plain Promise.all would fix wall-clock but fire all N at once, which on a
 * pooled managed Postgres just relocates the queue into the connection pool.
 * These pin down both properties that matter: order preservation (the rows
 * are zipped back against `candidates` by index) and the concurrency cap.
 */

import { describe, expect, it } from "bun:test";
import { mapWithConcurrency, DB_FANOUT_LIMIT } from "../lib/concurrency";

const tick = () => new Promise((r) => setTimeout(r, 1));

describe("order preservation", () => {
  it("returns results in INPUT order, not completion order", async () => {
    // Deliberately invert the durations so completion order is the reverse
    // of input order. Zipping by index in the callers depends on this.
    const items = [1, 2, 3, 4, 5];
    const out = await mapWithConcurrency(items, 5, async (n) => {
      await new Promise((r) => setTimeout(r, (6 - n) * 5));
      return n * 10;
    });
    expect(out).toEqual([10, 20, 30, 40, 50]);
  });

  it("passes the index through", async () => {
    const out = await mapWithConcurrency(["a", "b", "c"], 2, async (v, i) => `${i}:${v}`);
    expect(out).toEqual(["0:a", "1:b", "2:c"]);
  });

  it("handles an empty list without spawning workers", async () => {
    let called = 0;
    const out = await mapWithConcurrency([], 8, async () => { called++; return 1; });
    expect(out).toEqual([]);
    expect(called).toBe(0);
  });
});

describe("concurrency is actually bounded", () => {
  it("never exceeds the limit in flight", async () => {
    let inFlight = 0;
    let peak = 0;
    await mapWithConcurrency(Array.from({ length: 50 }, (_, i) => i), 5, async () => {
      inFlight++;
      peak = Math.max(peak, inFlight);
      await tick();
      inFlight--;
      return null;
    });
    expect(peak).toBeLessThanOrEqual(5);
    expect(peak).toBeGreaterThan(1); // ...but it IS parallel, not serial
  });

  it("clamps the limit to the item count", async () => {
    let peak = 0;
    let inFlight = 0;
    await mapWithConcurrency([1, 2], 100, async () => {
      inFlight++;
      peak = Math.max(peak, inFlight);
      await tick();
      inFlight--;
      return null;
    });
    expect(peak).toBeLessThanOrEqual(2);
  });

  it("treats a zero or negative limit as serial rather than deadlocking", async () => {
    // A limit of 0 would spawn no workers and hang forever if unclamped.
    const out = await mapWithConcurrency([1, 2, 3], 0, async (n) => n);
    expect(out).toEqual([1, 2, 3]);
  });

  it("processes every item exactly once", async () => {
    const seen: number[] = [];
    await mapWithConcurrency(Array.from({ length: 30 }, (_, i) => i), 7, async (n) => {
      await tick();
      seen.push(n);
      return n;
    });
    expect(seen.length).toBe(30);
    expect(new Set(seen).size).toBe(30);
  });
});

describe("the shared limit", () => {
  it("is conservative enough for a pooled managed Postgres", () => {
    expect(DB_FANOUT_LIMIT).toBeGreaterThan(1);
    expect(DB_FANOUT_LIMIT).toBeLessThanOrEqual(20);
  });
});