brackt/app/lib/bracket-templates.ts

/**
 * Bracket Template System
 *
 * Defines pre-configured tournament bracket structures for various sports.
 * Templates specify rounds, match counts, and which rounds contribute to fantasy scoring.
 */

export interface BracketRound {
  /** Display name for this round (e.g., "First Four", "Elite Eight") */
  name: string;
  /** Number of matches in this round */
  matchCount: number;
  /** Name of the round that winners advance to (null for championship) */
  feedsInto: string | null;
  /** Whether this round affects fantasy points (false = 0 points per Q20) */
  isScoring: boolean;
  /**
   * Name of the round that *losers* advance to (e.g., "Third Place Game" for SF losers).
   * When set, the loser of each match in this round is placed into the target round.
   */
  loserFeedsInto?: string | null;
  /**
   * Floor position banked by the WINNER of a *non-scoring* round.
   *
   * Omit for the default behavior: winners entering the first scoring round bank a
   * T5–T8 floor (position 5), everyone else banks nothing. Set an explicit number when
   * that default is wrong — in a double-elimination losers bracket a win can guarantee
   * a worse finish than 5th (llws_20 "Elimination Round 3" → 7). Set null to bank no
   * floor even though the next round scores.
   *
   * Has no effect on scoring rounds, which use RoundScoringConfig.winnerFloor instead.
   */
  nonScoringWinnerFloor?: number | null;
}

export interface GroupStageConfig {
  /** Number of groups */
  groupCount: number;
  /** Teams per group */
  teamsPerGroup: number;
  /** Group labels (e.g., ["A", "B", ..., "L"]) */
  groupLabels: string[];
}

/**
 * A play-in game within a bracket region (e.g., NCAA First Four).
 * Two teams compete; the winner fills a specific seed slot in the main bracket.
 */
export interface BracketPlayIn {
  /** Which seed slot the winner fills (e.g., 11 or 16) */
  seedSlot: number;
  /** Number of teams in this play-in game (always 2) */
  teams: 2;
}

/**
 * A named region within a bracket (e.g., NCAA "East", "South").
 * Each region contributes exactly 16 teams to the Round of 64.
 */
export interface BracketRegion {
  /** Display name (e.g., "East", "South") */
  name: string;
  /**
   * Seed numbers that enter the region directly (no play-in).
   * Must be ascending and contain every seed 1–16 except those covered by playIns.
   * Length = 16 - playIns.length.
   */
  directSeeds: number[];
  /**
   * Play-in games for this region. Order here determines the order their teams
   * appear in the participant array (after all direct-seed teams across all regions).
   */
  playIns: BracketPlayIn[];
}

/**
 * Defines a named conference or sub-bracket group within a bracket.
 * Used to split matches into East/West (NBA) or regional groups (NCAA) for display.
 */
export interface ConferenceGroup {
  /** Display name, e.g. "Eastern Conference" */
  name: string;
  /**
   * Maps round name → the match numbers (1-based) that belong to this conference.
   * Rounds not listed here are either shared (Finals) or not applicable.
   */
  roundMatchNumbers: Record<string, number[]>;
}

/**
 * A named tab/section within a bracket display.
 * Either shows a simple list of rounds, or a set of conference/regional sub-brackets.
 */
export interface BracketPhase {
  /** Tab label */
  name: string;
  /** Simple ordered list of round names to show in this tab */
  rounds?: string[];
  /** Regional/conference sub-groups to show stacked in this tab */
  groups?: ConferenceGroup[];
  /** Rounds rendered after groups (e.g. Final Four, Championship) */
  sharedRounds?: string[];
  /** Custom rendering layout for special phases */
  layout?: "play-in";
}

export interface BracketTemplate {
  /** Unique identifier for this template */
  id: string;
  /** Human-readable name */
  name: string;
  /** Total number of teams in the bracket */
  totalTeams: number;
  /** Ordered list of rounds from earliest to championship */
  rounds: BracketRound[];
  /** Round name where fantasy scoring begins */
  scoringStartsAtRound: string;
  /** Optional group stage configuration (e.g., FIFA World Cup) */
  groupStage?: GroupStageConfig;
  /** Number of teams advancing to knockout stage (when groupStage is defined) */
  knockoutTeams?: number;
  /**
   * Optional named region config. When present, the participant array for bracket
   * generation is structured as: all direct seeds region-by-region in order, then
   * all play-in teams grouped by region (and play-in order within each region).
   */
  regions?: BracketRegion[];
  /**
   * Optional human-readable labels for each participant slot (0-indexed).
   * When provided, the admin bracket UI shows these labels instead of "Seed N".
   * Length must equal totalTeams.
   */
  participantLabels?: string[];
  /**
   * Optional conference/group split for brackets with parallel sub-brackets (NBA).
   * When present, the UI renders each group as a separate sub-bracket.
   * Rounds not listed in any group's roundMatchNumbers are treated as shared (e.g., Finals).
   */
  conferenceGroups?: ConferenceGroup[];
  /**
   * Optional tabbed phase display (NCAA).
   * When present, the UI renders a tab switcher with each phase as a section.
   */
  phases?: BracketPhase[];
}

/** All seed numbers in a standard 16-team regional bracket (1–16) */
export const ALL_16_SEEDS: number[] = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];

