import { expect, test } from "vitest";
import { ReadinessManager } from "../src/runtime/readiness-manager.js";

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((r) => { resolve = r; });
  return { promise, resolve };
}

test("readiness is single-flight per workspace and caches a short-lived success", async () => {
  let now = 1_000;
  let calls = 0;
  const first = deferred<any>();
  const tht = {
    ollamaEnsure: async () => {
      calls += 1;
      return first.promise;
    },
  } as any;
  const readiness = new ReadinessManager(tht, 60, 500, () => now);

  const a = readiness.ensure("psd");
  const b = readiness.ensure("psd");
  expect(calls).toBe(1);
  first.resolve({ ok: true, model_name: "embed" });
  await expect(a).resolves.toMatchObject({ ok: true });
  await expect(b).resolves.toMatchObject({ ok: true });

  await readiness.ensure("psd");
  expect(calls).toBe(1);
  now += 501;
  tht.ollamaEnsure = async () => { calls += 1; return { ok: true }; };
  await readiness.ensure("psd");
  expect(calls).toBe(2);
});

test("readiness keys workspaces independently", async () => {
  const seen: string[] = [];
  const tht = {
    ollamaEnsure: async (workspace: string) => {
      seen.push(workspace);
      return { ok: true };
    },
  } as any;
  const readiness = new ReadinessManager(tht, 60);
  await Promise.all([readiness.ensure("a"), readiness.ensure("b")]);
  expect(seen.sort()).toEqual(["a", "b"]);
});

test("readiness does not cache failed results", async () => {
  let calls = 0;
  const tht = {
    ollamaEnsure: async () => {
      calls += 1;
      return calls === 1 ? { ok: false, error: "down" } : { ok: true };
    },
  } as any;
  const readiness = new ReadinessManager(tht, 60);
  await expect(readiness.ensure("psd")).resolves.toMatchObject({ ok: false });
  await expect(readiness.ensure("psd")).resolves.toMatchObject({ ok: true });
  expect(calls).toBe(2);
});