import { describe, expect, it } from "vitest";
import * as schema from "~/database/schema";
import { SIMULATOR_MANIFEST } from "../manifest";
import { SIMULATOR_TYPES } from "../registry";
import { getSimulatorInputPolicy } from "../input-policy";
import { assertRegistrySchemaDriftFree } from "~/models/simulator";

describe("simulator manifest", () => {
  it("has a manifest profile for every registered simulator type", () => {
    expect(Object.keys(SIMULATOR_MANIFEST).toSorted()).toEqual([...SIMULATOR_TYPES].toSorted());
  });

  it("keeps the registry and database enum in sync", () => {
    expect([...schema.simulatorTypeEnum.enumValues].toSorted()).toEqual([...SIMULATOR_TYPES].toSorted());
  });

  it("assertRegistrySchemaDriftFree does not throw when registry and schema are aligned", async () => {
    await expect(assertRegistrySchemaDriftFree()).resolves.toBeUndefined();
  });

  it("documents admin setup requirements for all profiles", () => {
    for (const simulatorType of SIMULATOR_TYPES) {
      const profile = SIMULATOR_MANIFEST[simulatorType];
      expect(profile.displayName).toBeTruthy();
      expect(profile.description).toBeTruthy();
      expect(Array.isArray(profile.requiredInputs)).toBe(true);
      expect(Array.isArray(profile.optionalInputs)).toBe(true);
      expect(profile.setupSections.length).toBeGreaterThan(0);
      expect(profile.defaultConfig).toBeTypeOf("object");
    }
  });

  // updateProbabilitiesAfterResult sends a season down the re-run path or the ICM path purely
  // on this flag, and getting it wrong is silent in both directions: set it on a simulator
  // that re-plays decided games and eliminated teams come back to life; leave it off a
  // bracket-aware one and ICM keeps reporting placement floors as worth less than the points
  // already awarded. Pinning the set makes a new simulator an explicit decision rather than a
  // default. To add one, confirm it reads playoff_matches AND honors isComplete/winnerId.
  it("pins which simulators are bracket-aware", () => {
    const bracketAware = SIMULATOR_TYPES.filter((t) => SIMULATOR_MANIFEST[t].bracketAware);
    expect(bracketAware.toSorted()).toEqual(
      [
        "afl_bracket",
        "college_hockey_bracket",
        "cs2_major_qualifying_points",
        "darts_bracket",
        "llws_bracket",
        "nba_bracket",
        "ncaam_bracket",
        "ncaaw_bracket",
        "nhl_bracket",
        "nll_bracket",
        "snooker_bracket",
        "ucl_bracket",
        "world_cup",
      ].toSorted()
    );
  });

  it("only derives inputs from declared optional inputs", () => {
    for (const simulatorType of SIMULATOR_TYPES) {
      const profile = SIMULATOR_MANIFEST[simulatorType];
      for (const alternatives of Object.values(profile.derivableInputs ?? {})) {
        for (const alternative of alternatives ?? []) {
          expect(profile.optionalInputs).toContain(alternative);
        }
      }
    }
  });

  it("exposes the per-profile futures blend weight through the input policy", () => {
    expect(getSimulatorInputPolicy(SIMULATOR_MANIFEST.ncaa_football_bracket.defaultConfig).oddsWeight).toBe(0.4);
    expect(getSimulatorInputPolicy(SIMULATOR_MANIFEST.world_cup.defaultConfig).oddsWeight).toBe(0.3);
    expect(getSimulatorInputPolicy(SIMULATOR_MANIFEST.ucl_bracket.defaultConfig).oddsWeight).toBe(0.3);
    // College hockey blends odds internally, so the central blend is disabled.
    expect(getSimulatorInputPolicy(SIMULATOR_MANIFEST.college_hockey_bracket.defaultConfig).oddsWeight).toBe(0);
    // Every profile resolves to the default base-Elo priority unless overridden.
    expect(getSimulatorInputPolicy(SIMULATOR_MANIFEST.nba_bracket.defaultConfig).baseEloPriority)
      .toEqual(["sourceElo", "projectedWins", "projectedTablePoints"]);
  });

  it("keeps EPL projection and match parity as separate config knobs", () => {
    expect(SIMULATOR_MANIFEST.epl_standings.defaultConfig).toMatchObject({
      parityFactor: 400,
      matchParityFactor: 400,
      averageOpponentElo: 1500,
      baseDrawRate: 0.26,
      drawDecay: 0.002,
    });
  });
});