diff --git a/apps/api/src/modules/tournament-code/tournament-code.controller.ts b/apps/api/src/modules/tournament-code/tournament-code.controller.ts new file mode 100644 index 00000000..cd28cd47 --- /dev/null +++ b/apps/api/src/modules/tournament-code/tournament-code.controller.ts @@ -0,0 +1,105 @@ +import { + BadRequestException, + Body, + Controller, + Delete, + Get, + HttpCode, + HttpStatus, + Param, + Post, + Query, + UseGuards, +} from '@nestjs/common'; +import mongoose from 'mongoose'; +import { CurrentUser } from '../auth/current-user.decorator'; +import { Roles } from '../auth/roles.decorator'; +import { RolesGuard } from '../auth/roles.guard'; +import { ParseObjectIdPipe } from '../common/parse-object-id.pipe'; +import type { + TournamentCodeState, + UserDocument, +} from '../global/database/schema'; +import { TournamentCodeService } from './tournament-code.service'; +import type { BulkUploadTournamentCodesRequest } from './tournament-code.types'; + +@Controller('communities/:communityId/tournament-codes') +@Roles('owner', 'admin') +@UseGuards(RolesGuard) +export class TournamentCodeController { + constructor(private readonly tournamentCodeService: TournamentCodeService) {} + + @Post() + public async bulkUpload( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Body() body: BulkUploadTournamentCodesRequest, + ) { + this.assertSameCommunity(currentUser, communityId); + return this.tournamentCodeService.bulkUpload({ + communityId, + uploadedBy: currentUser._id, + codes: body.codes ?? [], + }); + } + + @Get() + public async list( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Query('state') state?: TournamentCodeState, + @Query('limit') limit?: string, + ) { + this.assertSameCommunity(currentUser, communityId); + return { + codes: await this.tournamentCodeService.list({ + state, + limit: limit ? Number(limit) : undefined, + }), + }; + } + + @Get('stats') + public async stats( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + ) { + this.assertSameCommunity(currentUser, communityId); + return this.tournamentCodeService.stats(); + } + + @Post(':id/release') + public async restore( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Param('id', ParseObjectIdPipe) id: mongoose.Types.ObjectId, + ) { + this.assertSameCommunity(currentUser, communityId); + return this.tournamentCodeService.restoreToAvailable(id); + } + + @Delete(':id') + @HttpCode(HttpStatus.NO_CONTENT) + public async discard( + @CurrentUser() currentUser: UserDocument, + @Param('communityId', ParseObjectIdPipe) + communityId: mongoose.Types.ObjectId, + @Param('id', ParseObjectIdPipe) id: mongoose.Types.ObjectId, + ) { + this.assertSameCommunity(currentUser, communityId); + await this.tournamentCodeService.discardAvailable(id); + } + + private assertSameCommunity( + user: UserDocument, + communityId: mongoose.Types.ObjectId, + ): void { + if (!user.communityId.equals(communityId)) { + throw new BadRequestException('Different community.'); + } + } +} diff --git a/apps/api/src/modules/tournament-code/tournament-code.module.ts b/apps/api/src/modules/tournament-code/tournament-code.module.ts new file mode 100644 index 00000000..f41cc726 --- /dev/null +++ b/apps/api/src/modules/tournament-code/tournament-code.module.ts @@ -0,0 +1,11 @@ +import { Module } from '@nestjs/common'; +import { TournamentCodeController } from './tournament-code.controller'; +import { TournamentCodeScheduler } from './tournament-code.scheduler'; +import { TournamentCodeService } from './tournament-code.service'; + +@Module({ + controllers: [TournamentCodeController], + providers: [TournamentCodeService, TournamentCodeScheduler], + exports: [TournamentCodeService], +}) +export class TournamentCodeModule {} diff --git a/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts b/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts new file mode 100644 index 00000000..9f73d297 --- /dev/null +++ b/apps/api/src/modules/tournament-code/tournament-code.scheduler.ts @@ -0,0 +1,57 @@ +import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common'; +import { TournamentCodeService } from './tournament-code.service'; + +@Injectable() +export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy { + private readonly logger = new Logger(TournamentCodeScheduler.name); + private attachTimer?: NodeJS.Timeout; + private expireTimer?: NodeJS.Timeout; + + constructor(private readonly tournamentCodeService: TournamentCodeService) {} + + public onModuleInit() { + this.attachTimer = setInterval(() => { + void this.attachPending(); + }, 30_000); + this.expireTimer = setInterval(() => { + void this.markExpired(); + }, 60 * 60 * 1000); + this.attachTimer.unref?.(); + this.expireTimer.unref?.(); + + void this.attachPending(); + void this.markExpired(); + } + + public onModuleDestroy() { + if (this.attachTimer) clearInterval(this.attachTimer); + if (this.expireTimer) clearInterval(this.expireTimer); + } + + private async attachPending() { + try { + const touched = await this.tournamentCodeService.attachPendingMatches(); + if (touched > 0) { + this.logger.debug(`Attached tournament codes for ${touched} matches.`); + } + } catch (error) { + this.logger.warn( + `Failed to attach pending tournament codes: ${ + error instanceof Error ? error.message : error + }`, + ); + } + } + + private async markExpired() { + try { + await this.tournamentCodeService.markExpired(); + } catch (error) { + this.logger.warn( + `Failed to mark expired tournament codes: ${ + error instanceof Error ? error.message : error + }`, + ); + } + } +} diff --git a/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts b/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts new file mode 100644 index 00000000..0e2c03e2 --- /dev/null +++ b/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts @@ -0,0 +1,191 @@ +import type { MatchDocument } from '../global/database/schema'; +import { TournamentCodeService } from './tournament-code.service'; + +type TournamentCodeServiceInternals = TournamentCodeService & { + resolveRequiredSlots(match: MatchDocument): number; + resolveSeriesRefForGameNumber( + match: MatchDocument, + gameNumber: number, + ): { teamAIndex: number; teamBIndex: number }; + ensureGameSchedule(match: MatchDocument): void; +}; + +function createService() { + return new TournamentCodeService( + {} as never, + ) as unknown as TournamentCodeServiceInternals; +} + +interface MatchOverrides { + gameCount?: number; + gameMode?: 'pair' | 'bracket' | 'round-robin'; + participants?: Array<{ excluded?: boolean }>; + teams?: Array<{ teamIndex: number }>; + gameSchedule?: Array<{ + gameNumber: number; + teamAIndex: number; + teamBIndex: number; + }>; +} + +function createMatch(overrides: MatchOverrides): MatchDocument { + return { + gameCount: 1, + gameMode: 'pair', + participants: [], + teams: [], + gameSchedule: [], + ...overrides, + } as unknown as MatchDocument; +} + +describe('TournamentCodeService round-robin scheduling', () => { + it('keeps pair slot calculation unchanged', () => { + const service = createService(); + const match = createMatch({ + gameCount: 3, + teams: Array.from({ length: 6 }, (_, index) => ({ + teamIndex: index + 1, + })), + participants: Array.from({ length: 30 }, () => ({})), + }); + + expect(service.resolveRequiredSlots(match)).toBe(9); + expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({ + teamAIndex: 1, + teamBIndex: 2, + }); + expect(service.resolveSeriesRefForGameNumber(match, 4)).toEqual({ + teamAIndex: 3, + teamBIndex: 4, + }); + expect(service.resolveSeriesRefForGameNumber(match, 7)).toEqual({ + teamAIndex: 5, + teamBIndex: 6, + }); + }); + + it('calculates round-robin slots from team pairs and per-pair game count', () => { + const service = createService(); + + expect( + service.resolveRequiredSlots( + createMatch({ + gameMode: 'round-robin', + gameCount: 1, + teams: Array.from({ length: 6 }, (_, index) => ({ + teamIndex: index + 1, + })), + }), + ), + ).toBe(15); + expect( + service.resolveRequiredSlots( + createMatch({ + gameMode: 'round-robin', + gameCount: 2, + teams: Array.from({ length: 6 }, (_, index) => ({ + teamIndex: index + 1, + })), + }), + ), + ).toBe(30); + expect( + service.resolveRequiredSlots( + createMatch({ + gameMode: 'round-robin', + gameCount: 1, + teams: [], + participants: Array.from({ length: 30 }, () => ({})), + }), + ), + ).toBe(15); + }); + + it('uses persisted round-robin game schedule for game refs', () => { + const service = createService(); + const match = createMatch({ + gameMode: 'round-robin', + gameCount: 2, + gameSchedule: [ + { gameNumber: 1, teamAIndex: 2, teamBIndex: 5 }, + { gameNumber: 2, teamAIndex: 2, teamBIndex: 5 }, + { gameNumber: 3, teamAIndex: 1, teamBIndex: 4 }, + ], + }); + + expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({ + teamAIndex: 2, + teamBIndex: 5, + }); + expect(service.resolveSeriesRefForGameNumber(match, 3)).toEqual({ + teamAIndex: 1, + teamBIndex: 4, + }); + }); + + it('falls back to lexicographic round-robin pairs before schedule is persisted', () => { + const service = createService(); + const match = createMatch({ + gameMode: 'round-robin', + gameCount: 1, + teams: Array.from({ length: 4 }, (_, index) => ({ + teamIndex: index + 1, + })), + gameSchedule: [], + }); + + expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({ + teamAIndex: 1, + teamBIndex: 2, + }); + expect(service.resolveSeriesRefForGameNumber(match, 2)).toEqual({ + teamAIndex: 1, + teamBIndex: 3, + }); + }); + + it('creates a round-robin schedule once and leaves pair matches empty', () => { + const service = createService(); + const roundRobin = createMatch({ + gameMode: 'round-robin', + gameCount: 2, + teams: Array.from({ length: 4 }, (_, index) => ({ + teamIndex: index + 1, + })), + gameSchedule: [], + }); + + service.ensureGameSchedule(roundRobin); + expect(roundRobin.gameSchedule).toHaveLength(12); + const persisted = [...roundRobin.gameSchedule]; + service.ensureGameSchedule(roundRobin); + expect(roundRobin.gameSchedule).toEqual(persisted); + + const pair = createMatch({ + gameMode: 'pair', + teams: Array.from({ length: 4 }, (_, index) => ({ + teamIndex: index + 1, + })), + gameSchedule: [], + }); + service.ensureGameSchedule(pair); + expect(pair.gameSchedule).toEqual([]); + }); + + it('does not expose fallback round-robin slots before the schedule is persisted', async () => { + const service = createService(); + const slots = await service.buildSlots( + createMatch({ + gameMode: 'round-robin', + gameCount: 1, + teams: Array.from({ length: 6 }, (_, index) => ({ + teamIndex: index + 1, + })), + gameSchedule: [], + }), + ); + + expect(slots).toEqual([]); + }); +}); diff --git a/apps/api/src/modules/tournament-code/tournament-code.service.ts b/apps/api/src/modules/tournament-code/tournament-code.service.ts new file mode 100644 index 00000000..8801f7df --- /dev/null +++ b/apps/api/src/modules/tournament-code/tournament-code.service.ts @@ -0,0 +1,470 @@ +import { + BadRequestException, + Injectable, + NotFoundException, +} from '@nestjs/common'; +import mongoose from 'mongoose'; +import { ConnectionService } from '../global/database/connection.service'; +import type { + MatchGameAssignment, + MatchDocument, + TournamentCode, + TournamentCodeDocument, + TournamentCodeState, + TournamentSpectatorType, +} from '../global/database/schema'; +import { + DEFAULT_TOURNAMENT_GAME_COUNT, + TOURNAMENT_CODE_EXPIRING_SOON_MS, + TOURNAMENT_CODE_EXPIRY_MARGIN_MS, + TOURNAMENT_CODE_PATTERN, +} from './tournament-code.constants'; +import type { + BulkUploadTournamentCodesResponse, + TournamentCodeSlotView, + TournamentCodeUploadItem, +} from './tournament-code.types'; +import { + resolveRoundRobinTeamCount, + roundRobinPairCount, + roundRobinPairs, + shuffleInPlace, +} from './round-robin.util'; + +const DEFAULT_REGION = 'kr'; +const DEFAULT_SPECTATOR_TYPE: TournamentSpectatorType = 'ALL'; + +@Injectable() +export class TournamentCodeService { + constructor(private readonly connectionService: ConnectionService) {} + + public async bulkUpload(params: { + communityId: mongoose.Types.ObjectId; + uploadedBy: mongoose.Types.ObjectId; + codes: TournamentCodeUploadItem[]; + }): Promise { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const invalid: BulkUploadTournamentCodesResponse['invalid'] = []; + const duplicates: string[] = []; + const valid: Array< + Omit & { + uploadedBy: mongoose.Types.ObjectId; + } + > = []; + const seen = new Set(); + + for (const item of params.codes) { + const code = this.normalizeCode(item.code); + if (!code) { + invalid.push({ code: item.code ?? '', reason: 'empty-code' }); + continue; + } + if (!TOURNAMENT_CODE_PATTERN.test(code)) { + invalid.push({ code, reason: 'invalid-format' }); + continue; + } + if (seen.has(code)) { + duplicates.push(code); + continue; + } + seen.add(code); + + const expiresAt = new Date(item.expiresAt); + if (Number.isNaN(expiresAt.getTime())) { + invalid.push({ code, reason: 'invalid-expiresAt' }); + continue; + } + if (expiresAt <= new Date()) { + invalid.push({ code, reason: 'expired-expiresAt' }); + continue; + } + + valid.push({ + code, + region: DEFAULT_REGION, + mapType: 'SUMMONERS_RIFT', + teamSize: 5, + spectatorType: item.spectatorType ?? DEFAULT_SPECTATOR_TYPE, + metadata: item.metadata, + expiresAt, + state: 'available', + uploadedBy: params.uploadedBy, + uploadedAt: new Date(), + source: item.source, + notes: item.notes, + }); + } + + if (valid.length === 0) { + return { inserted: 0, duplicates, invalid }; + } + + const existing = await TournamentCodeModel.find({ + code: { $in: valid.map((item) => item.code) }, + }) + .select({ code: 1 }) + .lean() + .exec(); + const existingCodes = new Set(existing.map((item) => item.code)); + duplicates.push(...existing.map((item) => item.code)); + + const insertable = valid.filter((item) => !existingCodes.has(item.code)); + if (insertable.length > 0) { + await TournamentCodeModel.insertMany(insertable, { ordered: false }); + } + + await this.attachPendingMatches(params.communityId); + + return { + inserted: insertable.length, + duplicates: [...new Set(duplicates)], + invalid, + }; + } + + public async list(params: { + state?: TournamentCodeState; + limit?: number; + }): Promise { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const filter: { state?: TournamentCodeState } = {}; + if (params.state) filter.state = params.state; + return TournamentCodeModel.find(filter) + .sort({ expiresAt: 1, uploadedAt: -1 }) + .limit(Math.min(params.limit ?? 100, 300)) + .exec(); + } + + public async stats(): Promise<{ + byState: Record; + expiringSoon: number; + available: number; + }> { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const states: TournamentCodeState[] = [ + 'available', + 'reserved', + 'used', + 'expired', + 'released', + ]; + const counts = await TournamentCodeModel.aggregate<{ + _id: TournamentCodeState; + count: number; + }>([{ $group: { _id: '$state', count: { $sum: 1 } } }]).exec(); + const byState = Object.fromEntries(states.map((state) => [state, 0])) as Record< + TournamentCodeState, + number + >; + for (const entry of counts) byState[entry._id] = entry.count; + + const expiringSoon = await TournamentCodeModel.countDocuments({ + state: 'available', + expiresAt: { + $gt: new Date(), + $lte: new Date(Date.now() + TOURNAMENT_CODE_EXPIRING_SOON_MS), + }, + }); + + return { byState, expiringSoon, available: byState.available }; + } + + public async discardAvailable(id: mongoose.Types.ObjectId): Promise { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const result = await TournamentCodeModel.deleteOne({ + _id: id, + state: 'available', + }).exec(); + if (result.deletedCount === 0) { + throw new BadRequestException('Only available tournament codes can be deleted.'); + } + } + + public async restoreToAvailable( + id: mongoose.Types.ObjectId, + ): Promise { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const MatchModel = await this.connectionService.getModel('match'); + const code = await TournamentCodeModel.findById(id); + if (!code) throw new NotFoundException('Tournament code not found.'); + if (code.state !== 'released' && code.state !== 'reserved') { + throw new BadRequestException( + 'Only released or reserved tournament codes can be restored.', + ); + } + const previousMatchId = code.matchId; + code.state = 'available'; + code.matchId = undefined; + code.gameNumber = undefined; + code.reservedAt = undefined; + code.releasedAt = undefined; + await code.save(); + if (previousMatchId) { + await MatchModel.updateOne( + { _id: previousMatchId }, + { $pull: { tournamentCodeIds: code._id } }, + ).exec(); + await this.attachPendingMatches(); + } + return code; + } + + public async reserveForMatch( + matchOrId: MatchDocument | mongoose.Types.ObjectId, + ): Promise { + const MatchModel = await this.connectionService.getModel('match'); + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const match = + matchOrId instanceof mongoose.Types.ObjectId + ? await MatchModel.findById(matchOrId) + : await MatchModel.findById(matchOrId._id); + if (!match) throw new NotFoundException('Match not found.'); + + match.gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; + match.tournamentCodeIds = match.tournamentCodeIds ?? []; + this.ensureGameSchedule(match); + const shouldSaveMetadata = + match.isModified('gameCount') || match.isModified('gameSchedule'); + const requiredSlots = this.resolveRequiredSlots(match); + const need = requiredSlots - match.tournamentCodeIds.length; + if (need <= 0) { + if (shouldSaveMetadata) await match.save(); + return match; + } + + const reservedIds: mongoose.Types.ObjectId[] = []; + const startGameNumber = match.tournamentCodeIds.length + 1; + const expiresAfter = new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS); + + for (let index = 0; index < need; index += 1) { + const code = await TournamentCodeModel.findOneAndUpdate( + { + state: 'available', + region: DEFAULT_REGION, + mapType: 'SUMMONERS_RIFT', + teamSize: 5, + expiresAt: { $gt: expiresAfter }, + }, + { + $set: { + state: 'reserved', + matchId: match._id, + gameNumber: startGameNumber + index, + reservedAt: new Date(), + }, + $unset: { releasedAt: 1 }, + }, + { sort: { expiresAt: 1 }, returnDocument: 'after' }, + ).exec(); + if (!code) break; + reservedIds.push(code._id); + } + + if (reservedIds.length > 0) { + match.tournamentCodeIds.push(...reservedIds); + } + if (reservedIds.length > 0 || shouldSaveMetadata) { + await match.save(); + } + return match; + } + + public async releaseFromMatch( + matchOrId: MatchDocument | mongoose.Types.ObjectId, + ): Promise { + const MatchModel = await this.connectionService.getModel('match'); + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const match = + matchOrId instanceof mongoose.Types.ObjectId + ? await MatchModel.findById(matchOrId) + : await MatchModel.findById(matchOrId._id); + if (!match) return; + if (match.tournamentCodeIds.length === 0) return; + + await TournamentCodeModel.updateMany( + { _id: { $in: match.tournamentCodeIds }, state: 'reserved' }, + { + $set: { state: 'released', releasedAt: new Date() }, + $unset: { matchId: 1, gameNumber: 1, reservedAt: 1 }, + }, + ).exec(); + + match.tournamentCodeIds = []; + await match.save(); + } + + public async markExpired(): Promise { + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const result = await TournamentCodeModel.updateMany( + { + state: { $in: ['available', 'reserved', 'released'] }, + expiresAt: { $lte: new Date() }, + }, + { $set: { state: 'expired' } }, + ).exec(); + return result.modifiedCount; + } + + public async attachPendingMatches( + communityId?: mongoose.Types.ObjectId, + ): Promise { + const MatchModel = await this.connectionService.getModel('match'); + const filter: { + status: { $in: string[] }; + communityId?: mongoose.Types.ObjectId; + } = { + status: { $in: ['team-built', 'in-progress'] }, + }; + if (communityId) filter.communityId = communityId; + + const matches = await MatchModel.find(filter).exec(); + let touched = 0; + for (const match of matches) { + if ((match.tournamentCodeIds?.length ?? 0) >= this.resolveRequiredSlots(match)) { + continue; + } + const before = match.tournamentCodeIds?.length ?? 0; + await this.reserveForMatch(match); + const after = match.tournamentCodeIds?.length ?? 0; + if (after > before) touched += 1; + } + return touched; + } + + public async buildSlots(match: MatchDocument): Promise { + if ( + (match.gameMode ?? 'pair') === 'round-robin' && + (match.gameSchedule?.length ?? 0) === 0 && + (match.tournamentCodeIds?.length ?? 0) === 0 + ) { + return []; + } + const TournamentCodeModel = + await this.connectionService.getModel('tournamentCode'); + const gameCount = this.resolveRequiredSlots(match); + const ids = match.tournamentCodeIds ?? []; + const codes = + ids.length > 0 + ? await TournamentCodeModel.find({ _id: { $in: ids } }).exec() + : []; + const byGameNumber = new Map( + codes + .filter((code) => typeof code.gameNumber === 'number') + .map((code) => [code.gameNumber as number, code]), + ); + + return Array.from({ length: gameCount }, (_, index) => { + const gameNumber = index + 1; + const code = byGameNumber.get(gameNumber); + if (!code) { + const seriesRef = this.resolveSeriesRefForGameNumber(match, gameNumber); + return { + gameNumber, + ...seriesRef, + code: null, + expiresAt: null, + state: 'pending', + riotMatchId: null, + }; + } + return { + gameNumber, + ...this.resolveSeriesRefForGameNumber(match, gameNumber), + code: code.code, + expiresAt: code.expiresAt.toISOString(), + state: code.state, + riotMatchId: code.riotMatchId ?? null, + }; + }); + } + + private normalizeCode(code: string | undefined): string { + return (code ?? '').trim().toUpperCase(); + } + + private resolveRequiredSlots(match: MatchDocument): number { + const gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; + const gameMode = match.gameMode ?? 'pair'; + + if (gameMode === 'round-robin') { + const teamCount = resolveRoundRobinTeamCount(match); + return roundRobinPairCount(teamCount) * gameCount; + } + + const teamCount = (match.teams ?? []).length; + const activeParticipantCount = (match.participants ?? []).filter( + (participant) => !participant.excluded, + ).length; + const participantSeriesCount = Math.floor(activeParticipantCount / 10); + const teamSeriesCount = Math.ceil(teamCount / 2); + const seriesCount = Math.max(1, teamSeriesCount, participantSeriesCount); + return seriesCount * gameCount; + } + + private resolveSeriesRefForGameNumber( + match: MatchDocument, + gameNumber: number, + ): { teamAIndex: number; teamBIndex: number } { + const gameMode = match.gameMode ?? 'pair'; + + if (gameMode === 'round-robin') { + const persisted = match.gameSchedule?.find( + (entry) => entry.gameNumber === gameNumber, + ); + if (persisted) { + return { + teamAIndex: persisted.teamAIndex, + teamBIndex: persisted.teamBIndex, + }; + } + + const teamCount = resolveRoundRobinTeamCount(match); + const perSeries = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; + const pairIndex = Math.max(0, Math.ceil(gameNumber / perSeries) - 1); + return roundRobinPairs(teamCount)[pairIndex] ?? { + teamAIndex: 1, + teamBIndex: 2, + }; + } + + const perSeries = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; + const seriesIndex = Math.max(1, Math.ceil(gameNumber / perSeries)); + return { + teamAIndex: (seriesIndex - 1) * 2 + 1, + teamBIndex: (seriesIndex - 1) * 2 + 2, + }; + } + + private ensureGameSchedule(match: MatchDocument): void { + if ((match.gameMode ?? 'pair') !== 'round-robin') return; + if ((match.gameSchedule?.length ?? 0) > 0) return; + + const teamCount = resolveRoundRobinTeamCount(match); + if (teamCount < 2) return; + + const gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; + const pairs = shuffleInPlace([...roundRobinPairs(teamCount)]); + const schedule: MatchGameAssignment[] = []; + + for (let pairIndex = 0; pairIndex < pairs.length; pairIndex += 1) { + const pair = pairs[pairIndex]; + for (let gameIndex = 0; gameIndex < gameCount; gameIndex += 1) { + schedule.push({ + gameNumber: pairIndex * gameCount + gameIndex + 1, + teamAIndex: pair.teamAIndex, + teamBIndex: pair.teamBIndex, + }); + } + } + + match.gameSchedule = schedule; + } +}