import test from "node:test";
import assert from "node:assert/strict";
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
  enumerateValidAccountIds,
  isProvisionedAccount,
  _resetEnumerationCache,
} from "../index.js";

const BOOT_ID = "12345678-9abc-def0-1234-56789abcdef0";
const LATER_ID = "99999999-aaaa-bbbb-cccc-dddddddddddd";

/** One valid account dir (BOOT_ID) that existed at "boot". */
function makeFixture(): string {
  const root = mkdtempSync(join(tmpdir(), "acct-prov-"));
  mkdirSync(join(root, BOOT_ID));
  writeFileSync(join(root, BOOT_ID, "account.json"), JSON.stringify({ id: BOOT_ID }));
  return root;
}

/** Provision a second account dir on disk AFTER boot (simulates account_create). */
function provisionLater(root: string): void {
  mkdirSync(join(root, LATER_ID));
  writeFileSync(join(root, LATER_ID, "account.json"), JSON.stringify({ id: LATER_ID }));
}

test("isProvisionedAccount: a created-after-boot id resolves via re-scan on miss", () => {
  _resetEnumerationCache();
  const root = makeFixture();
  try {
    // Warm the cache at "boot" — only BOOT_ID is present.
    assert.deepEqual(enumerateValidAccountIds(root), [BOOT_ID]);
    // A sub-account is provisioned after the snapshot.
    provisionLater(root);
    // Miss against the cached set must re-scan disk and find it — no restart.
    assert.equal(isProvisionedAccount(root, LATER_ID), true);
  } finally {
    rmSync(root, { recursive: true });
  }
});

test("isProvisionedAccount: a truly-absent id still returns false after re-scan", () => {
  _resetEnumerationCache();
  const root = makeFixture();
  try {
    enumerateValidAccountIds(root); // warm
    const bogus = "00000000-0000-0000-0000-000000000000";
    assert.equal(isProvisionedAccount(root, bogus), false);
  } finally {
    rmSync(root, { recursive: true });
  }
});

test("isProvisionedAccount: a warmed hit returns true without re-scanning", () => {
  _resetEnumerationCache();
  const root = makeFixture();
  try {
    enumerateValidAccountIds(root); // warm = [BOOT_ID]
    // Provision a second dir AFTER warming.
    provisionLater(root);
    // HIT: BOOT_ID is already in the cached set → true, and the cache must NOT
    // be refreshed (no readdirSync). Proof: the cached set still hides LATER_ID.
    assert.equal(isProvisionedAccount(root, BOOT_ID), true);
    assert.deepEqual(
      enumerateValidAccountIds(root),
      [BOOT_ID],
      "a hit must not refresh the cache — LATER_ID must stay hidden",
    );
  } finally {
    rmSync(root, { recursive: true });
  }
});

test("isProvisionedAccount: cold cache scans disk and answers", () => {
  _resetEnumerationCache();
  const root = makeFixture();
  try {
    // No warm call — cache is cold. A miss (cold) must scan and answer both ways.
    assert.equal(isProvisionedAccount(root, BOOT_ID), true);
    assert.equal(isProvisionedAccount(root, LATER_ID), false);
  } finally {
    rmSync(root, { recursive: true });
  }
});