// Standard seeding order for a 16-team regional bracket
// Each entry is [higherSeed, lowerSeed] (lower number = better seed)
export const STANDARD_BRACKET_SEEDING: [number, number][] = [
  [1, 16], [8, 9], [5, 12], [4, 13], [6, 11], [3, 14], [7, 10], [2, 15],
];

/**
 * Returns the 0-indexed position within the standard 8-match bracket order
 * for a given seed slot. Used to compute which Round of 64 match a play-in
 * winner advances to.
 *
 * Standard order: 1v16, 8v9, 5v12, 4v13, 6v11, 3v14, 7v10, 2v15
 */
export function matchIndexForSeedSlot(seedSlot: number): number {
  for (let i = 0; i < STANDARD_BRACKET_SEEDING.length; i++) {
    if (STANDARD_BRACKET_SEEDING[i].includes(seedSlot)) return i;
  }
  throw new Error(`Seed slot ${seedSlot} not found in standard bracket seeding`);
}

export interface NCAA68SlotMap {
  /** Start index in participantIds for each region's direct seeds */
  directOffsets: number[];
  /** Ordered list of all play-ins, with participant index info and region context */
  playInOffsets: Array<{
    regionIndex: number;
    playInIndex: number;
    /** Index of the first team in this play-in within participantIds */
    startIndex: number;
    seedSlot: number;
  }>;
  totalDirect: number;
  totalPlayIn: number;
}

/**
 * Computes the participant array slot mapping for an NCAA-style bracket with regions.
 *
 * Participant array layout:
 *   [region 0 direct seeds] [region 1 direct seeds] ... [region N direct seeds]
 *   [region 0 play-in 0 team A, team B] [region 0 play-in 1 team A, team B] ...
 *   [region 1 play-in 0 team A, team B] ...
 *
 * This layout is shared between the server (bracket generation) and the client
 * (form rendering) so both sides agree on which participant{i} maps where.
 */
export function buildNCAA68SlotMap(regions: BracketRegion[]): NCAA68SlotMap {
  let cursor = 0;
  const directOffsets: number[] = [];

  for (const region of regions) {
    directOffsets.push(cursor);
    cursor += region.directSeeds.length;
  }

  const totalDirect = cursor;
  const playInOffsets: NCAA68SlotMap["playInOffsets"] = [];

  for (let r = 0; r < regions.length; r++) {
    for (let p = 0; p < regions[r].playIns.length; p++) {
      playInOffsets.push({
        regionIndex: r,
        playInIndex: p,
        startIndex: cursor,
        seedSlot: regions[r].playIns[p].seedSlot,
      });
      cursor += 2;
    }
  }

  const totalPlayIn = cursor - totalDirect;

  return { directOffsets, playInOffsets, totalDirect, totalPlayIn };
}

/**
 * Simple 4-team bracket
 * Semifinals → Finals
 * All rounds score fantasy points
 */
