import { readFileSync } from "node:fs";
import { strictEqual, ok, throws } from "node:assert";
import { describe, it } from "node:test";
import { parseManifest } from "../src/bundle.js";
import { parseNodeSection as bundleParseNodeSection } from "../src/bundle.js";
import { validateManifest, selectExport } from "../src/manifest.js";
import { verifyNodeHashes, parseNodeSection as parseNodes } from "../src/merkle.js";
import { buildTreeFromNodeMap } from "../src/cli.js";

const fixtureDir = "../../test/fixtures";

describe("run bundle — id.arboricx", () => {
  const bundle = readFileSync(`${fixtureDir}/id.arboricx`);
  const manifest = parseManifest(bundle);
  const nodeSectionData = bundleParseNodeSection(bundle);
  const { nodeMap } = parseNodes(nodeSectionData);

  it("manifest validates", () => {
    validateManifest(manifest);
  });

  it("node hashes verify", () => {
    const { verified } = verifyNodeHashes(nodeMap);
    ok(verified);
  });

  it("export 'root' is selectable", () => {
    const exp = selectExport(manifest, "root");
    strictEqual(exp.name, "root");
  });

  it("tree reconstructs as a Fork", () => {
    const exp = selectExport(manifest, "root");
    const tree = buildTreeFromNodeMap(nodeMap, exp.root);
    ok(Array.isArray(tree));
    ok(tree.length >= 2, "tree should be a Fork (length >= 2)");
  });
});

describe("run bundle — true.arboricx", () => {
  const bundle = readFileSync(`${fixtureDir}/true.arboricx`);
  const manifest = parseManifest(bundle);
  const nodeSectionData = bundleParseNodeSection(bundle);
  const { nodeMap } = parseNodes(nodeSectionData);

  it("manifest validates", () => {
    validateManifest(manifest);
  });

  it("export 'root' is selectable", () => {
    const exp = selectExport(manifest, "root");
    strictEqual(exp.name, "root");
  });

  it("tree reconstructs as Stem Leaf", () => {
    const exp = selectExport(manifest, "root");
    const tree = buildTreeFromNodeMap(nodeMap, exp.root);
    ok(Array.isArray(tree));
    strictEqual(tree.length, 1, "true should be a Stem (single child)");
    strictEqual(tree[0].length, 0, "child should be Leaf");
  });
});

describe("run bundle — false.arboricx", () => {
  const bundle = readFileSync(`${fixtureDir}/false.arboricx`);
  const manifest = parseManifest(bundle);
  const nodeSectionData = bundleParseNodeSection(bundle);
  const { nodeMap } = parseNodes(nodeSectionData);

  it("manifest validates", () => {
    validateManifest(manifest);
  });

  it("export 'root' is selectable", () => {
    const exp = selectExport(manifest, "root");
    strictEqual(exp.name, "root");
  });

  it("tree reconstructs as Leaf", () => {
    const exp = selectExport(manifest, "root");
    const tree = buildTreeFromNodeMap(nodeMap, exp.root);
    strictEqual(tree.length, 0, "false should be Leaf (empty array)");
  });
});

describe("run bundle — notQ.arboricx", () => {
  const bundle = readFileSync(`${fixtureDir}/notQ.arboricx`);
  const manifest = parseManifest(bundle);
  const nodeSectionData = bundleParseNodeSection(bundle);
  const { nodeMap } = parseNodes(nodeSectionData);

  it("manifest validates", () => {
    validateManifest(manifest);
  });

  it("node hashes verify", () => {
    const { verified } = verifyNodeHashes(nodeMap);
    ok(verified);
  });
});

describe("run bundle — missing export", () => {
  const bundle = readFileSync(`${fixtureDir}/id.arboricx`);
  const manifest = parseManifest(bundle);

  it("nonexistent export fails clearly", () => {
    throws(() => selectExport(manifest, "nonexistent"), /not found/);
  });
});

describe("run bundle — auto-select", () => {
  // true.arboricx has only one export, should auto-select
  const bundle = readFileSync(`${fixtureDir}/true.arboricx`);
  const manifest = parseManifest(bundle);

  it("single export auto-selects", () => {
    const exp = selectExport(manifest, undefined);
    ok(exp, "should auto-select the only export");
  });
});