1024 lines
34 KiB
TypeScript
1024 lines
34 KiB
TypeScript
import { eq, and } from "drizzle-orm";
|
|
import { database } from "~/database/context";
|
|
import * as schema from "~/database/schema";
|
|
import type { BracketTemplate } from "~/lib/bracket-templates";
|
|
import { getBracketTemplate } from "~/lib/bracket-templates";
|
|
|
|
export type PlayoffMatch = typeof schema.playoffMatches.$inferSelect;
|
|
export type NewPlayoffMatch = typeof schema.playoffMatches.$inferInsert;
|
|
|
|
export async function createPlayoffMatch(
|
|
data: NewPlayoffMatch
|
|
): Promise<PlayoffMatch> {
|
|
const db = database();
|
|
const [match] = await db
|
|
.insert(schema.playoffMatches)
|
|
.values(data)
|
|
.returning();
|
|
return match;
|
|
}
|
|
|
|
export async function createManyPlayoffMatches(
|
|
data: NewPlayoffMatch[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const db = database();
|
|
return await db
|
|
.insert(schema.playoffMatches)
|
|
.values(data)
|
|
.returning();
|
|
}
|
|
|
|
export async function findPlayoffMatchById(
|
|
id: string
|
|
): Promise<PlayoffMatch | undefined> {
|
|
const db = database();
|
|
return await db.query.playoffMatches.findFirst({
|
|
where: eq(schema.playoffMatches.id, id),
|
|
with: {
|
|
scoringEvent: true,
|
|
participant1: true,
|
|
participant2: true,
|
|
winner: true,
|
|
loser: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
export async function findPlayoffMatchesByEventId(
|
|
eventId: string
|
|
): Promise<PlayoffMatch[]> {
|
|
const db = database();
|
|
return await db.query.playoffMatches.findMany({
|
|
where: eq(schema.playoffMatches.scoringEventId, eventId),
|
|
orderBy: (matches, { asc }) => [asc(matches.matchNumber)],
|
|
with: {
|
|
participant1: true,
|
|
participant2: true,
|
|
winner: true,
|
|
loser: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
export async function findPlayoffMatchesByEventIdAndRound(
|
|
eventId: string,
|
|
round: string
|
|
): Promise<PlayoffMatch[]> {
|
|
const db = database();
|
|
return await db.query.playoffMatches.findMany({
|
|
where: and(
|
|
eq(schema.playoffMatches.scoringEventId, eventId),
|
|
eq(schema.playoffMatches.round, round)
|
|
),
|
|
orderBy: (matches, { asc }) => [asc(matches.matchNumber)],
|
|
with: {
|
|
participant1: true,
|
|
participant2: true,
|
|
winner: true,
|
|
loser: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
export async function updatePlayoffMatch(
|
|
id: string,
|
|
data: Partial<NewPlayoffMatch>
|
|
): Promise<PlayoffMatch> {
|
|
const db = database();
|
|
const [match] = await db
|
|
.update(schema.playoffMatches)
|
|
.set({ ...data, updatedAt: new Date() })
|
|
.where(eq(schema.playoffMatches.id, id))
|
|
.returning();
|
|
return match;
|
|
}
|
|
|
|
export async function deletePlayoffMatch(id: string): Promise<void> {
|
|
const db = database();
|
|
await db.delete(schema.playoffMatches).where(eq(schema.playoffMatches.id, id));
|
|
}
|
|
|
|
export async function deletePlayoffMatchesByEventId(
|
|
eventId: string
|
|
): Promise<void> {
|
|
const db = database();
|
|
await db
|
|
.delete(schema.playoffMatches)
|
|
.where(eq(schema.playoffMatches.scoringEventId, eventId));
|
|
}
|
|
|
|
/**
|
|
* Set the winner of a playoff match
|
|
*/
|
|
export async function setMatchWinner(
|
|
matchId: string,
|
|
winnerId: string,
|
|
loserId: string,
|
|
participant1Score?: number,
|
|
participant2Score?: number
|
|
): Promise<PlayoffMatch> {
|
|
const db = database();
|
|
const [match] = await db
|
|
.update(schema.playoffMatches)
|
|
.set({
|
|
winnerId,
|
|
loserId,
|
|
isComplete: true,
|
|
participant1Score: participant1Score?.toString(),
|
|
participant2Score: participant2Score?.toString(),
|
|
updatedAt: new Date(),
|
|
})
|
|
.where(eq(schema.playoffMatches.id, matchId))
|
|
.returning();
|
|
return match;
|
|
}
|
|
|
|
/**
|
|
* Generate a standard single elimination bracket structure
|
|
*/
|
|
export async function generateSingleEliminationBracket(
|
|
eventId: string,
|
|
participantIds: string[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const db = database();
|
|
const numParticipants = participantIds.length;
|
|
|
|
// Validate that we have 4 or 8 participants for standard bracket
|
|
if (numParticipants !== 4 && numParticipants !== 8) {
|
|
throw new Error("Single elimination bracket requires 4 or 8 participants");
|
|
}
|
|
|
|
const matches: NewPlayoffMatch[] = [];
|
|
|
|
if (numParticipants === 8) {
|
|
// Quarterfinals (4 matches)
|
|
for (let i = 0; i < 4; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Quarterfinals",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds[i * 2],
|
|
participant2Id: participantIds[i * 2 + 1],
|
|
isComplete: false,
|
|
});
|
|
}
|
|
|
|
// Semifinals (2 matches)
|
|
for (let i = 0; i < 2; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Semifinals",
|
|
matchNumber: i + 1,
|
|
participant1Id: null,
|
|
participant2Id: null,
|
|
isComplete: false,
|
|
});
|
|
}
|
|
} else if (numParticipants === 4) {
|
|
// Semifinals (2 matches)
|
|
for (let i = 0; i < 2; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Semifinals",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds[i * 2],
|
|
participant2Id: participantIds[i * 2 + 1],
|
|
isComplete: false,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Finals (1 match)
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Finals",
|
|
matchNumber: 1,
|
|
participant1Id: null,
|
|
participant2Id: null,
|
|
isComplete: false,
|
|
});
|
|
|
|
return await createManyPlayoffMatches(matches);
|
|
}
|
|
|
|
/**
|
|
* Advance the winner of a match to the next round
|
|
* Uses deterministic slot assignment to maintain bracket structure
|
|
*/
|
|
export async function advanceWinner(
|
|
matchId: string,
|
|
winnerId: string
|
|
): Promise<void> {
|
|
const db = database();
|
|
|
|
// Get the match
|
|
const match = await findPlayoffMatchById(matchId);
|
|
if (!match) throw new Error("Match not found");
|
|
|
|
// Determine which round this is and where to advance
|
|
const eventId = match.scoringEventId;
|
|
let nextRound: string;
|
|
let nextMatchNumber: number;
|
|
let participantSlot: 'participant1Id' | 'participant2Id';
|
|
|
|
if (match.round === "Quarterfinals") {
|
|
nextRound = "Semifinals";
|
|
// Match 1,2 -> SF1, Match 3,4 -> SF2
|
|
nextMatchNumber = match.matchNumber <= 2 ? 1 : 2;
|
|
// Odd matches (1, 3) -> participant1, Even matches (2, 4) -> participant2
|
|
participantSlot = match.matchNumber % 2 === 1 ? 'participant1Id' : 'participant2Id';
|
|
} else if (match.round === "Semifinals") {
|
|
nextRound = "Finals";
|
|
nextMatchNumber = 1;
|
|
// SF Match 1 -> Finals participant1, SF Match 2 -> Finals participant2
|
|
participantSlot = match.matchNumber === 1 ? 'participant1Id' : 'participant2Id';
|
|
} else {
|
|
// Finals - no advancement needed
|
|
return;
|
|
}
|
|
|
|
// Find the next match
|
|
const nextMatches = await findPlayoffMatchesByEventIdAndRound(eventId, nextRound);
|
|
const nextMatch = nextMatches.find(m => m.matchNumber === nextMatchNumber);
|
|
|
|
if (!nextMatch) throw new Error("Next match not found");
|
|
|
|
// Check if the slot is already filled
|
|
if (nextMatch[participantSlot]) {
|
|
throw new Error(`Next match ${participantSlot} is already filled`);
|
|
}
|
|
|
|
// Fill the determined slot
|
|
await updatePlayoffMatch(nextMatch.id, { [participantSlot]: winnerId });
|
|
}
|
|
|
|
/**
|
|
* NCAA 68 First Four seeding
|
|
* Returns matchups for the 4 play-in games
|
|
*
|
|
* First Four structure (using 0-indexed participant array):
|
|
* - Games 1-2: Participants 64-67 (16 seeds, lowest auto-qualifiers)
|
|
* - Winners are 16 seeds and face 1 seeds in Round of 64
|
|
* - Games 3-4: Participants 60-63 (11/12 seeds, last at-large bids)
|
|
* - Winners are 11 seeds and face 6 seeds in Round of 64
|
|
*/
|
|
function generateNCAA68FirstFourSeeding(): [number, number][] {
|
|
return [
|
|
[64, 65], // First Four Game 1: 16-seed play-in A (winner is 16 seed, faces 1 seed)
|
|
[66, 67], // First Four Game 2: 16-seed play-in B (winner is 16 seed, faces 1 seed)
|
|
[60, 61], // First Four Game 3: 11/12-seed play-in A (winner is 11 seed, faces 6 seed)
|
|
[62, 63], // First Four Game 4: 11/12-seed play-in B (winner is 11 seed, faces 6 seed)
|
|
];
|
|
}
|
|
|
|
/**
|
|
* NCAA 68 Round of 64 seeding
|
|
* Returns matchups for the Round of 64, with 4 TBD slots from First Four
|
|
*
|
|
* 68 teams total: 60 directly seeded (0-59) + 8 in First Four (60-67)
|
|
* Round of 64 needs 64 participants: 60 direct + 4 First Four winners
|
|
*
|
|
* Distribution: Each region has 15 direct seeds + 1 FF winner = 16 per region
|
|
* - Region 1: Seeds 0-14 + FF1 (FF1 winner is 16 seed, faces 1 seed)
|
|
* - Region 2: Seeds 15-29 + FF2 (FF2 winner is 16 seed, faces 1 seed)
|
|
* - Region 3: Seeds 30-44 + FF3 (FF3 winner is 11 seed, faces 6 seed)
|
|
* - Region 4: Seeds 45-59 + FF4 (FF4 winner is 11 seed, faces 6 seed)
|
|
*
|
|
* @returns Array of [seed1, seed2 or "FF{gameNum}"] pairs for 32 matches
|
|
*/
|
|
function generateNCAA68RoundOf64Seeding(): ([number, number] | [number, string] | [string, number])[] {
|
|
const matchups: ([number, number] | [number, string] | [string, number])[] = [];
|
|
|
|
// Region 1: Seeds 0-14 + FF1 (16 total)
|
|
// Standard bracket order: 1v16, 8v9, 5v12, 4v13, 6v11, 3v14, 7v10, 2v15
|
|
matchups.push([0, "FF1"]); // #1 vs #16 (FF1 winner)
|
|
matchups.push([7, 8]); // #8 vs #9
|
|
matchups.push([4, 11]); // #5 vs #12
|
|
matchups.push([3, 12]); // #4 vs #13
|
|
matchups.push([5, 10]); // #6 vs #11
|
|
matchups.push([2, 13]); // #3 vs #14
|
|
matchups.push([6, 9]); // #7 vs #10
|
|
matchups.push([1, 14]); // #2 vs #15
|
|
|
|
// Region 2: Seeds 15-29 + FF2 (16 total)
|
|
matchups.push([15, "FF2"]); // #1 vs #16 (FF2 winner)
|
|
matchups.push([22, 23]); // #8 vs #9
|
|
matchups.push([19, 26]); // #5 vs #12
|
|
matchups.push([18, 27]); // #4 vs #13
|
|
matchups.push([20, 25]); // #6 vs #11
|
|
matchups.push([17, 28]); // #3 vs #14
|
|
matchups.push([21, 24]); // #7 vs #10
|
|
matchups.push([16, 29]); // #2 vs #15
|
|
|
|
// Region 3: Seeds 30-44 + FF3 (16 total)
|
|
matchups.push([30, 44]); // #1 vs #16
|
|
matchups.push([37, 38]); // #8 vs #9
|
|
matchups.push([34, 41]); // #5 vs #12
|
|
matchups.push([33, 42]); // #4 vs #13
|
|
matchups.push([35, "FF3"]); // #6 vs #11 (FF3 winner = 11 seed)
|
|
matchups.push([32, 43]); // #3 vs #14
|
|
matchups.push([36, 39]); // #7 vs #10
|
|
matchups.push([31, 40]); // #2 vs #15
|
|
|
|
// Region 4: Seeds 45-59 + FF4 (16 total)
|
|
matchups.push([45, 59]); // #1 vs #16
|
|
matchups.push([52, 53]); // #8 vs #9
|
|
matchups.push([49, 56]); // #5 vs #12
|
|
matchups.push([48, 57]); // #4 vs #13
|
|
matchups.push([50, "FF4"]); // #6 vs #11 (FF4 winner = 11 seed)
|
|
matchups.push([47, 58]); // #3 vs #14
|
|
matchups.push([51, 54]); // #7 vs #10
|
|
matchups.push([46, 55]); // #2 vs #15
|
|
|
|
return matchups;
|
|
}
|
|
|
|
/**
|
|
* Generate standard tournament seeding matchups
|
|
* Returns pairs of seed indices for proper bracket balance
|
|
*
|
|
* Examples:
|
|
* - 4 teams: [[0,3], [1,2]] = 1v4, 2v3
|
|
* - 8 teams: [[0,7], [3,4], [1,6], [2,5]] = 1v8, 4v5, 2v7, 3v6
|
|
* - 16 teams: [[0,15], [7,8], [4,11], [3,12], [5,10], [2,13], [6,9], [1,14]]
|
|
* = 1v16, 8v9, 5v12, 4v13, 6v11, 3v14, 7v10, 2v15
|
|
*/
|
|
function generateStandardSeeding(teamCount: number): [number, number][] {
|
|
if (![4, 8, 16, 32].includes(teamCount)) {
|
|
// Non-standard sizes need sequential seeding for now
|
|
const pairs: [number, number][] = [];
|
|
for (let i = 0; i < teamCount; i += 2) {
|
|
pairs.push([i, i + 1]);
|
|
}
|
|
return pairs;
|
|
}
|
|
|
|
// Standard balanced bracket seeding
|
|
const rounds = Math.log2(teamCount);
|
|
let seeds = [0, 1]; // Start with 1 vs 2
|
|
|
|
// Build up seeding by adding rounds
|
|
for (let round = 1; round < rounds; round++) {
|
|
const newSeeds: number[] = [];
|
|
const maxSeed = Math.pow(2, round + 1) - 1;
|
|
|
|
for (const seed of seeds) {
|
|
newSeeds.push(seed);
|
|
newSeeds.push(maxSeed - seed);
|
|
}
|
|
seeds = newSeeds;
|
|
}
|
|
|
|
// Convert to pairs (odd indices vs even indices)
|
|
const pairs: [number, number][] = [];
|
|
for (let i = 0; i < seeds.length; i += 2) {
|
|
pairs.push([seeds[i], seeds[i + 1]]);
|
|
}
|
|
|
|
return pairs;
|
|
}
|
|
|
|
/**
|
|
* Generate a bracket from a template
|
|
* Phase 2.6: Template-based bracket generation
|
|
* Phase 2.7: Added proper tournament seeding
|
|
*
|
|
* @param eventId - The scoring event ID
|
|
* @param templateId - The bracket template ID (e.g., "simple_16", "ncaa_68")
|
|
* @param participantIds - Array of participant IDs to assign to the bracket (optional, can be assigned later)
|
|
* @returns Array of created playoff matches
|
|
*/
|
|
export async function generateBracketFromTemplate(
|
|
eventId: string,
|
|
templateId: string,
|
|
participantIds?: string[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const template = getBracketTemplate(templateId);
|
|
if (!template) {
|
|
throw new Error(`Bracket template '${templateId}' not found`);
|
|
}
|
|
|
|
// Validate participant count if provided
|
|
if (participantIds && participantIds.length !== template.totalTeams) {
|
|
throw new Error(
|
|
`Template '${templateId}' requires ${template.totalTeams} participants, but ${participantIds.length} were provided`
|
|
);
|
|
}
|
|
|
|
// NCAA 68 requires special handling for First Four and Round of 64
|
|
if (templateId === "ncaa_68") {
|
|
return await generateNCAA68Bracket(eventId, template, participantIds);
|
|
}
|
|
|
|
// NFL 14 requires special handling for bye weeks
|
|
if (templateId === "nfl_14") {
|
|
return await generateNFL14Bracket(eventId, template, participantIds);
|
|
}
|
|
|
|
// AFL 10 requires special handling for double-chance finals system
|
|
if (templateId === "afl_10") {
|
|
return await generateAFL10Bracket(eventId, template, participantIds);
|
|
}
|
|
|
|
const matches: NewPlayoffMatch[] = [];
|
|
|
|
// Generate matches for each round in the template
|
|
for (const round of template.rounds) {
|
|
// Only assign participants to the first round if participantIds provided
|
|
let seedingPairs: [number, number][] = [];
|
|
|
|
if (participantIds && round === template.rounds[0]) {
|
|
const firstRoundTeams = round.matchCount * 2;
|
|
seedingPairs = generateStandardSeeding(firstRoundTeams);
|
|
}
|
|
|
|
for (let i = 0; i < round.matchCount; i++) {
|
|
let participant1Id: string | null = null;
|
|
let participant2Id: string | null = null;
|
|
let seedInfo: string | null = null;
|
|
|
|
if (participantIds && round === template.rounds[0] && seedingPairs[i]) {
|
|
const [seed1Index, seed2Index] = seedingPairs[i];
|
|
participant1Id = participantIds[seed1Index] || null;
|
|
participant2Id = participantIds[seed2Index] || null;
|
|
|
|
// Store seed info for display (1-indexed for users)
|
|
seedInfo = `${seed1Index + 1} vs ${seed2Index + 1}`;
|
|
}
|
|
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: round.name,
|
|
matchNumber: i + 1,
|
|
participant1Id,
|
|
participant2Id,
|
|
isComplete: false,
|
|
isScoring: round.isScoring,
|
|
templateRound: round.name,
|
|
seedInfo,
|
|
});
|
|
}
|
|
}
|
|
|
|
return await createManyPlayoffMatches(matches);
|
|
}
|
|
|
|
/**
|
|
* Generate NCAA 68 bracket with First Four and Round of 64
|
|
* Phase 2.8: Special handling for First Four play-in games
|
|
*/
|
|
async function generateNCAA68Bracket(
|
|
eventId: string,
|
|
template: BracketTemplate,
|
|
participantIds?: string[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const matches: NewPlayoffMatch[] = [];
|
|
|
|
// First Four: 4 play-in games
|
|
const firstFourSeeding = generateNCAA68FirstFourSeeding();
|
|
for (let i = 0; i < firstFourSeeding.length; i++) {
|
|
const [seed1, seed2] = firstFourSeeding[i];
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "First Four",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds ? participantIds[seed1] : null,
|
|
participant2Id: participantIds ? participantIds[seed2] : null,
|
|
isComplete: false,
|
|
isScoring: false, // First Four doesn't score fantasy points
|
|
templateRound: "First Four",
|
|
seedInfo: `${seed1 + 1} vs ${seed2 + 1}`,
|
|
});
|
|
}
|
|
|
|
// Round of 64: 32 games with some TBD slots from First Four
|
|
const roundOf64Seeding = generateNCAA68RoundOf64Seeding();
|
|
for (let i = 0; i < roundOf64Seeding.length; i++) {
|
|
const matchup = roundOf64Seeding[i];
|
|
let participant1Id: string | null = null;
|
|
let participant2Id: string | null = null;
|
|
let seedInfo: string | null = null;
|
|
|
|
if (participantIds) {
|
|
const [seed1, seed2] = matchup;
|
|
|
|
// Handle TBD slots (FF1-FF4 placeholders)
|
|
if (typeof seed1 === "number") {
|
|
participant1Id = participantIds[seed1];
|
|
} // else it's "FF1", "FF2", etc. - will be filled by First Four winner
|
|
|
|
if (typeof seed2 === "number") {
|
|
participant2Id = participantIds[seed2];
|
|
}
|
|
|
|
seedInfo = `${typeof seed1 === "number" ? seed1 + 1 : seed1} vs ${typeof seed2 === "number" ? seed2 + 1 : seed2}`;
|
|
}
|
|
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Round of 64",
|
|
matchNumber: i + 1,
|
|
participant1Id,
|
|
participant2Id,
|
|
isComplete: false,
|
|
isScoring: false, // Round of 64 doesn't score
|
|
templateRound: "Round of 64",
|
|
seedInfo,
|
|
});
|
|
}
|
|
|
|
// Generate remaining rounds (Round of 32, Sweet Sixteen, Elite Eight, Final Four, Championship)
|
|
for (let roundIndex = 2; roundIndex < template.rounds.length; roundIndex++) {
|
|
const round = template.rounds[roundIndex];
|
|
for (let i = 0; i < round.matchCount; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: round.name,
|
|
matchNumber: i + 1,
|
|
participant1Id: null,
|
|
participant2Id: null,
|
|
isComplete: false,
|
|
isScoring: round.isScoring,
|
|
templateRound: round.name,
|
|
seedInfo: null,
|
|
});
|
|
}
|
|
}
|
|
|
|
return await createManyPlayoffMatches(matches);
|
|
}
|
|
|
|
/**
|
|
* Generate NFL 14 bracket with bye weeks for top 2 seeds
|
|
* Phase 2.9: Special handling for Wild Card round (12 teams) and Divisional byes
|
|
*/
|
|
async function generateNFL14Bracket(
|
|
eventId: string,
|
|
template: BracketTemplate,
|
|
participantIds?: string[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const matches: NewPlayoffMatch[] = [];
|
|
|
|
// Wild Card: 6 games for seeds 3-14 (12 teams)
|
|
// Seeds 1-2 get byes and automatically advance to Divisional
|
|
const wildCardSeeding = [
|
|
[6, 10], // #7 seed vs #11 seed (0-indexed: 6 vs 10)
|
|
[5, 11], // #6 seed vs #12 seed
|
|
[4, 12], // #5 seed vs #13 seed
|
|
[7, 9], // #8 seed vs #10 seed
|
|
[3, 13], // #4 seed vs #14 seed
|
|
[2, 14], // #3 seed vs #15 seed (Note: 14 is index for seed 15, but we only have 14 teams, so this is 3 vs 14)
|
|
];
|
|
|
|
// Actually for 14 teams (seeds 1-14), Wild Card should be:
|
|
// Match 1: #7 (index 6) vs #10 (index 9)
|
|
// Match 2: #6 (index 5) vs #11 (index 10)
|
|
// Match 3: #5 (index 4) vs #12 (index 11)
|
|
// Match 4: #8 (index 7) vs #9 (index 8)
|
|
// Match 5: #4 (index 3) vs #13 (index 12)
|
|
// Match 6: #3 (index 2) vs #14 (index 13)
|
|
const correctedWildCardSeeding = [
|
|
[6, 9], // #7 vs #10
|
|
[5, 10], // #6 vs #11
|
|
[4, 11], // #5 vs #12
|
|
[7, 8], // #8 vs #9
|
|
[3, 12], // #4 vs #13
|
|
[2, 13], // #3 vs #14
|
|
];
|
|
|
|
for (let i = 0; i < correctedWildCardSeeding.length; i++) {
|
|
const [seed1, seed2] = correctedWildCardSeeding[i];
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Wild Card",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds ? participantIds[seed1] : null,
|
|
participant2Id: participantIds ? participantIds[seed2] : null,
|
|
isComplete: false,
|
|
isScoring: false, // Wild Card doesn't score fantasy points
|
|
templateRound: "Wild Card",
|
|
seedInfo: `${seed1 + 1} vs ${seed2 + 1}`,
|
|
});
|
|
}
|
|
|
|
// Divisional: 4 games
|
|
// Top 2 seeds (#1 and #2) get byes and are placed in Divisional automatically
|
|
// The other 2 Divisional matches will be filled by Wild Card winners
|
|
const divisionalRound = template.rounds.find((r) => r.name === "Divisional");
|
|
if (divisionalRound) {
|
|
for (let i = 0; i < divisionalRound.matchCount; i++) {
|
|
let participant1Id: string | null = null;
|
|
let participant2Id: string | null = null;
|
|
let seedInfo: string | null = null;
|
|
|
|
// Assign bye teams to first two Divisional matches
|
|
if (participantIds) {
|
|
if (i === 0) {
|
|
// Match 1: #1 seed (index 0) vs TBD (Wild Card winner)
|
|
participant1Id = participantIds[0];
|
|
seedInfo = "1 vs TBD";
|
|
} else if (i === 1) {
|
|
// Match 2: #2 seed (index 1) vs TBD (Wild Card winner)
|
|
participant1Id = participantIds[1];
|
|
seedInfo = "2 vs TBD";
|
|
}
|
|
// Matches 3 and 4 are TBD vs TBD (Wild Card winners)
|
|
}
|
|
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Divisional",
|
|
matchNumber: i + 1,
|
|
participant1Id,
|
|
participant2Id,
|
|
isComplete: false,
|
|
isScoring: divisionalRound.isScoring,
|
|
templateRound: "Divisional",
|
|
seedInfo,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Generate remaining rounds (Conference Championship, Super Bowl)
|
|
for (let roundIndex = 2; roundIndex < template.rounds.length; roundIndex++) {
|
|
const round = template.rounds[roundIndex];
|
|
for (let i = 0; i < round.matchCount; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: round.name,
|
|
matchNumber: i + 1,
|
|
participant1Id: null,
|
|
participant2Id: null,
|
|
isComplete: false,
|
|
isScoring: round.isScoring,
|
|
templateRound: round.name,
|
|
seedInfo: null,
|
|
});
|
|
}
|
|
}
|
|
|
|
return await createManyPlayoffMatches(matches);
|
|
}
|
|
|
|
/**
|
|
* Generate AFL 10 bracket with Wildcard Round (2026+ format)
|
|
* Phase 3.3: Special handling for AFL's double-chance finals system
|
|
*
|
|
* Structure:
|
|
* - Wildcard Round: 7v10, 8v9
|
|
* - Qualifying Finals: 1v4, 2v3 (winners get bye to Preliminary Finals, losers to Semi-Finals)
|
|
* - Elimination Finals: 5v8, 6v7 (where 7 and 8 are wildcard winners)
|
|
* - Semi-Finals: QF losers vs EF winners
|
|
* - Preliminary Finals: QF winners vs SF winners
|
|
* - Grand Final: PF winners
|
|
*/
|
|
async function generateAFL10Bracket(
|
|
eventId: string,
|
|
template: BracketTemplate,
|
|
participantIds?: string[]
|
|
): Promise<PlayoffMatch[]> {
|
|
const matches: NewPlayoffMatch[] = [];
|
|
|
|
// Wildcard Round: 7th vs 10th, 8th vs 9th
|
|
const wildcardSeeding = [
|
|
[6, 9], // #7 (index 6) vs #10 (index 9) - 7th hosts
|
|
[7, 8], // #8 (index 7) vs #9 (index 8) - 8th hosts
|
|
];
|
|
|
|
for (let i = 0; i < wildcardSeeding.length; i++) {
|
|
const [seed1, seed2] = wildcardSeeding[i];
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Wildcard Round",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds ? participantIds[seed1] : null,
|
|
participant2Id: participantIds ? participantIds[seed2] : null,
|
|
isComplete: false,
|
|
isScoring: false, // Losers get 0 points (9th-10th place)
|
|
templateRound: "Wildcard Round",
|
|
seedInfo: `${seed1 + 1} vs ${seed2 + 1}`,
|
|
});
|
|
}
|
|
|
|
// Qualifying Finals: 1st vs 4th, 2nd vs 3rd
|
|
const qualifyingSeeding = [
|
|
[0, 3], // #1 (index 0) vs #4 (index 3)
|
|
[1, 2], // #2 (index 1) vs #3 (index 2)
|
|
];
|
|
|
|
for (let i = 0; i < qualifyingSeeding.length; i++) {
|
|
const [seed1, seed2] = qualifyingSeeding[i];
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Qualifying Finals",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds ? participantIds[seed1] : null,
|
|
participant2Id: participantIds ? participantIds[seed2] : null,
|
|
isComplete: false,
|
|
isScoring: false, // Winners get bye, losers get second chance
|
|
templateRound: "Qualifying Finals",
|
|
seedInfo: `${seed1 + 1} vs ${seed2 + 1}`,
|
|
});
|
|
}
|
|
|
|
// Elimination Finals: 5th vs TBD (wildcard winner), 6th vs TBD (wildcard winner)
|
|
const eliminationSeeding = [
|
|
{ higher: 4, wildcard: 2 }, // #5 (index 4) vs Wildcard Match 2 winner
|
|
{ higher: 5, wildcard: 1 }, // #6 (index 5) vs Wildcard Match 1 winner
|
|
];
|
|
|
|
for (let i = 0; i < eliminationSeeding.length; i++) {
|
|
const { higher, wildcard } = eliminationSeeding[i];
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Elimination Finals",
|
|
matchNumber: i + 1,
|
|
participant1Id: participantIds ? participantIds[higher] : null,
|
|
participant2Id: null, // Will be filled by wildcard winner
|
|
isComplete: false,
|
|
isScoring: true, // Losers share 7th-8th
|
|
templateRound: "Elimination Finals",
|
|
seedInfo: participantIds ? `${higher + 1} vs WC${wildcard}` : null,
|
|
});
|
|
}
|
|
|
|
// Semi-Finals: QF losers vs EF winners (TBD vs TBD)
|
|
for (let i = 0; i < 2; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Semi-Finals",
|
|
matchNumber: i + 1,
|
|
participant1Id: null, // Will be filled by QF loser
|
|
participant2Id: null, // Will be filled by EF winner
|
|
isComplete: false,
|
|
isScoring: true, // Losers share 5th-6th
|
|
templateRound: "Semi-Finals",
|
|
seedInfo: null,
|
|
});
|
|
}
|
|
|
|
// Preliminary Finals: QF winners vs SF winners (TBD vs TBD)
|
|
for (let i = 0; i < 2; i++) {
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Preliminary Finals",
|
|
matchNumber: i + 1,
|
|
participant1Id: null, // Will be filled by QF winner
|
|
participant2Id: null, // Will be filled by SF winner
|
|
isComplete: false,
|
|
isScoring: true, // Losers share 3rd-4th
|
|
templateRound: "Preliminary Finals",
|
|
seedInfo: null,
|
|
});
|
|
}
|
|
|
|
// Grand Final: PF winners (TBD vs TBD)
|
|
matches.push({
|
|
scoringEventId: eventId,
|
|
round: "Grand Final",
|
|
matchNumber: 1,
|
|
participant1Id: null,
|
|
participant2Id: null,
|
|
isComplete: false,
|
|
isScoring: true, // Winner 1st, Loser 2nd
|
|
templateRound: "Grand Final",
|
|
seedInfo: null,
|
|
});
|
|
|
|
return await createManyPlayoffMatches(matches);
|
|
}
|
|
|
|
/**
|
|
* AFL-specific advancement logic for the complex double-chance system
|
|
* Phase 3.3: Handles both winners and losers advancing to different rounds
|
|
*
|
|
* Advancement rules:
|
|
* - Wildcard Round: Winner → Elimination Finals
|
|
* - Qualifying Finals: Winner → Preliminary Finals, Loser → Semi-Finals
|
|
* - Elimination Finals: Winner → Semi-Finals
|
|
* - Semi-Finals: Winner → Preliminary Finals
|
|
* - Preliminary Finals: Winner → Grand Final
|
|
*/
|
|
async function advanceAFLWinner(
|
|
match: PlayoffMatch,
|
|
winnerId: string,
|
|
loserId: string
|
|
): Promise<void> {
|
|
const db = database();
|
|
const eventId = match.scoringEventId;
|
|
|
|
// Wildcard Round: Winner advances to Elimination Finals
|
|
if (match.round === "Wildcard Round") {
|
|
// Wildcard Match 1 winner → EF Match 2, participant2Id
|
|
// Wildcard Match 2 winner → EF Match 1, participant2Id
|
|
const efMatchNumber = match.matchNumber === 1 ? 2 : 1;
|
|
const efMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Elimination Finals");
|
|
const efMatch = efMatches.find((m) => m.matchNumber === efMatchNumber);
|
|
|
|
if (!efMatch) throw new Error(`Elimination Finals match ${efMatchNumber} not found`);
|
|
if (efMatch.participant2Id) throw new Error(`EF ${efMatchNumber} participant2 already filled`);
|
|
|
|
await updatePlayoffMatch(efMatch.id, { participant2Id: winnerId });
|
|
return;
|
|
}
|
|
|
|
// Qualifying Finals: Winner → Preliminary Finals, Loser → Semi-Finals
|
|
if (match.round === "Qualifying Finals") {
|
|
// QF Match 1: Winner → PF1 participant1, Loser → SF1 participant1
|
|
// QF Match 2: Winner → PF2 participant1, Loser → SF2 participant1
|
|
const pfMatchNumber = match.matchNumber;
|
|
const pfMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Preliminary Finals");
|
|
const pfMatch = pfMatches.find((m) => m.matchNumber === pfMatchNumber);
|
|
|
|
if (!pfMatch) throw new Error(`Preliminary Finals match ${pfMatchNumber} not found`);
|
|
if (pfMatch.participant1Id) throw new Error(`PF ${pfMatchNumber} participant1 already filled`);
|
|
|
|
await updatePlayoffMatch(pfMatch.id, { participant1Id: winnerId });
|
|
|
|
// Also advance loser to Semi-Finals
|
|
const sfMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Semi-Finals");
|
|
const sfMatch = sfMatches.find((m) => m.matchNumber === match.matchNumber);
|
|
|
|
if (!sfMatch) throw new Error(`Semi-Finals match ${match.matchNumber} not found`);
|
|
if (sfMatch.participant1Id) throw new Error(`SF ${match.matchNumber} participant1 already filled`);
|
|
|
|
await updatePlayoffMatch(sfMatch.id, { participant1Id: loserId });
|
|
return;
|
|
}
|
|
|
|
// Elimination Finals: Winner → Semi-Finals
|
|
if (match.round === "Elimination Finals") {
|
|
// EF Match 1 winner → SF2 participant2
|
|
// EF Match 2 winner → SF1 participant2
|
|
const sfMatchNumber = match.matchNumber === 1 ? 2 : 1;
|
|
const sfMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Semi-Finals");
|
|
const sfMatch = sfMatches.find((m) => m.matchNumber === sfMatchNumber);
|
|
|
|
if (!sfMatch) throw new Error(`Semi-Finals match ${sfMatchNumber} not found`);
|
|
if (sfMatch.participant2Id) throw new Error(`SF ${sfMatchNumber} participant2 already filled`);
|
|
|
|
await updatePlayoffMatch(sfMatch.id, { participant2Id: winnerId });
|
|
return;
|
|
}
|
|
|
|
// Semi-Finals: Winner → Preliminary Finals
|
|
if (match.round === "Semi-Finals") {
|
|
// SF Match 1 winner → PF2 participant2
|
|
// SF Match 2 winner → PF1 participant2
|
|
const pfMatchNumber = match.matchNumber === 1 ? 2 : 1;
|
|
const pfMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Preliminary Finals");
|
|
const pfMatch = pfMatches.find((m) => m.matchNumber === pfMatchNumber);
|
|
|
|
if (!pfMatch) throw new Error(`Preliminary Finals match ${pfMatchNumber} not found`);
|
|
if (pfMatch.participant2Id) throw new Error(`PF ${pfMatchNumber} participant2 already filled`);
|
|
|
|
await updatePlayoffMatch(pfMatch.id, { participant2Id: winnerId });
|
|
return;
|
|
}
|
|
|
|
// Preliminary Finals: Winner → Grand Final
|
|
if (match.round === "Preliminary Finals") {
|
|
const gfMatches = await findPlayoffMatchesByEventIdAndRound(eventId, "Grand Final");
|
|
const gfMatch = gfMatches[0];
|
|
|
|
if (!gfMatch) throw new Error("Grand Final match not found");
|
|
|
|
const participantSlot: 'participant1Id' | 'participant2Id' =
|
|
match.matchNumber === 1 ? 'participant1Id' : 'participant2Id';
|
|
|
|
if (gfMatch[participantSlot]) throw new Error(`GF ${participantSlot} already filled`);
|
|
|
|
await updatePlayoffMatch(gfMatch.id, { [participantSlot]: winnerId });
|
|
return;
|
|
}
|
|
|
|
// Grand Final: No advancement
|
|
if (match.round === "Grand Final") {
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Advance winner to next round using template-based logic
|
|
* Works with any bracket template
|
|
*/
|
|
export async function advanceWinnerTemplate(
|
|
matchId: string,
|
|
winnerId: string,
|
|
template: BracketTemplate
|
|
): Promise<void> {
|
|
const db = database();
|
|
|
|
// Get the match
|
|
const match = await findPlayoffMatchById(matchId);
|
|
if (!match) throw new Error("Match not found");
|
|
|
|
// Special handling for AFL 10 double-chance system
|
|
// Phase 3.3: AFL has complex winner/loser advancement rules
|
|
if (template.id === "afl_10") {
|
|
const loserId = match.winnerId === match.participant1Id ? match.participant2Id : match.participant1Id;
|
|
if (!loserId) throw new Error("Cannot determine loser for AFL advancement");
|
|
return await advanceAFLWinner(match, winnerId, loserId);
|
|
}
|
|
|
|
// Special handling for NCAA 68 First Four
|
|
// Phase 2.8: First Four winners advance to specific Round of 64 slots
|
|
if (template.id === "ncaa_68" && match.round === "First Four") {
|
|
return await advanceFirstFourWinner(match, winnerId);
|
|
}
|
|
|
|
// Find current round in template
|
|
const currentRoundIndex = template.rounds.findIndex(
|
|
(r) => r.name === match.round
|
|
);
|
|
if (currentRoundIndex === -1) {
|
|
throw new Error(`Round '${match.round}' not found in template`);
|
|
}
|
|
|
|
const currentRound = template.rounds[currentRoundIndex];
|
|
|
|
// Check if there's a next round
|
|
if (!currentRound.feedsInto) {
|
|
// Championship game - no advancement needed
|
|
return;
|
|
}
|
|
|
|
const nextRound = template.rounds.find((r) => r.name === currentRound.feedsInto);
|
|
if (!nextRound) {
|
|
throw new Error(`Next round '${currentRound.feedsInto}' not found in template`);
|
|
}
|
|
|
|
// Determine next match number and slot
|
|
// This uses the same logic as before: matches advance in sequential pairs
|
|
const nextMatchNumber = Math.ceil(match.matchNumber / 2);
|
|
const participantSlot: 'participant1Id' | 'participant2Id' =
|
|
match.matchNumber % 2 === 1 ? 'participant1Id' : 'participant2Id';
|
|
|
|
// Find the next match
|
|
const nextMatches = await findPlayoffMatchesByEventIdAndRound(
|
|
match.scoringEventId,
|
|
nextRound.name
|
|
);
|
|
const nextMatch = nextMatches.find((m) => m.matchNumber === nextMatchNumber);
|
|
|
|
if (!nextMatch) {
|
|
throw new Error(
|
|
`Next match not found: round=${nextRound.name}, matchNumber=${nextMatchNumber}`
|
|
);
|
|
}
|
|
|
|
// Check if the slot is already filled
|
|
if (nextMatch[participantSlot]) {
|
|
throw new Error(`Next match ${participantSlot} is already filled`);
|
|
}
|
|
|
|
// Fill the determined slot
|
|
await updatePlayoffMatch(nextMatch.id, { [participantSlot]: winnerId });
|
|
}
|
|
|
|
/**
|
|
* Advance First Four winner to Round of 64
|
|
* Phase 2.8: NCAA 68 specific logic
|
|
*
|
|
* First Four match → Round of 64 match mapping:
|
|
* - FF Match 1 (16-seed) → R64 Match 1 (Region 1 vs #1 seed), participant2Id
|
|
* - FF Match 2 (16-seed) → R64 Match 9 (Region 2 vs #1 seed), participant2Id
|
|
* - FF Match 3 (11-seed) → R64 Match 21 (Region 3 vs #6 seed), participant2Id
|
|
* - FF Match 4 (11-seed) → R64 Match 29 (Region 4 vs #6 seed), participant2Id
|
|
*/
|
|
async function advanceFirstFourWinner(
|
|
firstFourMatch: PlayoffMatch,
|
|
winnerId: string
|
|
): Promise<void> {
|
|
// Map First Four match numbers to Round of 64 match numbers
|
|
const firstFourToRoundOf64: Record<number, number> = {
|
|
1: 1, // FF Game 1 (16-seed) → R64 Match 1 (vs 1 seed)
|
|
2: 9, // FF Game 2 (16-seed) → R64 Match 9 (vs 1 seed)
|
|
3: 21, // FF Game 3 (11-seed) → R64 Match 21 (vs 6 seed)
|
|
4: 29, // FF Game 4 (11-seed) → R64 Match 29 (vs 6 seed)
|
|
};
|
|
|
|
const targetMatchNumber = firstFourToRoundOf64[firstFourMatch.matchNumber];
|
|
if (!targetMatchNumber) {
|
|
throw new Error(`Invalid First Four match number: ${firstFourMatch.matchNumber}`);
|
|
}
|
|
|
|
// Find the target Round of 64 match
|
|
const roundOf64Matches = await findPlayoffMatchesByEventIdAndRound(
|
|
firstFourMatch.scoringEventId,
|
|
"Round of 64"
|
|
);
|
|
|
|
const targetMatch = roundOf64Matches.find((m) => m.matchNumber === targetMatchNumber);
|
|
if (!targetMatch) {
|
|
throw new Error(`Round of 64 match ${targetMatchNumber} not found`);
|
|
}
|
|
|
|
// Check if participant2Id is already filled
|
|
if (targetMatch.participant2Id) {
|
|
throw new Error(`Round of 64 match ${targetMatchNumber} participant2Id is already filled`);
|
|
}
|
|
|
|
// Fill the slot
|
|
await updatePlayoffMatch(targetMatch.id, { participant2Id: winnerId });
|
|
}
|