import { describe, expect, it, vi } from "vitest";

import {
  getToolcraftDiscreteCombinationCardinality,
  getToolcraftDiscreteCombinationPlanningError,
  searchToolcraftDiscreteCombinations,
  toolcraftDiscreteCombinationBudget,
  toolcraftDiscreteDimensionBudget,
} from "./performance-fixture-discrete-search";

describe("Toolcraft discrete combination search", () => {
  it("accepts cardinality under and exactly at the path budget", () => {
    expect(getToolcraftDiscreteCombinationCardinality([8, 8])).toEqual({
      cardinality: 64,
      status: "within-budget",
    });
    expect(
      getToolcraftDiscreteCombinationCardinality([64, 64]),
    ).toEqual({
      cardinality: toolcraftDiscreteCombinationBudget,
      status: "within-budget",
    });
  });

  it("distinguishes immediately over-budget cardinality from overflow", () => {
    expect(
      getToolcraftDiscreteCombinationCardinality([
        toolcraftDiscreteCombinationBudget + 1,
      ]),
    ).toMatchObject({
      budget: toolcraftDiscreteCombinationBudget,
      cardinality: toolcraftDiscreteCombinationBudget + 1,
      status: "over-budget",
    });
    expect(
      getToolcraftDiscreteCombinationCardinality([
        Number.MAX_SAFE_INTEGER,
        2,
      ]),
    ).toMatchObject({ status: "overflow" });
    expect(
      getToolcraftDiscreteCombinationPlanningError("path-over", [4097]),
    ).toMatch(/exceeding the deterministic path-level budget 4096/u);
    expect(
      getToolcraftDiscreteCombinationPlanningError("path-overflow", [
        Number.MAX_SAFE_INTEGER,
        2,
      ]),
    ).toMatch(/exceeds safe integer capacity and cannot be planned/u);
  });

  it("visits combinations lazily in deterministic domain order", () => {
    const visits: number[][] = [];

    const result = searchToolcraftDiscreteCombinations(
      [[2, 1], [20, 10]],
      (combination) => {
        visits.push([...combination]);
        return combination[0] === 1 && combination[1] === 20;
      },
    );

    expect(result).toEqual({ match: [1, 20], visited: 3 });
    expect(visits).toEqual([[2, 20], [2, 10], [1, 20]]);
  });

  it("stops immediately after an early match", () => {
    const visitor = vi.fn(() => true);

    expect(
      searchToolcraftDiscreteCombinations(
        [[1, 2, 3], [10, 20, 30]],
        visitor,
      ),
    ).toEqual({ match: [1, 10], visited: 1 });
    expect(visitor).toHaveBeenCalledTimes(1);
  });

  it("accepts the exact dimension budget and rejects one dimension beyond it", () => {
    expect(
      getToolcraftDiscreteCombinationPlanningError(
        "path-at-dimension-limit",
        Array.from({ length: toolcraftDiscreteDimensionBudget }, () => 1),
      ),
    ).toBeUndefined();
    expect(
      getToolcraftDiscreteCombinationPlanningError(
        "path-over-dimension-limit",
        Array.from({ length: toolcraftDiscreteDimensionBudget + 1 }, () => 1),
      ),
    ).toMatch(/dimensions, exceeding the deterministic path-level dimension budget/u);
  });

  it("rejects ten thousand singleton domains without recursive stack failure", () => {
    expect(() =>
      getToolcraftDiscreteCombinationPlanningError(
        "path-ten-thousand-singletons",
        Array.from({ length: 10_000 }, () => 1),
      ),
    ).not.toThrow(RangeError);
    expect(
      getToolcraftDiscreteCombinationPlanningError(
        "path-ten-thousand-singletons",
        Array.from({ length: 10_000 }, () => 1),
      ),
    ).toMatch(/10_000|10000/u);
  });

  it("iterates ten thousand singleton domains without a recursive stack", () => {
    const domains = Array.from({ length: 10_000 }, (_, index) => [index]);

    const result = searchToolcraftDiscreteCombinations(domains, () => true);

    expect(result.visited).toBe(1);
    expect(result.match).toHaveLength(10_000);
    expect(result.match?.[0]).toBe(0);
    expect(result.match?.[9_999]).toBe(9_999);
  });
});