import {
  createEngine,
  listVariants,
  getVariant,
  CLASSIC_VARIANT,
  SIX_BY_SIX_VARIANT,
  DIAGONAL_VARIANT,
  HYPER_VARIANT,
  WINDOKU_VARIANT,
  JIGSAW_VARIANT,
  KILLER_VARIANT,
  THERMO_VARIANT,
  KROPKI_VARIANT,
  SAMURAI_VARIANT,
} from "@reetesh/sudoku-engine";
 
type VariantId =
  | "classic"
  | "6x6"
  | "diagonal"
  | "hyper"
  | "jigsaw"
  | "windoku"
  | "killer"
  | "thermo"
  | "kropki"
  | "samurai";
 
createEngine({ variant: "classic" /* default */ });
listVariants(); // readonly SudokuVariant[]
getVariant("samurai"); // throws SudokuEngineError if unknown

const mini = createEngine({ variant: "6x6" });
 
import {
  defineVariant,
  composeHouses,
  CLASSIC_GRID,
  buildRowHouses,
  buildColumnHouses,
  buildIrregularRegionHouses,
  getVariant,
} from "@reetesh/sudoku-engine";
 
const custom = createEngine({
  definition: defineVariant({
    ...getVariant("jigsaw"),
    id: "my-jigsaw",
    houses: composeHouses(CLASSIC_GRID, [
      ...buildRowHouses(CLASSIC_GRID),
      ...buildColumnHouses(CLASSIC_GRID),
      ...buildIrregularRegionHouses(CLASSIC_GRID, myRegionMap),
    ]),
  }),
});

const engine = createEngine({ variant: "killer" });
const game = engine.generatePuzzle("easy")!;
const scoped = engine.withMeta(game.metaConstraints!);
scoped.solve(game.puzzle);

{
  difficulty: Difficulty;
  puzzle: Board;
  solution: Board;
  clueCount: number;
  metaConstraints?: readonly MetaConstraint[]; // killer / thermo / kropki
}

new BatchEngine({ seed?: number; variant?: VariantId });
engine.generateOne({ difficulty, seed? }): GeneratedPuzzle; // throws on failure
engine.generateBatch({ count, distribution? }): GeneratedPuzzle[];

type MetaConstraint =
  | CageSumConstraint
  | ThermometerConstraint
  | KropkiConstraint;
 
interface CageSumConstraint {
  id: string;
  kind: "cage-sum";
  cells: readonly CellRef[];
  sum: number;
  uniqueDigits: true;
}
 
interface ThermometerConstraint {
  id: string;
  kind: "thermometer";
  cells: readonly CellRef[]; // bulb → tip
}
 
interface KropkiConstraint {
  id: string;
  kind: "kropki";
  a: CellRef;
  b: CellRef;
  dot: "black" | "white"; // ratio 2 | consecutive
}
 
interface CellRef {
  row: number;
  column: number;
}

// Classic
generatePuzzle("medium");
 
// Diagonal
const x = createEngine({ variant: "diagonal" });
x.generatePuzzle("hard");
 
// Killer (meta required)
const killer = createEngine({ variant: "killer" });
const g = killer.generatePuzzle("easy")!;
killer.withMeta(g.metaConstraints!).solve(g.puzzle);
 
// Samurai
createEngine({ variant: "samurai" }).generatePuzzle("easy");
 
// Batch
new BatchEngine({ variant: "windoku", seed: 1 }).generateBatch({ count: 8 });