@ethlete/cdk 4.45.0 → 4.46.1

package/esm2022/lib/components/bracket/components/new-bracket/bracket-new.mjs

@@ -0,0 +1,782 @@
+export const FALLBACK_MATCH_POSITION = -1;
+export const TOURNAMENT_MODE = {
+    SINGLE_ELIMINATION: 'single-elimination',
+    DOUBLE_ELIMINATION: 'double-elimination',
+    GROUP: 'group',
+    SWISS: 'swiss',
+    SWISS_WITH_ELIMINATION: 'swiss-with-elimination',
+};
+export const COMMON_BRACKET_ROUND_TYPE = {
+    THIRD_PLACE: 'third-place',
+    FINAL: 'final',
+};
+export const SINGLE_ELIMINATION_BRACKET_ROUND_TYPE = {
+    SINGLE_ELIMINATION_BRACKET: 'single-elimination-bracket',
+};
+export const DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE = {
+    UPPER_BRACKET: 'upper-bracket',
+    LOWER_BRACKET: 'lower-bracket',
+    REVERSE_FINAL: 'reverse-final',
+};
+export const SWISS_BRACKET_ROUND_TYPE = {
+    SWISS: 'swiss',
+};
+export const GROUP_BRACKET_ROUND_TYPE = {
+    GROUP: 'group',
+};
+export const generateRoundTypeFromEthleteRoundType = (type, tournamentMode) => {
+    switch (type) {
+        case 'normal':
+            switch (tournamentMode) {
+                case 'single-elimination':
+                    return SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET;
+                case 'group':
+                    return GROUP_BRACKET_ROUND_TYPE.GROUP;
+                case 'swiss':
+                    return SWISS_BRACKET_ROUND_TYPE.SWISS;
+                default:
+                    throw new Error(`Unsupported tournament mode for a normal type round: ${tournamentMode}`);
+            }
+        case 'third_place':
+            return COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE;
+        case 'final':
+            return COMMON_BRACKET_ROUND_TYPE.FINAL;
+        case 'reverse_final':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL;
+        case 'winner_bracket':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
+        case 'loser_bracket':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+    }
+};
+export const generateTournamentModeFormEthleteRounds = (source) => {
+    const firstRound = source[0];
+    const firstMatch = firstRound?.matches[0];
+    if (!firstRound)
+        throw new Error('No rounds found');
+    if (!firstMatch)
+        throw new Error('No matches found');
+    switch (firstMatch.matchType) {
+        case 'groups':
+            return TOURNAMENT_MODE.GROUP;
+        case 'fifa_swiss': {
+            const lastRound = source[source.length - 1];
+            if (!lastRound)
+                throw new Error('No last round found');
+            if (lastRound.matches.length !== firstRound.matches.length) {
+                return TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
+            }
+            else {
+                return TOURNAMENT_MODE.SWISS;
+            }
+        }
+        case 'double_elimination':
+            return TOURNAMENT_MODE.DOUBLE_ELIMINATION;
+        case 'single_elimination':
+            return TOURNAMENT_MODE.SINGLE_ELIMINATION;
+        default:
+            throw new Error(`Unsupported tournament mode: ${firstMatch.matchType}`);
+    }
+};
+export const generateBracketDataForEthlete = (source) => {
+    const tournamentMode = generateTournamentModeFormEthleteRounds(source);
+    const bracketData = {
+        rounds: new Map(),
+        matches: new Map(),
+        participants: new Map(),
+        mode: tournamentMode,
+    };
+    let currentUpperBracketIndex = 0;
+    let currentLowerBracketIndex = 0;
+    for (const currentItem of source) {
+        if (bracketData.rounds.has(currentItem.round.id)) {
+            throw new Error(`Round with id ${currentItem.round.id} already exists in the bracket data.`);
+        }
+        const roundType = generateRoundTypeFromEthleteRoundType(currentItem.round.type, tournamentMode);
+        const isLowerBracket = roundType === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+        const bracketRound = {
+            type: roundType,
+            id: currentItem.round.id,
+            index: isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex,
+            data: currentItem.round,
+            position: currentItem.round.number,
+            name: currentItem.round.name || currentItem.round.type,
+            matchCount: currentItem.matches.length,
+            matches: new Map(),
+        };
+        bracketData.rounds.set(currentItem.round.id, bracketRound);
+        for (const [matchIndex, match] of currentItem.matches.entries()) {
+            if (bracketData.matches.has(match.id)) {
+                throw new Error(`Match with id ${match.id} already exists in the bracket data.`);
+            }
+            const bracketMatch = {
+                id: match.id,
+                indexInRound: matchIndex,
+                position: (matchIndex + 1),
+                data: match,
+                round: bracketRound,
+                home: match.home?.id || null,
+                away: match.away?.id || null,
+                winner: match.winningSide,
+                status: match.status === 'published' ? 'completed' : 'pending',
+            };
+            bracketData.matches.set(match.id, bracketMatch);
+            bracketRound.matches.set(match.id, bracketMatch);
+            const participants = [match.home, match.away];
+            for (const participant of participants) {
+                if (!participant)
+                    continue;
+                const participantId = participant.id;
+                if (!bracketData.participants.has(participantId)) {
+                    bracketData.participants.set(participantId, {
+                        id: participantId,
+                        name: participant.name || 'Unknown',
+                        matches: new Map(),
+                    });
+                }
+                const participantData = bracketData.participants.get(participantId);
+                if (!participantData.matches.has(match.id)) {
+                    participantData.matches.set(match.id, {
+                        side: match.home?.id === participantId ? 'home' : 'away',
+                        bracketMatch,
+                    });
+                }
+            }
+        }
+        if (isLowerBracket) {
+            currentLowerBracketIndex++;
+        }
+        else {
+            currentUpperBracketIndex++;
+        }
+    }
+    return bracketData;
+};
+export const generateMatchPositionMaps = (bracketData) => {
+    const matchPositionMaps = new Map();
+    for (const round of bracketData.rounds.values()) {
+        const matchMap = new Map([...round.matches.values()].map((m) => [m.position, m]));
+        matchPositionMaps.set(round.id, matchMap);
+    }
+    return matchPositionMaps;
+};
+export const generateBracketRoundTypeMap = (bracketData) => {
+    const roundAmountMap = new Map();
+    for (const round of bracketData.rounds.values()) {
+        if (!roundAmountMap.has(round.type)) {
+            roundAmountMap.set(round.type, new Map([[round.id, round]]));
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            roundAmountMap.set(round.type, roundAmountMap.get(round.type).set(round.id, round));
+        }
+    }
+    return roundAmountMap;
+};
+const UPPER_LOOP_ORDER = [
+    SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET,
+    DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET,
+    SWISS_BRACKET_ROUND_TYPE.SWISS,
+    GROUP_BRACKET_ROUND_TYPE.GROUP,
+    COMMON_BRACKET_ROUND_TYPE.FINAL,
+    DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL,
+    COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE,
+];
+const LOWER_LOOP_ORDER = [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET];
+export const generateRoundRelations = (bracketData) => {
+    const roundRelations = new Map();
+    const sortedRoundsByType = new Map();
+    for (const round of bracketData.rounds.values()) {
+        if (!sortedRoundsByType.has(round.type)) {
+            sortedRoundsByType.set(round.type, [round]);
+        }
+        else {
+            sortedRoundsByType.get(round.type)?.push(round);
+        }
+    }
+    for (const rounds of sortedRoundsByType.values()) {
+        if (rounds.length === 1)
+            continue;
+        rounds.sort((a, b) => a.position - b.position);
+    }
+    const sortedUpperRounds = UPPER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))
+        .filter((r) => !!r)
+        .flat();
+    const sortedLowerRounds = LOWER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))
+        .filter((r) => !!r)
+        .flat();
+    const firstUpperRound = sortedUpperRounds[0] || null;
+    const firstLowerRound = sortedLowerRounds[0] || null;
+    if (!firstUpperRound)
+        throw new Error('firstUpperRound is null');
+    const hasLowerRounds = sortedLowerRounds.length > 0;
+    const lastLowerRound = sortedLowerRounds[sortedLowerRounds.length - 1] || null;
+    for (const [currentUpperRoundIndex, currentUpperRound] of sortedUpperRounds.entries()) {
+        const previousUpperRound = sortedUpperRounds[currentUpperRoundIndex - 1] || null;
+        const nextUpperRound = sortedUpperRounds[currentUpperRoundIndex + 1] || null;
+        const currentLowerRound = sortedLowerRounds[currentUpperRoundIndex] || null;
+        const previousLowerRound = sortedLowerRounds[currentUpperRoundIndex - 1] || null;
+        const nextLowerRound = sortedLowerRounds[currentUpperRoundIndex + 1] || null;
+        const isFirstRound = currentUpperRoundIndex === 0;
+        const isLastUpperRound = currentUpperRoundIndex === sortedUpperRounds.length - 1;
+        const isFinal = currentUpperRound.type === COMMON_BRACKET_ROUND_TYPE.FINAL;
+        if (isFinal && hasLowerRounds) {
+            // two to one relation
+            if (!lastLowerRound || !currentLowerRound || !previousUpperRound)
+                throw new Error('lastLowerRound or currentLowerRound or previousUpperRound is null');
+            // in a sync double elimination bracket, the final round has the same index as the last lower round
+            // in an async one, there is always one more round in the lower bracket since we only display a section of the whole tournament
+            const isAsyncBracket = currentLowerRound.id !== lastLowerRound.id;
+            const finalLowerRound = isAsyncBracket ? nextLowerRound : currentLowerRound;
+            if (!finalLowerRound)
+                throw new Error('finalLowerRound is null');
+            if (!firstLowerRound)
+                throw new Error('firstLowerRound is null');
+            if (finalLowerRound.id !== lastLowerRound.id)
+                throw new Error('finalLowerRound is not the last lower round');
+            // if we have a reverse final
+            if (nextUpperRound) {
+                // for the final
+                roundRelations.set(currentUpperRound.id, {
+                    type: 'two-to-one',
+                    previousUpperRound: previousUpperRound,
+                    previousLowerRound: finalLowerRound,
+                    nextRound: nextUpperRound,
+                    currentRound: currentUpperRound,
+                    nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+                    previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                    previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,
+                    upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+                    lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,
+                });
+            }
+            else {
+                // no reverse final means the final is the last round
+                // for the final
+                roundRelations.set(currentUpperRound.id, {
+                    type: 'two-to-nothing',
+                    previousUpperRound: previousUpperRound,
+                    previousLowerRound: finalLowerRound,
+                    currentRound: currentUpperRound,
+                    previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,
+                    previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                    lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,
+                    upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+                });
+            }
+            if (isAsyncBracket) {
+                // if this is an async bracket, we need to set the relations for the 2 last lower rounds since they will be skipped by the default one to one logic
+                const preFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 2] || null;
+                const prePreFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 3] || null;
+                if (!preFinalLowerRound)
+                    throw new Error('preFinalLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                // for the last lower round
+                roundRelations.set(finalLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: preFinalLowerRound,
+                    nextRound: currentUpperRound,
+                    currentRound: finalLowerRound,
+                    nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,
+                    previousRoundMatchFactor: preFinalLowerRound.matchCount / finalLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,
+                });
+                if (prePreFinalLowerRound) {
+                    // for the pre final lower round
+                    roundRelations.set(preFinalLowerRound.id, {
+                        type: 'one-to-one',
+                        previousRound: prePreFinalLowerRound,
+                        nextRound: finalLowerRound,
+                        currentRound: preFinalLowerRound,
+                        nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                        previousRoundMatchFactor: prePreFinalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                        rootRoundMatchFactor: firstLowerRound.matchCount / preFinalLowerRound.matchCount,
+                    });
+                }
+                else {
+                    // for the first lower round
+                    roundRelations.set(preFinalLowerRound.id, {
+                        type: 'nothing-to-one',
+                        nextRound: finalLowerRound,
+                        currentRound: preFinalLowerRound,
+                        nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                    });
+                }
+            }
+            else {
+                // this is a sync bracket, we only need to set the relation for the last lower round
+                if (!previousLowerRound)
+                    throw new Error('previousLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                // for the last lower round
+                roundRelations.set(finalLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: previousLowerRound,
+                    nextRound: currentUpperRound,
+                    currentRound: finalLowerRound,
+                    nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,
+                    previousRoundMatchFactor: previousLowerRound.matchCount / finalLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,
+                });
+            }
+        }
+        else if (isLastUpperRound) {
+            // one to nothing relation
+            if (!previousUpperRound)
+                throw new Error('previousUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'one-to-nothing',
+                previousRound: previousUpperRound,
+                currentRound: currentUpperRound,
+                previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+        }
+        else if (isFirstRound) {
+            // nothing to one relation
+            if (!nextUpperRound)
+                throw new Error('nextUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'nothing-to-one',
+                nextRound: nextUpperRound,
+                currentRound: currentUpperRound,
+                nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+            if (currentLowerRound) {
+                if (!nextLowerRound)
+                    throw new Error('nextLowerRound is null');
+                roundRelations.set(currentLowerRound.id, {
+                    type: 'nothing-to-one',
+                    nextRound: nextLowerRound,
+                    currentRound: currentLowerRound,
+                    nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,
+                });
+            }
+        }
+        else {
+            // one to one relation
+            if (!previousUpperRound)
+                throw new Error('previousUpperRound is null');
+            if (!nextUpperRound)
+                throw new Error('nextUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'one-to-one',
+                previousRound: previousUpperRound,
+                nextRound: nextUpperRound,
+                currentRound: currentUpperRound,
+                nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+                previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+            // we only want to set lower rounds here until the special merging point of the final.
+            // lower bracket rounds after and including the final will be set in the final round block
+            if (currentLowerRound && currentUpperRound.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET) {
+                if (!previousLowerRound)
+                    throw new Error('previousLowerRound is null');
+                if (!nextLowerRound)
+                    throw new Error('nextLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                roundRelations.set(currentLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: previousLowerRound,
+                    nextRound: nextLowerRound,
+                    currentRound: currentLowerRound,
+                    nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,
+                    previousRoundMatchFactor: previousLowerRound.matchCount / currentLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / currentLowerRound.matchCount,
+                });
+            }
+        }
+    }
+    return roundRelations;
+};
+export const generateMatchRelations = (bracketData, roundRelations, matchPositionMaps) => {
+    const matchRelations = new Map();
+    for (const match of bracketData.matches.values()) {
+        const currentRelation = roundRelations.get(match.round.id);
+        if (!currentRelation)
+            throw new Error('Match round not found');
+        const { nextRoundMatchPosition, previousLowerRoundMatchPosition, previousUpperRoundMatchPosition } = generateMatchRelationPositions(currentRelation, match);
+        switch (currentRelation.type) {
+            case 'nothing-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                // means left is nothing. right is one
+                matchRelations.set(match.id, {
+                    type: 'nothing-to-one',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    nextRound: currentRelation.nextRound,
+                    nextMatch,
+                });
+                break;
+            }
+            case 'one-to-nothing': {
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!previousUpperMatch)
+                    throw new Error('Previous round match not found');
+                if (previousUpperRoundMatchPosition !== previousLowerRoundMatchPosition) {
+                    // means left is two. right is one
+                    if (!previousLowerMatch)
+                        throw new Error('Previous lower round match not found');
+                    matchRelations.set(match.id, {
+                        type: 'two-to-nothing',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousUpperMatch,
+                        previousUpperRound: currentRelation.previousRound,
+                        previousLowerMatch,
+                        previousLowerRound: currentRelation.previousRound,
+                    });
+                }
+                else {
+                    // means left is one. right is nothing
+                    matchRelations.set(match.id, {
+                        type: 'one-to-nothing',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousMatch: previousUpperMatch,
+                        previousRound: currentRelation.previousRound,
+                    });
+                }
+                break;
+            }
+            case 'one-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                // can be either one to one or two to one
+                const isLeftOne = previousUpperRoundMatchPosition === previousLowerRoundMatchPosition;
+                if (isLeftOne) {
+                    // one-to-one
+                    matchRelations.set(match.id, {
+                        type: 'one-to-one',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousMatch: previousUpperMatch,
+                        previousRound: currentRelation.previousRound,
+                        nextMatch,
+                        nextRound: currentRelation.nextRound,
+                    });
+                }
+                else {
+                    // two-to-one
+                    matchRelations.set(match.id, {
+                        type: 'two-to-one',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousUpperMatch,
+                        previousUpperRound: currentRelation.previousRound,
+                        previousLowerMatch,
+                        previousLowerRound: currentRelation.previousRound,
+                        nextMatch,
+                        nextRound: currentRelation.nextRound,
+                    });
+                }
+                break;
+            }
+            case 'two-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousLowerRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                matchRelations.set(match.id, {
+                    type: 'two-to-one',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    previousUpperMatch,
+                    previousUpperRound: currentRelation.previousUpperRound,
+                    previousLowerMatch,
+                    previousLowerRound: currentRelation.previousLowerRound,
+                    nextMatch,
+                    nextRound: currentRelation.nextRound,
+                });
+                break;
+            }
+            case 'two-to-nothing': {
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                matchRelations.set(match.id, {
+                    type: 'two-to-nothing',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    previousUpperMatch,
+                    previousUpperRound: currentRelation.previousUpperRound,
+                    previousLowerMatch,
+                    previousLowerRound: currentRelation.previousUpperRound,
+                });
+                break;
+            }
+        }
+    }
+    return matchRelations;
+};
+export const generateMatchRelationPositions = (currentRelation, match) => {
+    switch (currentRelation.type) {
+        case 'nothing-to-one': {
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousLowerRoundMatchPosition: FALLBACK_MATCH_POSITION,
+            };
+        }
+        case 'one-to-nothing': {
+            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
+            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            return {
+                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
+                    doubleUpperMatchCountShift),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+            };
+        }
+        case 'one-to-one': {
+            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
+            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
+                    doubleUpperMatchCountShift),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+            };
+        }
+        case 'two-to-one': {
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+            };
+        }
+        case 'two-to-nothing': {
+            return {
+                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+            };
+        }
+    }
+};
+export const generateMatchPosition = (match, factor) => {
+    return Math.ceil(match.position * factor);
+};
+export const logRoundRelations = (roundRelations, bracketData) => {
+    for (const [roundId, relation] of roundRelations.entries()) {
+        const round = bracketData.rounds.get(roundId);
+        if (!round) {
+            console.error(`Round with id ${roundId} not found in bracket data. The bracket will be malformed.`);
+            continue;
+        }
+        switch (relation.type) {
+            case 'nothing-to-one':
+                console.log(`START: ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'one-to-nothing':
+                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ENDING: ${round.name}`);
+                break;
+            case 'one-to-one':
+                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'two-to-one':
+                console.log(`MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'two-to-nothing':
+                console.log(`MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ENDING: ${round.name}`);
+                break;
+        }
+    }
+};
+export const generateMatchParticipantMap = (bracketData) => {
+    const matchParticipantMap = new Map();
+    const hasElimination = bracketData.mode === TOURNAMENT_MODE.SINGLE_ELIMINATION ||
+        bracketData.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ||
+        bracketData.mode === TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
+    for (const participant of bracketData.participants.values()) {
+        let winsTilNow = 0;
+        let lossesTilNow = 0;
+        let tiesTilNow = 0;
+        for (const matchParticipantMatch of participant.matches.values()) {
+            const isWinner = matchParticipantMatch.bracketMatch.winner === matchParticipantMatch.side;
+            const isLooser = matchParticipantMatch.bracketMatch.winner &&
+                matchParticipantMatch.bracketMatch.winner !== matchParticipantMatch.side;
+            const isTie = matchParticipantMatch.bracketMatch.status === 'completed' && !matchParticipantMatch.bracketMatch.winner;
+            if (isWinner) {
+                winsTilNow++;
+            }
+            else if (isLooser) {
+                lossesTilNow++;
+            }
+            else if (isTie) {
+                tiesTilNow++;
+            }
+            let isEliminated = false;
+            let isEliminationMatch = false;
+            if (hasElimination) {
+                // TODO: Implement elimination logic
+                // Means the current match is loss and it's the last match of the participant
+                isEliminated = false;
+                // Always true for single elimination, never for e.g. groups, depends on the round for double elimination, depends on the loss count for swiss with elimination
+                isEliminationMatch = false;
+            }
+            // TODO: Implement round logic
+            // true if its the first round of the bracket
+            const isFirstRound = false;
+            // true if its the last round of the bracket (eg. final for single elimination)
+            const isLastRound = false;
+            const participantMatchData = {
+                bracketMatch: matchParticipantMatch.bracketMatch,
+                result: isWinner ? 'win' : isLooser ? 'loss' : isTie ? 'tie' : null,
+                isEliminated,
+                isEliminationMatch,
+                isFirstRound,
+                isLastRound,
+                tieCount: tiesTilNow,
+                winCount: winsTilNow,
+                lossCount: lossesTilNow,
+            };
+            if (!matchParticipantMap.has(participant.id)) {
+                matchParticipantMap.set(participant.id, {
+                    id: participant.id,
+                    name: participant.name,
+                    matches: new Map(),
+                });
+            }
+            const participantData = matchParticipantMap.get(participant.id);
+            participantData.matches.set(matchParticipantMatch.bracketMatch.id, participantMatchData);
+        }
+    }
+    return matchParticipantMap;
+};
+const factorialCache = new Map();
+export const getAvailableSwissGroupsForRound = (roundNumber, totalMatchesInRound) => {
+    const ADVANCE_WINS = 3;
+    const ELIMINATE_LOSSES = 3;
+    // Cache factorial calculations
+    const getFactorial = (n) => {
+        if (n <= 1)
+            return 1;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (factorialCache.has(n))
+            return factorialCache.get(n);
+        const result = n * getFactorial(n - 1);
+        factorialCache.set(n, result);
+        return result;
+    };
+    // Pre-calculate roundFactorial
+    const roundFact = getFactorial(roundNumber);
+    let totalCombinations = 0;
+    const validGroups = [];
+    // Single loop to gather valid groups and total combinations
+    for (let wins = roundNumber; wins >= 0; wins--) {
+        const losses = roundNumber - wins;
+        const remainingGames = ADVANCE_WINS + ELIMINATE_LOSSES - (wins + losses) - 1;
+        const notYetEliminated = losses < ELIMINATE_LOSSES;
+        const canStillAdvance = wins < ADVANCE_WINS && remainingGames >= 0;
+        if (!canStillAdvance || !notYetEliminated)
+            continue;
+        const combinations = roundFact / (getFactorial(wins) * getFactorial(losses));
+        totalCombinations += combinations;
+        validGroups.push({ wins, losses, combinations });
+    }
+    // Create final groups with calculated proportions
+    return validGroups.map(({ wins, losses, combinations }) => ({
+        id: `${wins}-${losses}`,
+        name: `${wins}-${losses}`,
+        matchesInGroup: Math.round((combinations / totalCombinations) * totalMatchesInRound),
+    }));
+};
+export const generateBracketRoundSwissGroupMaps = (bracketData, matchParticipantMap) => {
+    if (bracketData.mode !== TOURNAMENT_MODE.SWISS_WITH_ELIMINATION) {
+        return null;
+    }
+    const roundsWithSwissGroups = new Map();
+    let roundNumber = 0;
+    for (const bracketRound of bracketData.rounds.values()) {
+        const availableGroups = getAvailableSwissGroupsForRound(roundNumber, bracketRound.matchCount);
+        const roundSwissData = {
+            groups: new Map(),
+        };
+        for (const group of availableGroups) {
+            const subGroup = {
+                id: group.id,
+                name: group.name,
+                matches: new Map(),
+                allowedMatchCount: group.matchesInGroup,
+            };
+            roundSwissData.groups.set(group.id, subGroup);
+        }
+        const emptyMatchIds = [];
+        for (const match of bracketRound.matches.values()) {
+            const participantHome = match.home ? (matchParticipantMap.get(match.home) ?? null) : null;
+            const participantAway = match.away ? (matchParticipantMap.get(match.away) ?? null) : null;
+            const anyParticipant = participantHome || participantAway;
+            if (!anyParticipant) {
+                emptyMatchIds.push(match.id);
+                continue;
+            }
+            const matchParticipantMatch = anyParticipant.matches.get(match.id);
+            if (!matchParticipantMatch)
+                throw new Error('Match participant match not found');
+            const wins = matchParticipantMatch.winCount;
+            const losses = matchParticipantMatch.lossCount;
+            const group = roundSwissData.groups.get(`${wins}-${losses}`);
+            if (!group)
+                throw new Error('Group not found for match: ' + match.id);
+            group.matches.set(match.id, match);
+        }
+        for (const emptyMatchId of emptyMatchIds) {
+            const match = bracketRound.matches.get(emptyMatchId);
+            if (!match)
+                throw new Error('Empty match not found');
+            let groupFound = false;
+            for (const group of roundSwissData.groups.values()) {
+                if (group.matches.size < group.allowedMatchCount) {
+                    group.matches.set(match.id, match);
+                    groupFound = true;
+                    break;
+                }
+            }
+            if (!groupFound) {
+                throw new Error('No group found for empty match');
+            }
+        }
+        roundNumber++;
+    }
+    return roundsWithSwissGroups;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bracket-new.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/bracket/components/new-bracket/bracket-new.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  MatchListViewUnion,\n  OpponentSide,\n  RoundStageStructureView,\n  RoundStageStructureWithMatchesView,\n  RoundType,\n} from '@ethlete/types';\n\nexport type BracketRoundId = string & { __brand: 'BracketRoundId' };\nexport type BracketMatchId = string & { __brand: 'BracketMatchId' };\nexport type BracketRoundPosition = number & { __brand: 'BracketRoundPosition' };\nexport type BracketMatchPosition = number & { __brand: 'BracketMatchPosition' };\nexport type MatchParticipantId = string & { __brand: 'MatchParticipantId' };\nexport type BracketRoundSwissGroupId = string & { __brand: 'BracketRoundSwissGroupId' };\n\n// Will usually be 0.5, 1 or 2. In Swiss this value will be gibberish\nexport type MatchFactor = number;\n\nexport const FALLBACK_MATCH_POSITION = -1 as BracketMatchPosition;\n\nexport const TOURNAMENT_MODE = {\n  SINGLE_ELIMINATION: 'single-elimination',\n  DOUBLE_ELIMINATION: 'double-elimination',\n  GROUP: 'group',\n  SWISS: 'swiss',\n  SWISS_WITH_ELIMINATION: 'swiss-with-elimination',\n} as const;\n\nexport type TournamentMode = (typeof TOURNAMENT_MODE)[keyof typeof TOURNAMENT_MODE];\n\nexport const COMMON_BRACKET_ROUND_TYPE = {\n  THIRD_PLACE: 'third-place',\n  FINAL: 'final',\n} as const;\n\nexport const SINGLE_ELIMINATION_BRACKET_ROUND_TYPE = {\n  SINGLE_ELIMINATION_BRACKET: 'single-elimination-bracket',\n} as const;\n\nexport const DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE = {\n  UPPER_BRACKET: 'upper-bracket',\n  LOWER_BRACKET: 'lower-bracket',\n  REVERSE_FINAL: 'reverse-final',\n} as const;\n\nexport const SWISS_BRACKET_ROUND_TYPE = {\n  SWISS: 'swiss',\n} as const;\n\nexport const GROUP_BRACKET_ROUND_TYPE = {\n  GROUP: 'group',\n} as const;\n\nexport type CommonBracketRoundType = (typeof COMMON_BRACKET_ROUND_TYPE)[keyof typeof COMMON_BRACKET_ROUND_TYPE];\nexport type SingleEliminationBracketRoundType =\n  | CommonBracketRoundType\n  | (typeof SINGLE_ELIMINATION_BRACKET_ROUND_TYPE)[keyof typeof SINGLE_ELIMINATION_BRACKET_ROUND_TYPE];\nexport type DoubleEliminationBracketRoundType =\n  | CommonBracketRoundType\n  | (typeof DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE)[keyof typeof DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE];\nexport type SwissBracketRoundType = (typeof SWISS_BRACKET_ROUND_TYPE)[keyof typeof SWISS_BRACKET_ROUND_TYPE];\nexport type GroupBracketRoundType = (typeof GROUP_BRACKET_ROUND_TYPE)[keyof typeof GROUP_BRACKET_ROUND_TYPE];\n\nexport type BracketRoundType =\n  | SingleEliminationBracketRoundType\n  | DoubleEliminationBracketRoundType\n  | SwissBracketRoundType\n  | GroupBracketRoundType;\n\nexport type BracketRound<TRoundData, TMatchData> = {\n  // NOTE: This is the logical index inside the bracket.\n  // In a double elimination bracket, the first round of the lower bracket will have the same index as the final round of the upper bracket\n  index: number;\n  type: BracketRoundType;\n  id: BracketRoundId;\n  data: TRoundData;\n  position: BracketRoundPosition;\n  name: string;\n  matchCount: number;\n  matches: BracketMatchMap<TRoundData, TMatchData>;\n};\n\nexport type BracketMatchStatus = 'completed' | 'pending';\n\nexport type BracketMatch<TRoundData, TMatchData> = {\n  data: TMatchData;\n  indexInRound: number;\n  id: BracketMatchId;\n  round: BracketRound<TRoundData, TMatchData>;\n  position: BracketMatchPosition;\n  home: MatchParticipantId | null;\n  away: MatchParticipantId | null;\n  winner: OpponentSide | null;\n  status: BracketMatchStatus;\n};\n\nexport type BracketRoundMap<TRoundData, TMatchData> = Map<BracketRoundId, BracketRound<TRoundData, TMatchData>>;\nexport type BracketMatchMap<TRoundData, TMatchData> = Map<BracketMatchId, BracketMatch<TRoundData, TMatchData>>;\n\nexport type BracketData<TRoundData, TMatchData> = {\n  rounds: BracketRoundMap<TRoundData, TMatchData>;\n  matches: BracketMatchMap<TRoundData, TMatchData>;\n  participants: BracketParticipantMap<TRoundData, TMatchData>;\n  mode: TournamentMode;\n};\n\nexport type AnyBracketData = BracketData<unknown, unknown>;\n\n// One match has one previous match and one next match (this would be the case, if a group tournament is being displayed via a bracket)\nexport type BracketMatchRelationOneToOne<TRoundData, TMatchData> = {\n  type: 'one-to-one';\n  currentMatch: BracketMatch<TRoundData, TMatchData>;\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousMatch: BracketMatch<TRoundData, TMatchData>;\n  previousRound: BracketRound<TRoundData, TMatchData>;\n  nextMatch: BracketMatch<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n};\n\n// The match has no previous match but a single next match (eg. the start of the bracket)\nexport type BracketMatchRelationNothingToOne<TRoundData, TMatchData> = {\n  type: 'nothing-to-one';\n  currentMatch: BracketMatch<TRoundData, TMatchData>;\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  nextMatch: BracketMatch<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n};\n\n// The match has no next match but a single previous match (eg. reverse finals)\nexport type BracketMatchRelationOneToNothing<TRoundData, TMatchData> = {\n  type: 'one-to-nothing';\n  currentMatch: BracketMatch<TRoundData, TMatchData>;\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousMatch: BracketMatch<TRoundData, TMatchData>;\n  previousRound: BracketRound<TRoundData, TMatchData>;\n};\n\n// The match has two previous matches and one next match (eg. a normal match in the bracket that is neither the start nor the end)\nexport type BracketMatchRelationTwoToOne<TRoundData, TMatchData> = {\n  type: 'two-to-one';\n  currentMatch: BracketMatch<TRoundData, TMatchData>;\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousUpperMatch: BracketMatch<TRoundData, TMatchData>;\n  previousUpperRound: BracketRound<TRoundData, TMatchData>;\n  previousLowerMatch: BracketMatch<TRoundData, TMatchData>;\n  previousLowerRound: BracketRound<TRoundData, TMatchData>;\n  nextMatch: BracketMatch<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n};\n\n// The match has two previous matches and no next match (eg. the finals in a single elimination bracket)\nexport type BracketMatchRelationTwoToNothing<TRoundData, TMatchData> = {\n  type: 'two-to-nothing';\n  currentMatch: BracketMatch<TRoundData, TMatchData>;\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousUpperMatch: BracketMatch<TRoundData, TMatchData>;\n  previousUpperRound: BracketRound<TRoundData, TMatchData>;\n  previousLowerMatch: BracketMatch<TRoundData, TMatchData>;\n  previousLowerRound: BracketRound<TRoundData, TMatchData>;\n};\n\nexport type BracketMatchRelation<TRoundData, TMatchData> =\n  | BracketMatchRelationOneToOne<TRoundData, TMatchData>\n  | BracketMatchRelationTwoToOne<TRoundData, TMatchData>\n  | BracketMatchRelationNothingToOne<TRoundData, TMatchData>\n  | BracketMatchRelationOneToNothing<TRoundData, TMatchData>\n  | BracketMatchRelationTwoToNothing<TRoundData, TMatchData>;\n\nexport type BracketMatchRelationsMap<TRoundData, TMatchData> = Map<\n  BracketMatchId,\n  BracketMatchRelation<TRoundData, TMatchData>\n>;\n\n// One round has one next round (the first round of the bracket)\nexport type BracketRoundRelationNothingToOne<TRoundData, TMatchData> = {\n  type: 'nothing-to-one';\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n  nextRoundMatchFactor: number;\n};\n\n// One round has one previous round (eg. the finals round of the bracket in case of a single elimination bracket)\nexport type BracketRoundRelationOneToNothing<TRoundData, TMatchData> = {\n  type: 'one-to-nothing';\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousRound: BracketRound<TRoundData, TMatchData>;\n  previousRoundMatchFactor: number;\n  rootRoundMatchFactor: number;\n};\n\n// One round has one previous round and one next round (eg. a normal round in the bracket that is neither the start nor the end)\nexport type BracketRoundRelationOneToOne<TRoundData, TMatchData> = {\n  type: 'one-to-one';\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousRound: BracketRound<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n  nextRoundMatchFactor: number;\n  previousRoundMatchFactor: number;\n  rootRoundMatchFactor: number;\n};\n\n// One round has two previous rounds and one next round (eg. the finals round in a double elimination bracket when the reverse finals is also being played)\nexport type BracketRoundRelationTwoToOne<TRoundData, TMatchData> = {\n  type: 'two-to-one';\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousUpperRound: BracketRound<TRoundData, TMatchData>;\n  previousLowerRound: BracketRound<TRoundData, TMatchData>;\n  nextRound: BracketRound<TRoundData, TMatchData>;\n  nextRoundMatchFactor: number;\n  previousUpperRoundMatchFactor: number;\n  previousLowerRoundMatchFactor: number;\n  upperRootRoundMatchFactor: number;\n  lowerRootRoundMatchFactor: number;\n};\n\n// One round has two previous rounds and no next round (eg. the finals round in a double elimination bracket when the reverse finals is not being played)\nexport type BracketRoundRelationTwoToNothing<TRoundData, TMatchData> = {\n  type: 'two-to-nothing';\n  currentRound: BracketRound<TRoundData, TMatchData>;\n  previousUpperRound: BracketRound<TRoundData, TMatchData>;\n  previousLowerRound: BracketRound<TRoundData, TMatchData>;\n  previousUpperRoundMatchFactor: number;\n  previousLowerRoundMatchFactor: number;\n  upperRootRoundMatchFactor: number;\n  lowerRootRoundMatchFactor: number;\n};\n\nexport type BracketRoundRelation<TRoundData, TMatchData> =\n  | BracketRoundRelationNothingToOne<TRoundData, TMatchData>\n  | BracketRoundRelationOneToNothing<TRoundData, TMatchData>\n  | BracketRoundRelationOneToOne<TRoundData, TMatchData>\n  | BracketRoundRelationTwoToOne<TRoundData, TMatchData>\n  | BracketRoundRelationTwoToNothing<TRoundData, TMatchData>;\n\nexport type BracketRoundRelations<TRoundData, TMatchData> = Map<\n  BracketRoundId,\n  BracketRoundRelation<TRoundData, TMatchData>\n>;\n\nexport type MatchPositionMaps<TRoundData, TMatchData> = Map<\n  BracketRoundId,\n  Map<BracketMatchPosition, BracketMatch<TRoundData, TMatchData>>\n>;\n\nexport type ParticipantMatchResult = 'win' | 'loss' | 'tie';\nexport type ParticipantMatchType = BracketRoundType;\n\nexport type MatchParticipantMatch<TRoundData, TMatchData> = {\n  bracketMatch: BracketMatch<TRoundData, TMatchData>;\n  result: ParticipantMatchResult | null;\n  isEliminated: boolean;\n  isEliminationMatch: boolean;\n  isFirstRound: boolean;\n  isLastRound: boolean;\n  tieCount: number;\n  winCount: number;\n  lossCount: number;\n};\n\nexport type MatchParticipant<TRoundData, TMatchData> = {\n  id: MatchParticipantId;\n  name: string;\n  matches: Map<BracketMatchId, MatchParticipantMatch<TRoundData, TMatchData>>;\n};\n\nexport type BracketParticipantMatch<TRoundData, TMatchData> = {\n  side: OpponentSide;\n  bracketMatch: BracketMatch<TRoundData, TMatchData>;\n};\n\nexport type BracketParticipant<TRoundData, TMatchData> = {\n  id: MatchParticipantId;\n  name: string;\n  matches: Map<BracketMatchId, BracketParticipantMatch<TRoundData, TMatchData>>;\n};\n\nexport type BracketParticipantMap<TRoundData, TMatchData> = Map<\n  MatchParticipantId,\n  BracketParticipant<TRoundData, TMatchData>\n>;\n\nexport type MatchParticipantMap<TRoundData, TMatchData> = Map<\n  MatchParticipantId,\n  MatchParticipant<TRoundData, TMatchData>\n>;\n\nexport type BracketRoundSwissGroup<TRoundData, TMatchData> = {\n  id: BracketRoundSwissGroupId;\n  name: string;\n  matches: BracketMatchMap<TRoundData, TMatchData>;\n  allowedMatchCount: number;\n};\n\nexport type BracketRoundSwissGroupMap<TRoundData, TMatchData> = Map<\n  BracketRoundSwissGroupId,\n  BracketRoundSwissGroup<TRoundData, TMatchData>\n>;\n\nexport type BracketRoundSwissData<TRoundData, TMatchData> = {\n  groups: BracketRoundSwissGroupMap<TRoundData, TMatchData>;\n};\n\nexport type BracketRoundMapWithSwissData<TRoundData, TMatchData> = Map<\n  BracketRoundId,\n  BracketRoundSwissData<TRoundData, TMatchData>\n>;\n\nexport type BracketRoundTypeMap<TRoundData, TMatchData> = Map<\n  BracketRoundType,\n  BracketRoundMap<TRoundData, TMatchData>\n>;\n\nexport const generateRoundTypeFromEthleteRoundType = (\n  type: RoundType,\n  tournamentMode: TournamentMode,\n): BracketRoundType => {\n  switch (type) {\n    case 'normal':\n      switch (tournamentMode) {\n        case 'single-elimination':\n          return SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET;\n        case 'group':\n          return GROUP_BRACKET_ROUND_TYPE.GROUP;\n        case 'swiss':\n          return SWISS_BRACKET_ROUND_TYPE.SWISS;\n        default:\n          throw new Error(`Unsupported tournament mode for a normal type round: ${tournamentMode}`);\n      }\n    case 'third_place':\n      return COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE;\n    case 'final':\n      return COMMON_BRACKET_ROUND_TYPE.FINAL;\n    case 'reverse_final':\n      return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL;\n    case 'winner_bracket':\n      return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;\n    case 'loser_bracket':\n      return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;\n  }\n};\n\nexport const generateTournamentModeFormEthleteRounds = (\n  source: RoundStageStructureWithMatchesView[],\n): TournamentMode => {\n  const firstRound = source[0];\n  const firstMatch = firstRound?.matches[0];\n\n  if (!firstRound) throw new Error('No rounds found');\n  if (!firstMatch) throw new Error('No matches found');\n\n  switch (firstMatch.matchType) {\n    case 'groups':\n      return TOURNAMENT_MODE.GROUP;\n    case 'fifa_swiss': {\n      const lastRound = source[source.length - 1];\n\n      if (!lastRound) throw new Error('No last round found');\n\n      if (lastRound.matches.length !== firstRound.matches.length) {\n        return TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;\n      } else {\n        return TOURNAMENT_MODE.SWISS;\n      }\n    }\n    case 'double_elimination':\n      return TOURNAMENT_MODE.DOUBLE_ELIMINATION;\n    case 'single_elimination':\n      return TOURNAMENT_MODE.SINGLE_ELIMINATION;\n    default:\n      throw new Error(`Unsupported tournament mode: ${firstMatch.matchType}`);\n  }\n};\n\nexport const generateBracketDataForEthlete = (source: RoundStageStructureWithMatchesView[]) => {\n  const tournamentMode = generateTournamentModeFormEthleteRounds(source);\n\n  const bracketData: BracketData<RoundStageStructureView, MatchListViewUnion> = {\n    rounds: new Map(),\n    matches: new Map(),\n    participants: new Map(),\n    mode: tournamentMode,\n  };\n\n  let currentUpperBracketIndex = 0;\n  let currentLowerBracketIndex = 0;\n\n  for (const currentItem of source) {\n    if (bracketData.rounds.has(currentItem.round.id as BracketRoundId)) {\n      throw new Error(`Round with id ${currentItem.round.id} already exists in the bracket data.`);\n    }\n\n    const roundType = generateRoundTypeFromEthleteRoundType(currentItem.round.type, tournamentMode);\n    const isLowerBracket = roundType === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;\n\n    const bracketRound: BracketRound<RoundStageStructureView, MatchListViewUnion> = {\n      type: roundType,\n      id: currentItem.round.id as BracketRoundId,\n      index: isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex,\n      data: currentItem.round,\n      position: currentItem.round.number as BracketRoundPosition,\n      name: currentItem.round.name || currentItem.round.type,\n      matchCount: currentItem.matches.length,\n      matches: new Map(),\n    };\n\n    bracketData.rounds.set(currentItem.round.id as BracketRoundId, bracketRound);\n\n    for (const [matchIndex, match] of currentItem.matches.entries()) {\n      if (bracketData.matches.has(match.id as BracketMatchId)) {\n        throw new Error(`Match with id ${match.id} already exists in the bracket data.`);\n      }\n\n      const bracketMatch: BracketMatch<RoundStageStructureView, MatchListViewUnion> = {\n        id: match.id as BracketMatchId,\n        indexInRound: matchIndex,\n        position: (matchIndex + 1) as BracketMatchPosition,\n        data: match,\n        round: bracketRound,\n        home: (match.home?.id as MatchParticipantId) || null,\n        away: (match.away?.id as MatchParticipantId) || null,\n        winner: match.winningSide,\n        status: match.status === 'published' ? 'completed' : 'pending',\n      };\n\n      bracketData.matches.set(match.id as BracketMatchId, bracketMatch);\n      bracketRound.matches.set(match.id as BracketMatchId, bracketMatch);\n\n      const participants = [match.home, match.away];\n\n      for (const participant of participants) {\n        if (!participant) continue;\n\n        const participantId = participant.id as MatchParticipantId;\n\n        if (!bracketData.participants.has(participantId)) {\n          bracketData.participants.set(participantId, {\n            id: participantId,\n            name: participant.name || 'Unknown',\n            matches: new Map(),\n          });\n        }\n\n        const participantData = bracketData.participants.get(participantId) as BracketParticipant<\n          RoundStageStructureView,\n          MatchListViewUnion\n        >;\n\n        if (!participantData.matches.has(match.id as BracketMatchId)) {\n          participantData.matches.set(match.id as BracketMatchId, {\n            side: match.home?.id === participantId ? 'home' : 'away',\n            bracketMatch,\n          });\n        }\n      }\n    }\n\n    if (isLowerBracket) {\n      currentLowerBracketIndex++;\n    } else {\n      currentUpperBracketIndex++;\n    }\n  }\n\n  return bracketData;\n};\n\nexport const generateMatchPositionMaps = <TRoundData, TMatchData>(bracketData: BracketData<TRoundData, TMatchData>) => {\n  const matchPositionMaps: MatchPositionMaps<TRoundData, TMatchData> = new Map();\n\n  for (const round of bracketData.rounds.values()) {\n    const matchMap = new Map([...round.matches.values()].map((m) => [m.position, m]));\n\n    matchPositionMaps.set(round.id, matchMap);\n  }\n\n  return matchPositionMaps;\n};\n\nexport const generateBracketRoundTypeMap = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n) => {\n  const roundAmountMap: BracketRoundTypeMap<TRoundData, TMatchData> = new Map();\n\n  for (const round of bracketData.rounds.values()) {\n    if (!roundAmountMap.has(round.type)) {\n      roundAmountMap.set(round.type, new Map([[round.id, round]]));\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      roundAmountMap.set(round.type, roundAmountMap.get(round.type)!.set(round.id, round));\n    }\n  }\n\n  return roundAmountMap;\n};\n\nconst UPPER_LOOP_ORDER: BracketRoundType[] = [\n  SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET,\n  DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET,\n  SWISS_BRACKET_ROUND_TYPE.SWISS,\n  GROUP_BRACKET_ROUND_TYPE.GROUP,\n  COMMON_BRACKET_ROUND_TYPE.FINAL,\n  DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL,\n  COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE,\n];\n\nconst LOWER_LOOP_ORDER: BracketRoundType[] = [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET];\n\nexport const generateRoundRelations = <TRoundData, TMatchData>(bracketData: BracketData<TRoundData, TMatchData>) => {\n  const roundRelations: BracketRoundRelations<TRoundData, TMatchData> = new Map();\n\n  const sortedRoundsByType = new Map<BracketRoundType, BracketRound<TRoundData, TMatchData>[]>();\n\n  for (const round of bracketData.rounds.values()) {\n    if (!sortedRoundsByType.has(round.type)) {\n      sortedRoundsByType.set(round.type, [round]);\n    } else {\n      sortedRoundsByType.get(round.type)?.push(round);\n    }\n  }\n\n  for (const rounds of sortedRoundsByType.values()) {\n    if (rounds.length === 1) continue;\n\n    rounds.sort((a, b) => a.position - b.position);\n  }\n\n  const sortedUpperRounds = UPPER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))\n    .filter((r) => !!r)\n    .flat();\n  const sortedLowerRounds = LOWER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))\n    .filter((r) => !!r)\n    .flat();\n\n  const firstUpperRound = sortedUpperRounds[0] || null;\n  const firstLowerRound = sortedLowerRounds[0] || null;\n\n  if (!firstUpperRound) throw new Error('firstUpperRound is null');\n\n  const hasLowerRounds = sortedLowerRounds.length > 0;\n  const lastLowerRound = sortedLowerRounds[sortedLowerRounds.length - 1] || null;\n\n  for (const [currentUpperRoundIndex, currentUpperRound] of sortedUpperRounds.entries()) {\n    const previousUpperRound = sortedUpperRounds[currentUpperRoundIndex - 1] || null;\n    const nextUpperRound = sortedUpperRounds[currentUpperRoundIndex + 1] || null;\n\n    const currentLowerRound = sortedLowerRounds[currentUpperRoundIndex] || null;\n    const previousLowerRound = sortedLowerRounds[currentUpperRoundIndex - 1] || null;\n    const nextLowerRound = sortedLowerRounds[currentUpperRoundIndex + 1] || null;\n\n    const isFirstRound = currentUpperRoundIndex === 0;\n    const isLastUpperRound = currentUpperRoundIndex === sortedUpperRounds.length - 1;\n\n    const isFinal = currentUpperRound.type === COMMON_BRACKET_ROUND_TYPE.FINAL;\n\n    if (isFinal && hasLowerRounds) {\n      // two to one relation\n\n      if (!lastLowerRound || !currentLowerRound || !previousUpperRound)\n        throw new Error('lastLowerRound or currentLowerRound or previousUpperRound is null');\n\n      // in a sync double elimination bracket, the final round has the same index as the last lower round\n      // in an async one, there is always one more round in the lower bracket since we only display a section of the whole tournament\n      const isAsyncBracket = currentLowerRound.id !== lastLowerRound.id;\n      const finalLowerRound = isAsyncBracket ? nextLowerRound : currentLowerRound;\n\n      if (!finalLowerRound) throw new Error('finalLowerRound is null');\n      if (!firstLowerRound) throw new Error('firstLowerRound is null');\n\n      if (finalLowerRound.id !== lastLowerRound.id) throw new Error('finalLowerRound is not the last lower round');\n\n      // if we have a reverse final\n      if (nextUpperRound) {\n        // for the final\n        roundRelations.set(currentUpperRound.id, {\n          type: 'two-to-one',\n          previousUpperRound: previousUpperRound,\n          previousLowerRound: finalLowerRound,\n          nextRound: nextUpperRound,\n          currentRound: currentUpperRound,\n          nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,\n          previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,\n          previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,\n          upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,\n          lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,\n        });\n      } else {\n        // no reverse final means the final is the last round\n\n        // for the final\n        roundRelations.set(currentUpperRound.id, {\n          type: 'two-to-nothing',\n          previousUpperRound: previousUpperRound,\n          previousLowerRound: finalLowerRound,\n          currentRound: currentUpperRound,\n          previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,\n          previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,\n          lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,\n          upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,\n        });\n      }\n\n      if (isAsyncBracket) {\n        // if this is an async bracket, we need to set the relations for the 2 last lower rounds since they will be skipped by the default one to one logic\n        const preFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 2] || null;\n        const prePreFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 3] || null;\n\n        if (!preFinalLowerRound) throw new Error('preFinalLowerRound is null');\n\n        if (!firstLowerRound) throw new Error('firstLowerRound is null');\n\n        // for the last lower round\n        roundRelations.set(finalLowerRound.id, {\n          type: 'one-to-one',\n          previousRound: preFinalLowerRound,\n          nextRound: currentUpperRound,\n          currentRound: finalLowerRound,\n          nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,\n          previousRoundMatchFactor: preFinalLowerRound.matchCount / finalLowerRound.matchCount,\n          rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,\n        });\n\n        if (prePreFinalLowerRound) {\n          // for the pre final lower round\n          roundRelations.set(preFinalLowerRound.id, {\n            type: 'one-to-one',\n            previousRound: prePreFinalLowerRound,\n            nextRound: finalLowerRound,\n            currentRound: preFinalLowerRound,\n            nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,\n            previousRoundMatchFactor: prePreFinalLowerRound.matchCount / preFinalLowerRound.matchCount,\n            rootRoundMatchFactor: firstLowerRound.matchCount / preFinalLowerRound.matchCount,\n          });\n        } else {\n          // for the first lower round\n          roundRelations.set(preFinalLowerRound.id, {\n            type: 'nothing-to-one',\n            nextRound: finalLowerRound,\n            currentRound: preFinalLowerRound,\n            nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,\n          });\n        }\n      } else {\n        // this is a sync bracket, we only need to set the relation for the last lower round\n        if (!previousLowerRound) throw new Error('previousLowerRound is null');\n        if (!firstLowerRound) throw new Error('firstLowerRound is null');\n\n        // for the last lower round\n        roundRelations.set(finalLowerRound.id, {\n          type: 'one-to-one',\n          previousRound: previousLowerRound,\n          nextRound: currentUpperRound,\n          currentRound: finalLowerRound,\n          nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,\n          previousRoundMatchFactor: previousLowerRound.matchCount / finalLowerRound.matchCount,\n          rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,\n        });\n      }\n    } else if (isLastUpperRound) {\n      // one to nothing relation\n\n      if (!previousUpperRound) throw new Error('previousUpperRound is null');\n\n      roundRelations.set(currentUpperRound.id, {\n        type: 'one-to-nothing',\n        previousRound: previousUpperRound,\n        currentRound: currentUpperRound,\n        previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,\n        rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,\n      });\n    } else if (isFirstRound) {\n      // nothing to one relation\n\n      if (!nextUpperRound) throw new Error('nextUpperRound is null');\n\n      roundRelations.set(currentUpperRound.id, {\n        type: 'nothing-to-one',\n        nextRound: nextUpperRound,\n        currentRound: currentUpperRound,\n        nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,\n      });\n\n      if (currentLowerRound) {\n        if (!nextLowerRound) throw new Error('nextLowerRound is null');\n\n        roundRelations.set(currentLowerRound.id, {\n          type: 'nothing-to-one',\n          nextRound: nextLowerRound,\n          currentRound: currentLowerRound,\n          nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,\n        });\n      }\n    } else {\n      // one to one relation\n\n      if (!previousUpperRound) throw new Error('previousUpperRound is null');\n      if (!nextUpperRound) throw new Error('nextUpperRound is null');\n\n      roundRelations.set(currentUpperRound.id, {\n        type: 'one-to-one',\n        previousRound: previousUpperRound,\n        nextRound: nextUpperRound,\n        currentRound: currentUpperRound,\n        nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,\n        previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,\n        rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,\n      });\n\n      // we only want to set lower rounds here until the special merging point of the final.\n      // lower bracket rounds after and including the final will be set in the final round block\n      if (currentLowerRound && currentUpperRound.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET) {\n        if (!previousLowerRound) throw new Error('previousLowerRound is null');\n        if (!nextLowerRound) throw new Error('nextLowerRound is null');\n        if (!firstLowerRound) throw new Error('firstLowerRound is null');\n\n        roundRelations.set(currentLowerRound.id, {\n          type: 'one-to-one',\n          previousRound: previousLowerRound,\n          nextRound: nextLowerRound,\n          currentRound: currentLowerRound,\n          nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,\n          previousRoundMatchFactor: previousLowerRound.matchCount / currentLowerRound.matchCount,\n          rootRoundMatchFactor: firstLowerRound.matchCount / currentLowerRound.matchCount,\n        });\n      }\n    }\n  }\n\n  return roundRelations;\n};\n\nexport const generateMatchRelations = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  matchPositionMaps: MatchPositionMaps<TRoundData, TMatchData>,\n) => {\n  const matchRelations: BracketMatchRelationsMap<TRoundData, TMatchData> = new Map();\n\n  for (const match of bracketData.matches.values()) {\n    const currentRelation = roundRelations.get(match.round.id);\n\n    if (!currentRelation) throw new Error('Match round not found');\n\n    const { nextRoundMatchPosition, previousLowerRoundMatchPosition, previousUpperRoundMatchPosition } =\n      generateMatchRelationPositions(currentRelation, match);\n\n    switch (currentRelation.type) {\n      case 'nothing-to-one': {\n        const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);\n\n        if (!nextMatch) throw new Error('Next round match not found');\n\n        // means left is nothing. right is one\n        matchRelations.set(match.id, {\n          type: 'nothing-to-one',\n          currentMatch: match,\n          currentRound: currentRelation.currentRound,\n          nextRound: currentRelation.nextRound,\n          nextMatch,\n        });\n\n        break;\n      }\n      case 'one-to-nothing': {\n        const previousUpperMatch = matchPositionMaps\n          .get(currentRelation.previousRound.id)\n          ?.get(previousUpperRoundMatchPosition);\n        const previousLowerMatch = matchPositionMaps\n          .get(currentRelation.previousRound.id)\n          ?.get(previousLowerRoundMatchPosition);\n\n        if (!previousUpperMatch) throw new Error('Previous round match not found');\n\n        if (previousUpperRoundMatchPosition !== previousLowerRoundMatchPosition) {\n          // means left is two. right is one\n\n          if (!previousLowerMatch) throw new Error('Previous lower round match not found');\n\n          matchRelations.set(match.id, {\n            type: 'two-to-nothing',\n            currentMatch: match,\n            currentRound: currentRelation.currentRound,\n            previousUpperMatch,\n            previousUpperRound: currentRelation.previousRound,\n            previousLowerMatch,\n            previousLowerRound: currentRelation.previousRound,\n          });\n        } else {\n          // means left is one. right is nothing\n          matchRelations.set(match.id, {\n            type: 'one-to-nothing',\n            currentMatch: match,\n            currentRound: currentRelation.currentRound,\n            previousMatch: previousUpperMatch,\n            previousRound: currentRelation.previousRound,\n          });\n        }\n\n        break;\n      }\n\n      case 'one-to-one': {\n        const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);\n        const previousUpperMatch = matchPositionMaps\n          .get(currentRelation.previousRound.id)\n          ?.get(previousUpperRoundMatchPosition);\n        const previousLowerMatch = matchPositionMaps\n          .get(currentRelation.previousRound.id)\n          ?.get(previousLowerRoundMatchPosition);\n\n        if (!nextMatch) throw new Error('Next round match not found');\n        if (!previousUpperMatch) throw new Error(`Previous upper round match not found`);\n        if (!previousLowerMatch) throw new Error('Previous lower round match not found');\n\n        // can be either one to one or two to one\n        const isLeftOne = previousUpperRoundMatchPosition === previousLowerRoundMatchPosition;\n\n        if (isLeftOne) {\n          // one-to-one\n          matchRelations.set(match.id, {\n            type: 'one-to-one',\n            currentMatch: match,\n            currentRound: currentRelation.currentRound,\n            previousMatch: previousUpperMatch,\n            previousRound: currentRelation.previousRound,\n            nextMatch,\n            nextRound: currentRelation.nextRound,\n          });\n        } else {\n          // two-to-one\n          matchRelations.set(match.id, {\n            type: 'two-to-one',\n            currentMatch: match,\n            currentRound: currentRelation.currentRound,\n            previousUpperMatch,\n            previousUpperRound: currentRelation.previousRound,\n            previousLowerMatch,\n            previousLowerRound: currentRelation.previousRound,\n            nextMatch,\n            nextRound: currentRelation.nextRound,\n          });\n        }\n\n        break;\n      }\n      case 'two-to-one': {\n        const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);\n\n        const previousUpperMatch = matchPositionMaps\n          .get(currentRelation.previousUpperRound.id)\n          ?.get(previousUpperRoundMatchPosition);\n        const previousLowerMatch = matchPositionMaps\n          .get(currentRelation.previousLowerRound.id)\n          ?.get(previousLowerRoundMatchPosition);\n\n        if (!nextMatch) throw new Error('Next round match not found');\n        if (!previousUpperMatch) throw new Error(`Previous upper round match not found`);\n        if (!previousLowerMatch) throw new Error('Previous lower round match not found');\n\n        matchRelations.set(match.id, {\n          type: 'two-to-one',\n          currentMatch: match,\n          currentRound: currentRelation.currentRound,\n          previousUpperMatch,\n          previousUpperRound: currentRelation.previousUpperRound,\n          previousLowerMatch,\n          previousLowerRound: currentRelation.previousLowerRound,\n          nextMatch,\n          nextRound: currentRelation.nextRound,\n        });\n\n        break;\n      }\n      case 'two-to-nothing': {\n        const previousUpperMatch = matchPositionMaps\n          .get(currentRelation.previousUpperRound.id)\n          ?.get(previousUpperRoundMatchPosition);\n        const previousLowerMatch = matchPositionMaps\n          .get(currentRelation.previousUpperRound.id)\n          ?.get(previousLowerRoundMatchPosition);\n\n        if (!previousUpperMatch) throw new Error(`Previous upper round match not found`);\n        if (!previousLowerMatch) throw new Error('Previous lower round match not found');\n\n        matchRelations.set(match.id, {\n          type: 'two-to-nothing',\n          currentMatch: match,\n          currentRound: currentRelation.currentRound,\n          previousUpperMatch,\n          previousUpperRound: currentRelation.previousUpperRound,\n          previousLowerMatch,\n          previousLowerRound: currentRelation.previousUpperRound,\n        });\n\n        break;\n      }\n    }\n  }\n\n  return matchRelations;\n};\n\nexport const generateMatchRelationPositions = <TRoundData, TMatchData>(\n  currentRelation: BracketRoundRelation<TRoundData, TMatchData>,\n  match: BracketMatch<TRoundData, TMatchData>,\n) => {\n  switch (currentRelation.type) {\n    case 'nothing-to-one': {\n      return {\n        nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),\n        previousUpperRoundMatchPosition: FALLBACK_MATCH_POSITION,\n        previousLowerRoundMatchPosition: FALLBACK_MATCH_POSITION,\n      };\n    }\n    case 'one-to-nothing': {\n      const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;\n      const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;\n\n      return {\n        nextRoundMatchPosition: FALLBACK_MATCH_POSITION,\n        previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -\n          doubleUpperMatchCountShift) as BracketMatchPosition,\n        previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),\n      };\n    }\n    case 'one-to-one': {\n      const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;\n      const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;\n\n      return {\n        nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),\n        previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -\n          doubleUpperMatchCountShift) as BracketMatchPosition,\n        previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),\n      };\n    }\n    case 'two-to-one': {\n      return {\n        nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),\n        previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),\n        previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),\n      };\n    }\n    case 'two-to-nothing': {\n      return {\n        nextRoundMatchPosition: FALLBACK_MATCH_POSITION,\n        previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),\n        previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),\n      };\n    }\n  }\n};\n\nexport const generateMatchPosition = (match: BracketMatch<unknown, unknown>, factor: MatchFactor) => {\n  return Math.ceil(match.position * factor) as BracketMatchPosition;\n};\n\nexport const logRoundRelations = (\n  roundRelations: BracketRoundRelations<unknown, unknown>,\n  bracketData: BracketData<unknown, unknown>,\n) => {\n  for (const [roundId, relation] of roundRelations.entries()) {\n    const round = bracketData.rounds.get(roundId);\n\n    if (!round) {\n      console.error(`Round with id ${roundId} not found in bracket data. The bracket will be malformed.`);\n      continue;\n    }\n\n    switch (relation.type) {\n      case 'nothing-to-one':\n        console.log(`START: ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);\n        break;\n      case 'one-to-nothing':\n        console.log(\n          `${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ENDING: ${round.name}`,\n        );\n        break;\n      case 'one-to-one':\n        console.log(\n          `${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`,\n        );\n        break;\n      case 'two-to-one':\n        console.log(\n          `MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`,\n        );\n        break;\n      case 'two-to-nothing':\n        console.log(\n          `MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ENDING: ${round.name}`,\n        );\n        break;\n    }\n  }\n};\n\nexport const generateMatchParticipantMap = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n) => {\n  const matchParticipantMap: MatchParticipantMap<TRoundData, TMatchData> = new Map();\n\n  const hasElimination =\n    bracketData.mode === TOURNAMENT_MODE.SINGLE_ELIMINATION ||\n    bracketData.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ||\n    bracketData.mode === TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;\n\n  for (const participant of bracketData.participants.values()) {\n    let winsTilNow = 0;\n    let lossesTilNow = 0;\n    let tiesTilNow = 0;\n\n    for (const matchParticipantMatch of participant.matches.values()) {\n      const isWinner = matchParticipantMatch.bracketMatch.winner === matchParticipantMatch.side;\n      const isLooser =\n        matchParticipantMatch.bracketMatch.winner &&\n        matchParticipantMatch.bracketMatch.winner !== matchParticipantMatch.side;\n      const isTie =\n        matchParticipantMatch.bracketMatch.status === 'completed' && !matchParticipantMatch.bracketMatch.winner;\n\n      if (isWinner) {\n        winsTilNow++;\n      } else if (isLooser) {\n        lossesTilNow++;\n      } else if (isTie) {\n        tiesTilNow++;\n      }\n\n      let isEliminated = false;\n      let isEliminationMatch = false;\n\n      if (hasElimination) {\n        // TODO: Implement elimination logic\n\n        // Means the current match is loss and it's the last match of the participant\n        isEliminated = false;\n\n        // Always true for single elimination, never for e.g. groups, depends on the round for double elimination, depends on the loss count for swiss with elimination\n        isEliminationMatch = false;\n      }\n\n      // TODO: Implement round logic\n      // true if its the first round of the bracket\n      const isFirstRound = false;\n\n      // true if its the last round of the bracket (eg. final for single elimination)\n      const isLastRound = false;\n\n      const participantMatchData: MatchParticipantMatch<TRoundData, TMatchData> = {\n        bracketMatch: matchParticipantMatch.bracketMatch,\n        result: isWinner ? 'win' : isLooser ? 'loss' : isTie ? 'tie' : null,\n        isEliminated,\n        isEliminationMatch,\n        isFirstRound,\n        isLastRound,\n        tieCount: tiesTilNow,\n        winCount: winsTilNow,\n        lossCount: lossesTilNow,\n      };\n\n      if (!matchParticipantMap.has(participant.id)) {\n        matchParticipantMap.set(participant.id, {\n          id: participant.id,\n          name: participant.name,\n          matches: new Map(),\n        });\n      }\n\n      const participantData = matchParticipantMap.get(participant.id) as MatchParticipant<TRoundData, TMatchData>;\n      participantData.matches.set(matchParticipantMatch.bracketMatch.id, participantMatchData);\n    }\n  }\n\n  return matchParticipantMap;\n};\n\nconst factorialCache = new Map<number, number>();\n\nexport const getAvailableSwissGroupsForRound = (roundNumber: number, totalMatchesInRound: number) => {\n  const ADVANCE_WINS = 3;\n  const ELIMINATE_LOSSES = 3;\n\n  // Cache factorial calculations\n  const getFactorial = (n: number): number => {\n    if (n <= 1) return 1;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    if (factorialCache.has(n)) return factorialCache.get(n)!;\n\n    const result = n * getFactorial(n - 1);\n    factorialCache.set(n, result);\n    return result;\n  };\n\n  // Pre-calculate roundFactorial\n  const roundFact = getFactorial(roundNumber);\n\n  let totalCombinations = 0;\n  const validGroups: { wins: number; losses: number; combinations: number }[] = [];\n\n  // Single loop to gather valid groups and total combinations\n  for (let wins = roundNumber; wins >= 0; wins--) {\n    const losses = roundNumber - wins;\n    const remainingGames = ADVANCE_WINS + ELIMINATE_LOSSES - (wins + losses) - 1;\n    const notYetEliminated = losses < ELIMINATE_LOSSES;\n    const canStillAdvance = wins < ADVANCE_WINS && remainingGames >= 0;\n\n    if (!canStillAdvance || !notYetEliminated) continue;\n\n    const combinations = roundFact / (getFactorial(wins) * getFactorial(losses));\n    totalCombinations += combinations;\n    validGroups.push({ wins, losses, combinations });\n  }\n\n  // Create final groups with calculated proportions\n  return validGroups.map(({ wins, losses, combinations }) => ({\n    id: `${wins}-${losses}` as BracketRoundSwissGroupId,\n    name: `${wins}-${losses}`,\n    matchesInGroup: Math.round((combinations / totalCombinations) * totalMatchesInRound),\n  }));\n};\n\nexport const generateBracketRoundSwissGroupMaps = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  matchParticipantMap: MatchParticipantMap<TRoundData, TMatchData>,\n) => {\n  if (bracketData.mode !== TOURNAMENT_MODE.SWISS_WITH_ELIMINATION) {\n    return null;\n  }\n\n  const roundsWithSwissGroups: BracketRoundMapWithSwissData<TRoundData, TMatchData> = new Map();\n\n  let roundNumber = 0;\n  for (const bracketRound of bracketData.rounds.values()) {\n    const availableGroups = getAvailableSwissGroupsForRound(roundNumber, bracketRound.matchCount);\n\n    const roundSwissData: BracketRoundSwissData<TRoundData, TMatchData> = {\n      groups: new Map(),\n    };\n\n    for (const group of availableGroups) {\n      const subGroup: BracketRoundSwissGroup<TRoundData, TMatchData> = {\n        id: group.id,\n        name: group.name,\n        matches: new Map(),\n        allowedMatchCount: group.matchesInGroup,\n      };\n\n      roundSwissData.groups.set(group.id, subGroup);\n    }\n\n    const emptyMatchIds: BracketMatchId[] = [];\n\n    for (const match of bracketRound.matches.values()) {\n      const participantHome = match.home ? (matchParticipantMap.get(match.home) ?? null) : null;\n      const participantAway = match.away ? (matchParticipantMap.get(match.away) ?? null) : null;\n\n      const anyParticipant = participantHome || participantAway;\n\n      if (!anyParticipant) {\n        emptyMatchIds.push(match.id);\n        continue;\n      }\n\n      const matchParticipantMatch = anyParticipant.matches.get(match.id);\n\n      if (!matchParticipantMatch) throw new Error('Match participant match not found');\n\n      const wins = matchParticipantMatch.winCount;\n      const losses = matchParticipantMatch.lossCount;\n\n      const group = roundSwissData.groups.get(`${wins}-${losses}` as BracketRoundSwissGroupId);\n\n      if (!group) throw new Error('Group not found for match: ' + match.id);\n\n      group.matches.set(match.id, match);\n    }\n\n    for (const emptyMatchId of emptyMatchIds) {\n      const match = bracketRound.matches.get(emptyMatchId);\n\n      if (!match) throw new Error('Empty match not found');\n\n      let groupFound = false;\n      for (const group of roundSwissData.groups.values()) {\n        if (group.matches.size < group.allowedMatchCount) {\n          group.matches.set(match.id, match);\n          groupFound = true;\n          break;\n        }\n      }\n\n      if (!groupFound) {\n        throw new Error('No group found for empty match');\n      }\n    }\n\n    roundNumber++;\n  }\n\n  return roundsWithSwissGroups;\n};\n"]}