/**
 * Unit tests for the persisted CDP target — no browser required.
 *
 * The store is what makes /browser-target outlive the pi session that ran it,
 * because the browser daemon is machine-wide. Its central obligation is that a
 * damaged file degrades to "nothing stored" — falling back to the built-in
 * default — rather than throwing and taking browser control down with it.
 *
 * Run: npx tsx test/cdp/target-store-test.ts
 */
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

let passed = 0;
let failed = 0;
const check = (cond: boolean, label: string): void => {
  if (cond) {
    passed++;
    console.log(`  ✓ ${label}`);
  } else {
    failed++;
    console.error(`  ✗ ${label}`);
  }
};

async function main(): Promise<void> {
  // The store resolves its path from pi's agent dir, which paths.ts derives
  // from the environment — so point that at a scratch dir before importing.
  const root = mkdtempSync(join(tmpdir(), "pi-target-"));
  process.env["PI_CODING_AGENT_DIR"] = root;

  const { readTarget, writeTarget, clearTarget } = await import("../../src/cdp/target-store");
  const { targetFilePath } = await import("../../src/profile/paths");
  const file = targetFilePath();

  try {
    // T1: nothing stored yet.
    check((await readTarget()) === null, "T1: a missing file reads as nothing stored");

    // T2: round-trip.
    {
      const w = await writeTarget("local");
      check(w.success, "T2: writing a target succeeds");
      check((await readTarget()) === "local", "T2: it reads back verbatim");
    }

    // T3: overwrite, not append — a switch must fully replace the last choice.
    {
      await writeTarget("10.4.5.6:9299");
      check((await readTarget()) === "10.4.5.6:9299", "T3: a second write replaces the first");
    }

    // T4: clearing restores "nothing stored", which resolution reads as the
    // built-in default rather than as local.
    {
      const c = await clearTarget();
      check(c.success, "T4: clearing succeeds");
      check((await readTarget()) === null, "T4: a cleared target reads as nothing stored");
    }

    // T5: whitespace is normalised on read, so a hand-edited file with a
    // trailing newline inside the JSON string still resolves.
    {
      writeFileSync(file, JSON.stringify({ version: 1, target: "  local  ", savedAt: "" }));
      check((await readTarget()) === "local", "T5: surrounding whitespace is trimmed");
    }

    // T6: damage must degrade to null, never throw. Each of these is a real
    // failure mode: truncated write, hand-edit, or a file from a future version.
    {
      const damaged: ReadonlyArray<readonly [string, string]> = [
        ["not json at all", "T6: unparseable JSON"],
        ['{"version":1,"target":', "T6: truncated JSON"],
        ['{"version":2,"target":"local"}', "T6: a newer file version"],
        ['{"version":1,"target":42}', "T6: a non-string target"],
        ['{"version":1,"target":null}', "T6: an explicitly null target"],
        ['{"version":1}', "T6: a missing target field"],
        ["[]", "T6: a JSON array instead of an object"],
        ['{"version":1,"target":""}', "T6: an empty target string"],
      ];
      for (const [contents, label] of damaged) {
        writeFileSync(file, contents);
        let threw = false;
        let value: string | null = "unset";
        try {
          value = await readTarget();
        } catch {
          threw = true;
        }
        check(!threw && value === null, `${label} degrades to nothing stored`);
      }
    }

    // T7: recovery — a damaged file must not poison later writes.
    {
      writeFileSync(file, "garbage");
      const w = await writeTarget("local");
      check(w.success, "T7: writing over a damaged file succeeds");
      check((await readTarget()) === "local", "T7: the store recovers");
    }
  } finally {
    rmSync(root, { recursive: true, force: true });
  }

  console.log(`\n${passed} passed, ${failed} failed`);
  if (failed > 0) process.exit(1);
}

void main();