export const SIMPLE_4: BracketTemplate = {
  id: "simple_4",
  name: "Simple 4-Team Bracket",
  totalTeams: 4,
  scoringStartsAtRound: "Semifinals",
  rounds: [
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "Finals",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * Simple 8-team bracket
 * Quarterfinals → Semifinals → Finals
 * All rounds score fantasy points
 */
export const SIMPLE_8: BracketTemplate = {
  id: "simple_8",
  name: "Simple 8-Team Bracket",
  totalTeams: 8,
  scoringStartsAtRound: "Quarterfinals",
  rounds: [
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semifinals",
      isScoring: true, // Losers share 5th-8th
    },
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "Finals",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * Simple 16-team bracket
 * Round of 16 → Quarterfinals → Semifinals → Finals
 * Only Quarterfinals and beyond score points (top 8)
 */
export const SIMPLE_16: BracketTemplate = {
  id: "simple_16",
  name: "Simple 16-Team Bracket",
  totalTeams: 16,
  scoringStartsAtRound: "Quarterfinals",
  rounds: [
    {
      name: "Round of 16",
      matchCount: 8,
      feedsInto: "Quarterfinals",
      isScoring: false, // Early elimination = 0 points
    },
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semifinals",
      isScoring: true, // Losers share 5th-8th
    },
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "Finals",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * Simple 32-team bracket
 * Round of 32 → Round of 16 → Quarterfinals → Semifinals → Finals
 * Only Quarterfinals and beyond score points (top 8)
 */
export const SIMPLE_32: BracketTemplate = {
  id: "simple_32",
  name: "Simple 32-Team Bracket",
  totalTeams: 32,
  scoringStartsAtRound: "Quarterfinals",
  rounds: [
    {
      name: "Round of 32",
      matchCount: 16,
      feedsInto: "Round of 16",
      isScoring: false, // Early elimination = 0 points
    },
    {
      name: "Round of 16",
      matchCount: 8,
      feedsInto: "Quarterfinals",
      isScoring: false, // Early elimination = 0 points
    },
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semifinals",
      isScoring: true, // Losers share 5th-8th
    },
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "Finals",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * NCAA Men's College Hockey Tournament (16 teams)
 * Regional Semifinals → Regional Finals → Frozen Four Semifinals → National Championship
 * Only Regional Finals and beyond score points (top 8).
 */
export const COLLEGE_HOCKEY_16: BracketTemplate = {
  id: "college_hockey_16",
  name: "NCAA Men's Hockey Tournament (16 teams)",
  totalTeams: 16,
  scoringStartsAtRound: "Regional Finals",
  rounds: [
    {
      name: "Regional Semifinals",
      matchCount: 8,
      feedsInto: "Regional Finals",
      isScoring: false,
    },
    {
      name: "Regional Finals",
      matchCount: 4,
      feedsInto: "Frozen Four Semifinals",
      isScoring: true,
    },
    {
      name: "Frozen Four Semifinals",
      matchCount: 2,
      feedsInto: "National Championship",
      isScoring: true,
    },
    {
      name: "National Championship",
      matchCount: 1,
      feedsInto: null,
      isScoring: true,
    },
  ],
};

/**
 * PDC World Darts Championship (128 players)
 * R1 (128) → R2 (64) → R3 (32) → R4 (16) → Quarterfinals → Semifinals → Final
 * Only Quarterfinals and beyond score points.
 *
 * Match formats:
 *   R1:  best-of-3 sets (first to 2)
 *   R2:  best-of-5 sets (first to 3)
 *   R3:  best-of-5 sets (first to 3)
 *   R4:  best-of-7 sets (first to 4)
 *   QF:  best-of-7 sets (first to 4)
 *   SF:  best-of-11 sets (first to 6)
 *   Final: best-of-13 sets (first to 7)
 *
 * Seeding: top 32 seeds placed in fixed positions; remaining 96 randomly drawn.
 */
export const DARTS_128: BracketTemplate = {
  id: "darts_128",
  name: "PDC World Darts Championship (128 Players)",
  totalTeams: 128,
  scoringStartsAtRound: "Quarterfinals",
  rounds: [
    {
      name: "Round 1",
      matchCount: 64,
      feedsInto: "Round 2",
      isScoring: false,
    },
    {
      name: "Round 2",
      matchCount: 32,
      feedsInto: "Round 3",
      isScoring: false,
    },
    {
      name: "Round 3",
      matchCount: 16,
      feedsInto: "Round 4",
      isScoring: false,
    },
    {
      name: "Round 4",
      matchCount: 8,
      feedsInto: "Quarterfinals",
      isScoring: false,
    },
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semi-Finals",
      isScoring: true, // QF losers share 5th–8th
    },
    {
      name: "Semi-Finals",
      matchCount: 2,
      feedsInto: "Final",
      isScoring: true, // SF losers share 3rd–4th
    },
    {
      name: "Final",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * Tennis Grand Slam (128-player single-elimination draw)
 * R128 → R64 → R32 → Round of 16 → Quarterfinals → Semifinals → Final
 *
 * Qualifying-points sport: QP is derived from how far each player advances
 * (see TEMPLATE_ROUND_CONFIG["tennis_128"] in scoring-calculator.ts). Scoring
 * begins at the Round of 16 — R16 losers share placements 9–16; earlier rounds
 * award nothing. Seeding: top 32 fixed, remaining 96 randomly drawn.
 */
export const TENNIS_128: BracketTemplate = {
  id: "tennis_128",
  name: "Tennis Grand Slam (128 Players)",
  totalTeams: 128,
  scoringStartsAtRound: "Round of 16",
  rounds: [
    { name: "Round of 128", matchCount: 64, feedsInto: "Round of 64", isScoring: false },
    { name: "Round of 64", matchCount: 32, feedsInto: "Round of 32", isScoring: false },
    { name: "Round of 32", matchCount: 16, feedsInto: "Round of 16", isScoring: false },
    { name: "Round of 16", matchCount: 8, feedsInto: "Quarterfinals", isScoring: true }, // losers share 9th–16th
    { name: "Quarterfinals", matchCount: 4, feedsInto: "Semifinals", isScoring: true }, // losers share 5th–8th
    { name: "Semifinals", matchCount: 2, feedsInto: "Final", isScoring: true }, // losers share 3rd–4th
    { name: "Final", matchCount: 1, feedsInto: null, isScoring: true }, // winner 1st, loser 2nd
  ],
};

/**
 * NCAA March Madness (68 teams)
 * First Four (play-in) → Round of 64 → Round of 32 → Sweet Sixteen → Elite Eight → Final Four → Championship
 * Only Elite Eight and beyond score points per Q18
 *
 * Region config (year-specific — update each March when the First Four matchups are announced):
 *   East    — 16 direct seeds, no play-ins
 *   South   — 15 direct seeds, 16-seed play-in
 *   West    — 15 direct seeds, 11-seed play-in
 *   Midwest — 14 direct seeds, 11-seed play-in + 16-seed play-in
 *
 * Participant array layout (68 slots):
 *   [0–15]   East seeds 1–16
 *   [16–30]  South seeds 1–15
 *   [31–45]  West seeds 1–10, 12–16
 *   [46–59]  Midwest seeds 1–10, 12–15
 *   [60–61]  South 16-seed play-in (2 teams)
 *   [62–63]  West 11-seed play-in (2 teams)
 *   [64–65]  Midwest 11-seed play-in (2 teams)
 *   [66–67]  Midwest 16-seed play-in (2 teams)
 */
export const NCAA_68: BracketTemplate = {
  id: "ncaa_68",
  name: "NCAA March Madness (68 teams)",
  totalTeams: 68,
  scoringStartsAtRound: "Elite Eight",
  rounds: [
    {
      name: "First Four",
      matchCount: 4,
      feedsInto: "Round of 64",
      isScoring: false, // Play-in games don't score
    },
    {
      name: "Round of 64",
      matchCount: 32,
      feedsInto: "Round of 32",
      isScoring: false,
    },
    {
      name: "Round of 32",
      matchCount: 16,
      feedsInto: "Sweet Sixteen",
      isScoring: false,
    },
    {
      name: "Sweet Sixteen",
      matchCount: 8,
      feedsInto: "Elite Eight",
      isScoring: false,
    },
    {
      name: "Elite Eight",
      matchCount: 4,
      feedsInto: "Final Four",
      isScoring: true, // Losers share 5th-8th
    },
    {
      name: "Final Four",
      matchCount: 2,
      feedsInto: "Championship",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Championship",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
  regions: [
    {
      // East: all 16 seeds enter directly — no play-in games
      name: "East",
      directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
      playIns: [],
    },
    {
      // South: seeds 1–15 direct; 16-seed determined by First Four play-in
      name: "South",
      directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
      playIns: [{ seedSlot: 16, teams: 2 }],
    },
    {
      // West: seeds 1–10 and 12–16 direct; 11-seed determined by First Four play-in
      name: "West",
      directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16],
      playIns: [{ seedSlot: 11, teams: 2 }],
    },
    {
      // Midwest: seeds 1–10 and 12–15 direct; both 11-seed and 16-seed via play-ins
      name: "Midwest",
      directSeeds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15],
      playIns: [
        { seedSlot: 11, teams: 2 },
        { seedSlot: 16, teams: 2 },
      ],
    },
  ],
  // Two-tab display: First Four → Bracket (4 regional sub-brackets + Final Four)
  phases: [
    {
      name: "First Four",
      rounds: ["First Four"],
    },
    {
      name: "Bracket",
      groups: [
        {
          name: "East Region",
          roundMatchNumbers: {
            "Round of 64":   [1, 2, 3, 4, 5, 6, 7, 8],
            "Round of 32":   [1, 2, 3, 4],
            "Sweet Sixteen": [1, 2],
            "Elite Eight":   [1],
          },
        },
        {
          name: "South Region",
          roundMatchNumbers: {
            "Round of 64":   [9, 10, 11, 12, 13, 14, 15, 16],
            "Round of 32":   [5, 6, 7, 8],
            "Sweet Sixteen": [3, 4],
            "Elite Eight":   [2],
          },
        },
        {
          name: "West Region",
          roundMatchNumbers: {
            "Round of 64":   [17, 18, 19, 20, 21, 22, 23, 24],
            "Round of 32":   [9, 10, 11, 12],
            "Sweet Sixteen": [5, 6],
            "Elite Eight":   [3],
          },
        },
        {
          name: "Midwest Region",
          roundMatchNumbers: {
            "Round of 64":   [25, 26, 27, 28, 29, 30, 31, 32],
            "Round of 32":   [13, 14, 15, 16],
            "Sweet Sixteen": [7, 8],
            "Elite Eight":   [4],
          },
        },
      ],
      sharedRounds: ["Final Four", "Championship"],
    },
  ],
};

/**
 * NFL Playoffs (14 teams)
 * Wild Card → Divisional → Conference Championship → Super Bowl
 * Top 2 seeds get byes (skip Wild Card)
 * Scoring starts at Divisional (top 8)
 */
export const NFL_14: BracketTemplate = {
  id: "nfl_14",
  name: "NFL Playoffs (14 teams)",
  totalTeams: 14,
  scoringStartsAtRound: "Divisional",
  rounds: [
    {
      name: "Wild Card",
      matchCount: 6,
      feedsInto: "Divisional",
      isScoring: false, // 12 teams play, 2 have byes
    },
    {
      name: "Divisional",
      matchCount: 4,
      feedsInto: "Conference Championship",
      isScoring: true, // Quarterfinals - Losers share 5th-8th
    },
    {
      name: "Conference Championship",
      matchCount: 2,
      feedsInto: "Super Bowl",
      isScoring: true, // Semifinals - Losers share 3rd-4th
    },
    {
      name: "Super Bowl",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Finals - Winner 1st, Loser 2nd
    },
  ],
};

/**
 * AFL Finals (10 teams with Wildcard Round from 2026)
 * Complex bracket with double-chance system for top 6 teams
 *
 * Structure:
 * - Wildcard Round: 7v10, 8v9 (losers eliminated with 0 points)
 * - Week 1 Finals:
 *   - Qualifying Finals: 1v4, 2v3 (losers get second chance)
 *   - Elimination Finals: 5v8(wildcard winner), 6v7(wildcard winner) (losers share 7th-8th)
 * - Week 2: Semi-Finals (QF losers vs EF winners, losers share 5th-6th)
 * - Week 3: Preliminary Finals (QF winners vs SF winners, losers share 3rd-4th)
 * - Week 4: Grand Final (1st vs 2nd)
 *
 * Note: This is NOT a simple single-elimination tree - it has double-chance paths
 */
export const AFL_10: BracketTemplate = {
  id: "afl_10",
  name: "AFL Finals (10 teams with Wildcard)",
  totalTeams: 10,
  scoringStartsAtRound: "Elimination Finals",
  rounds: [
    {
      name: "Wildcard Round",
      matchCount: 2,
      feedsInto: "Elimination Finals",
      isScoring: false, // Losers get 0 points (9th-10th)
    },
    {
      name: "Qualifying Finals",
      matchCount: 2,
      feedsInto: "Preliminary Finals", // Winners get bye
      isScoring: false, // Losers get second chance (go to Semi-Finals)
    },
    {
      name: "Elimination Finals",
      matchCount: 2,
      feedsInto: "Semi-Finals",
      isScoring: true, // Losers share 7th-8th
    },
    {
      name: "Semi-Finals",
      matchCount: 2,
      feedsInto: "Preliminary Finals",
      isScoring: true, // Losers share 5th-6th
    },
    {
      name: "Preliminary Finals",
      matchCount: 2,
      feedsInto: "Grand Final",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "Grand Final",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
};

/**
 * FIFA World Cup 48-team tournament (2026+)
 * Group stage: 12 groups of 4 teams play round-robin
 * Knockout stage: 32 teams advance to single-elimination bracket
 *
 * Group-to-knockout advancement is fully manual.
 * Admin marks teams as eliminated from groups, then assigns 32 advancing
 * teams into knockout bracket slots.
 *
 * Only knockout stage awards fantasy points.
 * Teams eliminated in groups get finalPosition = 0.
 */
export const FIFA_48: BracketTemplate = {
  id: "fifa_48",
  name: "FIFA World Cup (48 teams)",
  totalTeams: 48,
  knockoutTeams: 32,
  scoringStartsAtRound: "Quarterfinals",
  groupStage: {
    groupCount: 12,
    teamsPerGroup: 4,
    groupLabels: ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"],
  },
  rounds: [
    {
      name: "Round of 32",
      matchCount: 16,
      feedsInto: "Round of 16",
      isScoring: false,
    },
    {
      name: "Round of 16",
      matchCount: 8,
      feedsInto: "Quarterfinals",
      isScoring: false,
    },
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semifinals",
      isScoring: true,
    },
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "Finals",
      isScoring: true,
      loserFeedsInto: "Third Place Game",
    },
    {
      name: "Third Place Game",
      matchCount: 1,
      feedsInto: null,
      isScoring: true,
    },
    {
      name: "Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true,
    },
  ],
};

/**
 * College Football Playoff (12 teams, 2024–present format)
 * First Round: 5v12, 6v11, 7v10, 8v9 (campus sites, no fantasy points)
 * Quarterfinals: Seeds 1–4 (bye) vs first-round winners (scoring starts here)
 * Semifinals: 4 → 2
 * National Championship: 1 game
 */
export const CFP_12: BracketTemplate = {
  id: "cfp_12",
  name: "College Football Playoff (12 teams)",
  totalTeams: 12,
  scoringStartsAtRound: "Quarterfinals",
  rounds: [
    {
      name: "First Round",
      matchCount: 4,
      feedsInto: "Quarterfinals",
      isScoring: false, // 8 seeds play, top 4 have byes
    },
    {
      name: "Quarterfinals",
      matchCount: 4,
      feedsInto: "Semifinals",
      isScoring: true, // Losers share 5th–8th
    },
    {
      name: "Semifinals",
      matchCount: 2,
      feedsInto: "National Championship",
      isScoring: true, // Losers share 3rd–4th
    },
    {
      name: "National Championship",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, loser 2nd
    },
  ],
};

/**
 * NBA Playoffs with Play-In Tournament (20 teams)
 *
 * Structure:
 *   Play-In Round 1 (4 games, not scoring):
 *     East: 7 vs 8 (winner = E7 seed), 9 vs 10 (winner advances; loser eliminated)
 *     West: 7 vs 8 (winner = W7 seed), 9 vs 10 (winner advances; loser eliminated)
 *   Play-In Round 2 (2 games, not scoring):
 *     East: loser of 7/8 vs winner of 9/10 → winner = E8 seed; loser eliminated
 *     West: loser of 7/8 vs winner of 9/10 → winner = W8 seed; loser eliminated
 *   First Round (8 series, not scoring):
 *     East: 1v8, 4v5, 2v7, 3v6
 *     West: 1v8, 4v5, 2v7, 3v6
 *   Conference Semifinals (4 series, scoring starts — 5th-8th for losers)
 *   Conference Finals (2 series, scoring)
 *   NBA Finals (1 series, scoring)
 *
 * Participant array layout (20 slots, indices 0-19):
 *   [0–9]   East seeds 1–10
 *   [10–19] West seeds 1–10
 *
 * Play-in loser paths (custom advancement logic):
 *   PIR1 M1 (E7v8): winner → First Round M3 p1; loser → PIR2 M1 p1
 *   PIR1 M2 (E9v10): winner → PIR2 M1 p2; loser eliminated
 *   PIR1 M3 (W7v8): winner → First Round M7 p1; loser → PIR2 M2 p1
 *   PIR1 M4 (W9v10): winner → PIR2 M2 p2; loser eliminated
 *   PIR2 M1: winner → First Round M1 p2; loser eliminated
 *   PIR2 M2: winner → First Round M5 p2; loser eliminated
 *
 * First Round bracket order (enables correct Conference Semis matchups via standard ceil logic):
 *   M1: E1 vs E8 (play-in winner) → CS M1 p1
 *   M2: E4 vs E5                  → CS M1 p2
 *   M3: E2 vs E7 (play-in winner) → CS M2 p1
 *   M4: E3 vs E6                  → CS M2 p2
 *   M5: W1 vs W8 (play-in winner) → CS M3 p1
 *   M6: W4 vs W5                  → CS M3 p2
 *   M7: W2 vs W7 (play-in winner) → CS M4 p1
 *   M8: W3 vs W6                  → CS M4 p2
 */
export const NBA_20: BracketTemplate = {
  id: "nba_20",
  name: "NBA Playoffs with Play-In (20 teams)",
  totalTeams: 20,
  scoringStartsAtRound: "Conference Semifinals",
  rounds: [
    {
      name: "Play-In Round 1",
      matchCount: 4,
      feedsInto: "Play-In Round 2",
      isScoring: false, // Play-in games don't score
    },
    {
      name: "Play-In Round 2",
      matchCount: 2,
      feedsInto: "First Round",
      isScoring: false, // Still determining playoff field
    },
    {
      name: "First Round",
      matchCount: 8,
      feedsInto: "Conference Semifinals",
      isScoring: false, // First Round losers score 0 points
    },
    {
      name: "Conference Semifinals",
      matchCount: 4,
      feedsInto: "Conference Finals",
      isScoring: true, // Losers share 5th-8th
    },
    {
      name: "Conference Finals",
      matchCount: 2,
      feedsInto: "NBA Finals",
      isScoring: true, // Losers share 3rd-4th
    },
    {
      name: "NBA Finals",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // Winner 1st, Loser 2nd
    },
  ],
  participantLabels: [
    "East 1", "East 2", "East 3", "East 4", "East 5",
    "East 6", "East 7", "East 8", "East 9", "East 10",
    "West 1", "West 2", "West 3", "West 4", "West 5",
    "West 6", "West 7", "West 8", "West 9", "West 10",
  ],
  phases: [
    {
      name: "Play-In",
      rounds: ["Play-In Round 1", "Play-In Round 2"],
      layout: "play-in" as const,
    },
    {
      name: "Playoffs",
      rounds: ["First Round", "Conference Semifinals", "Conference Finals", "NBA Finals"],
    },
  ],
};

// ── LLWS 20 ───────────────────────────────────────────────────────────────────

/** Side-local match numbers → global match numbers, per round shape. */
const LLWS_OPENING_OFFSET = 4;   // Opening Round: US M1–4, Intl M5–8
const LLWS_PAIR_OFFSET = 2;      // 4-match rounds: US M1–2, Intl M3–4
const LLWS_SOLO_OFFSET = 1;      // 2-match rounds: US M1, Intl M2

/** Rounds with 4 matches (2 per side). Opening Round has 8; the rest have 2. */
export const LLWS_FOUR_MATCH_ROUNDS = new Set([
  "Winners Round 2",
  "Elimination Round 1",
  "Winners Semifinals",
  "Elimination Round 2",
  "Elimination Round 3",
]);

/**
 * Returns the global match number for a side-local match in an LLWS round.
 * side 0 = United States, side 1 = International.
 */
export function llwsMatchNumber(round: string, side: 0 | 1, localMatch: number): number {
  const offset =
    round === "Opening Round"
      ? LLWS_OPENING_OFFSET
      : LLWS_FOUR_MATCH_ROUNDS.has(round)
        ? LLWS_PAIR_OFFSET
        : LLWS_SOLO_OFFSET;
  return localMatch + side * offset;
}

/**
 * Inverse of llwsMatchNumber: global match number → { side, localMatch }.
 */
export function llwsSideAndLocal(
  round: string,
  matchNumber: number
): { side: 0 | 1; localMatch: number } {
  const offset =
    round === "Opening Round"
      ? LLWS_OPENING_OFFSET
      : LLWS_FOUR_MATCH_ROUNDS.has(round)
        ? LLWS_PAIR_OFFSET
        : LLWS_SOLO_OFFSET;
  const side: 0 | 1 = matchNumber > offset ? 1 : 0;
  return { side, localMatch: matchNumber - side * offset };
}

/**
 * Little League Baseball World Series (20 teams, 2025+ double-elimination format)
 *
 * Two independent 10-team double-elimination brackets — United States and
 * International — each producing a side champion, then a World Championship game and
 * a Consolation Third Place game between the two side runners-up.
 *
 * Rounds are shared across both sides: U.S. matches take the low match numbers and
 * International the high ones (see llwsMatchNumber). The phases/groups config splits
 * them back apart for display.
 *
 * A loss in the winners bracket is NOT an elimination — it drops the team into the
 * elimination bracket at a specific slot (see advanceLLWSWinner in models/playoff-match).
 * A loss in the elimination bracket is final.
 *
 * There is deliberately NO "if necessary" game: the winners-bracket champion is out if
 * it loses the Bracket Championship, dropping to the Consolation game rather than
 * forcing a rematch. This is the official LLWS modified double-elimination format.
 *
 * Placement tiers (only 8 teams score — the field is exactly 8 when Elim R4 begins):
 *   1st / 2nd  World Championship
 *   3rd / 4th  Consolation Third Place (real game, so positions are distinct)
 *   5th / 6th  Elimination Final losers
 *   7th / 8th  Elimination Round 4 losers
 *   0 pts      the 12 teams eliminated in Elimination Rounds 1–3
 *
 * Participant array layout (20 slots):
 *   [0–7]   U.S. Opening Round teams, two per game (M1..M4)
 *   [8, 9]  U.S. bye teams, entering Winners Round 2 M1 / M2 at participant1
 *   [10–17] International Opening Round teams, two per game (M5..M8)
 *   [18,19] International bye teams, entering Winners Round 2 M3 / M4 at participant1
 */
export const LLWS_20: BracketTemplate = {
  id: "llws_20",
  name: "Little League World Series (20 teams)",
  totalTeams: 20,
  scoringStartsAtRound: "Winners Final",
  // Ordered by the real schedule so non-phased views read chronologically.
  rounds: [
    {
      name: "Opening Round",
      matchCount: 8,
      feedsInto: "Winners Round 2",
      isScoring: false,
      loserFeedsInto: "Elimination Round 1",
      nonScoringWinnerFloor: null, // 16 teams still alive — nothing guaranteed
    },
    {
      name: "Winners Round 2",
      matchCount: 4,
      feedsInto: "Winners Semifinals",
      isScoring: false,
      loserFeedsInto: "Elimination Round 2",
      nonScoringWinnerFloor: null,
    },
    {
      name: "Elimination Round 1",
      matchCount: 4,
      feedsInto: "Elimination Round 2",
      isScoring: false, // losers finish 13th–16th
      nonScoringWinnerFloor: null,
    },
    {
      name: "Winners Semifinals",
      matchCount: 4,
      feedsInto: "Winners Final",
      isScoring: false,
      loserFeedsInto: "Elimination Round 3",
      // Reaching the Winners Final guarantees at worst 5th (lose it, then lose the
      // Elimination Final). Same value as the engine default, stated explicitly.
      nonScoringWinnerFloor: 5,
    },
    {
      name: "Elimination Round 2",
      matchCount: 4,
      feedsInto: "Elimination Round 3",
      isScoring: false, // losers finish 11th–12th
      nonScoringWinnerFloor: null,
    },
    {
      name: "Elimination Round 3",
      matchCount: 4,
      feedsInto: "Elimination Round 4",
      isScoring: false, // losers finish 9th–10th
      // Winners reach Elimination Round 4, where a loss is 7th — not 5th.
      nonScoringWinnerFloor: 7,
    },
    {
      name: "Winners Final",
      matchCount: 2,
      feedsInto: "Bracket Championship",
      isScoring: true, // loser drops to the Elimination Final (provisional 5th)
      loserFeedsInto: "Elimination Final",
    },
    {
      name: "Elimination Round 4",
      matchCount: 2,
      feedsInto: "Elimination Final",
      isScoring: true, // losers share 7th–8th
    },
    {
      name: "Elimination Final",
      matchCount: 2,
      feedsInto: "Bracket Championship",
      isScoring: true, // losers share 5th–6th
    },
    {
      name: "Bracket Championship",
      matchCount: 2,
      feedsInto: "World Championship",
      isScoring: true, // loser drops to the Consolation game (provisional 4th)
      loserFeedsInto: "Consolation Third Place",
    },
    {
      name: "Consolation Third Place",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // winner 3rd, loser 4th
    },
    {
      name: "World Championship",
      matchCount: 1,
      feedsInto: null,
      isScoring: true, // winner 1st, loser 2nd
    },
  ],
  // Region assignments rotate year to year (which region draws the bye changes), so
  // these are positional slot labels rather than region names.
  participantLabels: [
    "U.S. Opening 1 — Home", "U.S. Opening 1 — Away",
    "U.S. Opening 2 — Home", "U.S. Opening 2 — Away",
    "U.S. Opening 3 — Home", "U.S. Opening 3 — Away",
    "U.S. Opening 4 — Home", "U.S. Opening 4 — Away",
    "U.S. Bye — Winners R2 G1", "U.S. Bye — Winners R2 G2",
    "Intl Opening 1 — Home", "Intl Opening 1 — Away",
    "Intl Opening 2 — Home", "Intl Opening 2 — Away",
    "Intl Opening 3 — Home", "Intl Opening 3 — Away",
    "Intl Opening 4 — Home", "Intl Opening 4 — Away",
    "Intl Bye — Winners R2 G1", "Intl Bye — Winners R2 G2",
  ],
  phases: [
    {
      name: "United States",
      groups: [
        {
          name: "U.S. Winner's Bracket",
          roundMatchNumbers: {
            "Opening Round": [1, 2, 3, 4],
            "Winners Round 2": [1, 2],
            "Winners Semifinals": [1, 2],
            "Winners Final": [1],
          },
        },
        {
          name: "U.S. Elimination Bracket",
          roundMatchNumbers: {
            "Elimination Round 1": [1, 2],
            "Elimination Round 2": [1, 2],
            "Elimination Round 3": [1, 2],
            "Elimination Round 4": [1],
            "Elimination Final": [1],
          },
        },
        {
          name: "U.S. Championship",
          roundMatchNumbers: { "Bracket Championship": [1] },
        },
      ],
    },
    {
      name: "International",
      groups: [
        {
          name: "International Winner's Bracket",
          roundMatchNumbers: {
            "Opening Round": [5, 6, 7, 8],
            "Winners Round 2": [3, 4],
            "Winners Semifinals": [3, 4],
            "Winners Final": [2],
          },
        },
        {
          name: "International Elimination Bracket",
          roundMatchNumbers: {
            "Elimination Round 1": [3, 4],
            "Elimination Round 2": [3, 4],
            "Elimination Round 3": [3, 4],
            "Elimination Round 4": [2],
            "Elimination Final": [2],
          },
        },
        {
          name: "International Championship",
          roundMatchNumbers: { "Bracket Championship": [2] },
        },
      ],
    },
    {
      name: "Championship",
      rounds: ["Consolation Third Place", "World Championship"],
    },
  ],
};

/**
 * All available bracket templates
 */
export const BRACKET_TEMPLATES: Record<string, BracketTemplate> = {
  simple_4: SIMPLE_4,
  simple_8: SIMPLE_8,
  simple_16: SIMPLE_16,
  college_hockey_16: COLLEGE_HOCKEY_16,
  simple_32: SIMPLE_32,
  ncaa_68: NCAA_68,
  nfl_14: NFL_14,
  afl_10: AFL_10,
  fifa_48: FIFA_48,
  darts_128: DARTS_128,
  tennis_128: TENNIS_128,
  cfp_12: CFP_12,
  nba_20: NBA_20,
  llws_20: LLWS_20,
};

/**
 * Get a bracket template by ID
 */
export function getBracketTemplate(id: string): BracketTemplate | undefined {
  return BRACKET_TEMPLATES[id];
}

/**
 * Get all bracket templates as an array
 */
export function getAllBracketTemplates(): BracketTemplate[] {
  return Object.values(BRACKET_TEMPLATES);
}

/**
 * Returns round names in chronological order (earliest first) for the given matches.
 * When a template is provided its defined order is used; otherwise rounds are sorted
 * by descending match count (more matches = earlier round).
 */
export function getOrderedRoundsFromMatches(
  matches: Array<{ round: string }>,
  template?: BracketTemplate
): string[] {
  const roundsInMatches = new Set(matches.map((m) => m.round));

  if (template) {
    return template.rounds
      .map((r) => r.name)
      .filter((name) => roundsInMatches.has(name));
  }

  const roundMatchCounts = new Map<string, number>();
  for (const m of matches) {
    roundMatchCounts.set(m.round, (roundMatchCounts.get(m.round) || 0) + 1);
  }
  return Array.from(roundMatchCounts.keys()).toSorted(
    (a, b) => (roundMatchCounts.get(b) || 0) - (roundMatchCounts.get(a) || 0)
  );
}

/**
 * Helper to determine scoring round type based on match count in scoring rounds
 * Used for determining placement sharing (5-8th, 3-4th, 1-2nd)
 *
 * Special handling for AFL finals system which has specific placement rules
 */
export function getScoringRoundType(
  roundName: string,
  template: BracketTemplate
): "quarterfinals" | "semifinals" | "finals" | null {
  const round = template.rounds.find((r) => r.name === roundName);
  if (!round || !round.isScoring) return null;

  // Special handling for LLWS double elimination: match counts don't identify the
  // tier (Elimination Round 4 and the Elimination Final both have 2 matches), and
  // the Winners Final eliminates nobody.
  if (template.id === "llws_20") {
    if (roundName === "Elimination Round 4") return "quarterfinals"; // losers share 7-8th
    if (roundName === "Elimination Final") return "quarterfinals";   // losers share 5-6th
    if (roundName === "Bracket Championship") return "semifinals";   // losers play for 3-4th
    if (roundName === "Consolation Third Place") return "semifinals"; // finalizes 3rd/4th
    if (roundName === "World Championship") return "finals";         // 1st and 2nd
    return null; // Winners Final: loser drops to the elimination bracket, nobody is out
  }

  // Special handling for AFL finals
  if (template.id === "afl_10") {
    if (roundName === "Elimination Finals") return "quarterfinals"; // Losers share 7-8th
    if (roundName === "Semi-Finals") return "quarterfinals"; // Losers share 5-6th (custom mapping)
    if (roundName === "Preliminary Finals") return "semifinals"; // Losers share 3-4th
    if (roundName === "Grand Final") return "finals"; // 1st and 2nd
    return null;
  }

  // Standard logic for other templates
  // Determine type by match count in scoring round
  if (round.matchCount === 4) return "quarterfinals"; // 8 teams, losers share 5-8th
  if (round.matchCount === 2) return "semifinals"; // 4 teams, losers share 3-4th
  if (round.matchCount === 1) return "finals"; // 2 teams, 1st and 2nd
  return null;
}