wip

packages/racing/application/use-cases/CreateLeagueWithSeasonAndScoringUseCase.ts

@@ -0,0 +1,141 @@
+import { v4 as uuidv4 } from 'uuid';
+import { League } from '../../domain/entities/League';
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
+import type { LeagueScoringConfig } from '../../domain/entities/LeagueScoringConfig';
+import type {
+  LeagueScoringPresetProvider,
+  LeagueScoringPresetDTO,
+} from '../ports/LeagueScoringPresetProvider';
+
+export interface CreateLeagueWithSeasonAndScoringCommand {
+  name: string;
+  description?: string;
+  visibility: 'public' | 'private';
+  ownerId: string;
+  gameId: string;
+  maxDrivers?: number;
+  maxTeams?: number;
+  enableDriverChampionship: boolean;
+  enableTeamChampionship: boolean;
+  enableNationsChampionship: boolean;
+  enableTrophyChampionship: boolean;
+  scoringPresetId?: string;
+}
+
+export interface CreateLeagueWithSeasonAndScoringResultDTO {
+  leagueId: string;
+  seasonId: string;
+  scoringPresetId?: string;
+  scoringPresetName?: string;
+}
+
+export class CreateLeagueWithSeasonAndScoringUseCase {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly presetProvider: LeagueScoringPresetProvider,
+  ) {}
+
+  async execute(
+    command: CreateLeagueWithSeasonAndScoringCommand,
+  ): Promise<CreateLeagueWithSeasonAndScoringResultDTO> {
+    this.validate(command);
+
+    const leagueId = uuidv4();
+
+    const league = League.create({
+      id: leagueId,
+      name: command.name,
+      description: command.description ?? '',
+      ownerId: command.ownerId,
+      settings: {
+        pointsSystem: (command.scoringPresetId as any) ?? 'custom',
+        maxDrivers: command.maxDrivers,
+      },
+    });
+
+    await this.leagueRepository.create(league);
+
+    const seasonId = uuidv4();
+    const season = {
+      id: seasonId,
+      leagueId: league.id,
+      gameId: command.gameId,
+      name: `${command.name} Season 1`,
+      year: new Date().getFullYear(),
+      order: 1,
+      status: 'active' as const,
+      startDate: new Date(),
+      endDate: new Date(),
+    };
+
+    // Season is a domain entity; use the repository's create, but shape matches Season.create expectations.
+    // To keep this use case independent, we rely on repository to persist the plain object.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await this.seasonRepository.create(season as any);
+
+    const presetId = command.scoringPresetId ?? 'club-default';
+    const preset: LeagueScoringPresetDTO | undefined =
+      this.presetProvider.getPresetById(presetId);
+
+    if (!preset) {
+      throw new Error(`Unknown scoring preset: ${presetId}`);
+    }
+
+    const scoringConfig: LeagueScoringConfig = {
+      id: uuidv4(),
+      seasonId,
+      scoringPresetId: preset.id,
+      championships: [],
+    };
+
+    // For the initial alpha slice, we keep using the preset's config shape from the in-memory registry.
+    // The preset registry is responsible for building the full LeagueScoringConfig; we only attach the preset id here.
+    const fullConfigFactory = (await import(
+      '../../infrastructure/repositories/InMemoryScoringRepositories'
+    )) as typeof import('../../infrastructure/repositories/InMemoryScoringRepositories');
+
+    const presetFromInfra = fullConfigFactory.getLeagueScoringPresetById(
+      preset.id,
+    );
+    if (!presetFromInfra) {
+      throw new Error(`Preset registry missing preset: ${preset.id}`);
+    }
+
+    const infraConfig = presetFromInfra.createConfig({ seasonId });
+    const finalConfig: LeagueScoringConfig = {
+      ...infraConfig,
+      scoringPresetId: preset.id,
+    };
+
+    await this.leagueScoringConfigRepository.save(finalConfig);
+
+    return {
+      leagueId: league.id,
+      seasonId,
+      scoringPresetId: preset.id,
+      scoringPresetName: preset.name,
+    };
+  }
+
+  private validate(command: CreateLeagueWithSeasonAndScoringCommand): void {
+    if (!command.name || command.name.trim().length === 0) {
+      throw new Error('League name is required');
+    }
+    if (!command.ownerId || command.ownerId.trim().length === 0) {
+      throw new Error('League ownerId is required');
+    }
+    if (!command.gameId || command.gameId.trim().length === 0) {
+      throw new Error('gameId is required');
+    }
+    if (!command.visibility) {
+      throw new Error('visibility is required');
+    }
+    if (command.maxDrivers !== undefined && command.maxDrivers <= 0) {
+      throw new Error('maxDrivers must be greater than 0 when provided');
+    }
+  }
+}

packages/racing/application/use-cases/GetAllLeaguesWithCapacityAndScoringQuery.ts

@@ -0,0 +1,163 @@
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
+import type { IGameRepository } from '../../domain/repositories/IGameRepository';
+import type {
+  LeagueScoringPresetProvider,
+  LeagueScoringPresetDTO,
+} from '../ports/LeagueScoringPresetProvider';
+import type {
+  LeagueSummaryDTO,
+  LeagueSummaryScoringDTO,
+} from '../dto/LeagueSummaryDTO';
+
+/**
+ * Combined capacity + scoring summary query for leagues.
+ *
+ * Extends the behavior of GetAllLeaguesWithCapacityQuery by including
+ * scoring preset and game summaries when an active season and
+ * LeagueScoringConfig are available.
+ */
+export class GetAllLeaguesWithCapacityAndScoringQuery {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly gameRepository: IGameRepository,
+    private readonly presetProvider: LeagueScoringPresetProvider,
+  ) {}
+
+  async execute(): Promise<LeagueSummaryDTO[]> {
+    const leagues = await this.leagueRepository.findAll();
+
+    const results: LeagueSummaryDTO[] = [];
+
+    for (const league of leagues) {
+      const members = await this.leagueMembershipRepository.getLeagueMembers(
+        league.id,
+      );
+
+      const usedDriverSlots = members.filter(
+        (m) =>
+          m.status === 'active' &&
+          (m.role === 'owner' ||
+            m.role === 'admin' ||
+            m.role === 'steward' ||
+            m.role === 'member'),
+      ).length;
+
+      const configuredMaxDrivers = league.settings.maxDrivers ?? usedDriverSlots;
+      const safeMaxDrivers = Math.max(configuredMaxDrivers, usedDriverSlots);
+
+      const scoringSummary = await this.buildScoringSummary(league.id);
+
+      const structureSummary = `Solo • ${safeMaxDrivers} drivers`;
+
+      const qualifyingMinutes = 30;
+      const mainRaceMinutes =
+        typeof league.settings.sessionDuration === 'number'
+          ? league.settings.sessionDuration
+          : 40;
+      const timingSummary = `${qualifyingMinutes} min Quali • ${mainRaceMinutes} min Race`;
+
+      const dto: LeagueSummaryDTO = {
+        id: league.id,
+        name: league.name,
+        description: league.description,
+        ownerId: league.ownerId,
+        createdAt: league.createdAt,
+        maxDrivers: safeMaxDrivers,
+        usedDriverSlots,
+        maxTeams: undefined,
+        usedTeamSlots: undefined,
+        structureSummary,
+        scoringPatternSummary: scoringSummary?.scoringPatternSummary,
+        timingSummary,
+        scoring: scoringSummary,
+      };
+
+      results.push(dto);
+    }
+
+    return results;
+  }
+
+  private async buildScoringSummary(
+    leagueId: string,
+  ): Promise<LeagueSummaryScoringDTO | undefined> {
+    const seasons = await this.seasonRepository.findByLeagueId(leagueId);
+    if (!seasons || seasons.length === 0) {
+      return undefined;
+    }
+
+    const activeSeason =
+      seasons.find((s) => s.status === 'active') ?? seasons[0];
+
+    const scoringConfig =
+      await this.leagueScoringConfigRepository.findBySeasonId(activeSeason.id);
+    if (!scoringConfig) {
+      return undefined;
+    }
+
+    const game = await this.gameRepository.findById(activeSeason.gameId);
+    if (!game) {
+      return undefined;
+    }
+
+    const presetId = scoringConfig.scoringPresetId;
+    let preset: LeagueScoringPresetDTO | undefined;
+    if (presetId) {
+      preset = this.presetProvider.getPresetById(presetId);
+    }
+
+    const dropPolicySummary =
+      preset?.dropPolicySummary ?? this.deriveDropPolicySummary(scoringConfig);
+    const primaryChampionshipType =
+      preset?.primaryChampionshipType ??
+      (scoringConfig.championships[0]?.type ?? 'driver');
+
+    const scoringPresetName = preset?.name ?? 'Custom';
+    const scoringPatternSummary = `${scoringPresetName} • ${dropPolicySummary}`;
+
+    return {
+      gameId: game.id,
+      gameName: game.name,
+      primaryChampionshipType,
+      scoringPresetId: presetId ?? 'custom',
+      scoringPresetName,
+      dropPolicySummary,
+      scoringPatternSummary,
+    };
+  }
+
+  private deriveDropPolicySummary(config: {
+    championships: Array<{
+      dropScorePolicy: { strategy: string; count?: number; dropCount?: number };
+    }>;
+  }): string {
+    const championship = config.championships[0];
+    if (!championship) {
+      return 'All results count';
+    }
+
+    const policy = championship.dropScorePolicy;
+    if (!policy || policy.strategy === 'none') {
+      return 'All results count';
+    }
+
+    if (policy.strategy === 'bestNResults' && typeof policy.count === 'number') {
+      return `Best ${policy.count} results count`;
+    }
+
+    if (
+      policy.strategy === 'dropWorstN' &&
+      typeof policy.dropCount === 'number'
+    ) {
+      return `Worst ${policy.dropCount} results are dropped`;
+    }
+
+    return 'Custom drop score rules';
+  }
+}

packages/racing/application/use-cases/GetLeagueFullConfigQuery.ts

@@ -0,0 +1,144 @@
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
+import type { IGameRepository } from '../../domain/repositories/IGameRepository';
+import type { ChampionshipConfig } from '../../domain/value-objects/ChampionshipConfig';
+import type { DropScorePolicy } from '../../domain/value-objects/DropScorePolicy';
+import type {
+  LeagueConfigFormModel,
+  LeagueDropPolicyFormDTO,
+} from '../dto/LeagueConfigFormDTO';
+
+/**
+ * Query returning a unified LeagueConfigFormModel for a given league.
+ *
+ * First iteration focuses on:
+ * - Basics derived from League
+ * - Simple solo structure derived from League.settings.maxDrivers
+ * - Championships flags with driver enabled and others disabled
+ * - Scoring pattern id taken from LeagueScoringConfig.scoringPresetId
+ * - Drop policy inferred from the primary championship configuration
+ */
+export class GetLeagueFullConfigQuery {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly gameRepository: IGameRepository,
+  ) {}
+
+  async execute(params: { leagueId: string }): Promise<LeagueConfigFormModel | null> {
+    const { leagueId } = params;
+
+    const league = await this.leagueRepository.findById(leagueId);
+    if (!league) {
+      return null;
+    }
+
+    const seasons = await this.seasonRepository.findByLeagueId(leagueId);
+    const activeSeason =
+      seasons && seasons.length > 0
+        ? seasons.find((s) => s.status === 'active') ?? seasons[0]
+        : null;
+
+    const scoringConfig = activeSeason
+      ? await this.leagueScoringConfigRepository.findBySeasonId(activeSeason.id)
+      : null;
+
+    const game =
+      activeSeason && activeSeason.gameId
+        ? await this.gameRepository.findById(activeSeason.gameId)
+        : null;
+
+    const patternId = scoringConfig?.scoringPresetId;
+
+    const primaryChampionship: ChampionshipConfig | undefined =
+      scoringConfig && scoringConfig.championships && scoringConfig.championships.length > 0
+        ? scoringConfig.championships[0]
+        : undefined;
+
+    const dropPolicy: DropScorePolicy | undefined =
+      primaryChampionship?.dropScorePolicy ?? undefined;
+
+    const dropPolicyForm: LeagueDropPolicyFormDTO = this.mapDropPolicy(dropPolicy);
+
+    const defaultQualifyingMinutes = 30;
+    const defaultMainRaceMinutes = 40;
+    const mainRaceMinutes =
+      typeof league.settings.sessionDuration === 'number'
+        ? league.settings.sessionDuration
+        : defaultMainRaceMinutes;
+    const qualifyingMinutes = defaultQualifyingMinutes;
+
+    const roundsPlanned = 8;
+
+    let sessionCount = 2;
+    if (
+      primaryChampionship &&
+      Array.isArray((primaryChampionship as any).sessionTypes) &&
+      (primaryChampionship as any).sessionTypes.length > 0
+    ) {
+      sessionCount = (primaryChampionship as any).sessionTypes.length;
+    }
+
+    const practiceMinutes = 20;
+    const sprintRaceMinutes = patternId === 'sprint-main-driver' ? 20 : undefined;
+
+    const form: LeagueConfigFormModel = {
+      leagueId: league.id,
+      basics: {
+        name: league.name,
+        description: league.description,
+        visibility: 'public', // current domain model does not track visibility; default to public for now
+        gameId: game?.id ?? 'iracing',
+      },
+      structure: {
+        // First slice: treat everything as solo structure based on maxDrivers
+        mode: 'solo',
+        maxDrivers: league.settings.maxDrivers ?? 32,
+        maxTeams: undefined,
+        driversPerTeam: undefined,
+        multiClassEnabled: false,
+      },
+      championships: {
+        enableDriverChampionship: true,
+        enableTeamChampionship: false,
+        enableNationsChampionship: false,
+        enableTrophyChampionship: false,
+      },
+      scoring: {
+        patternId: patternId ?? undefined,
+        customScoringEnabled: !patternId,
+      },
+      dropPolicy: dropPolicyForm,
+      timings: {
+        practiceMinutes,
+        qualifyingMinutes,
+        sprintRaceMinutes,
+        mainRaceMinutes,
+        sessionCount,
+        roundsPlanned,
+      },
+    };
+
+    return form;
+  }
+
+  private mapDropPolicy(policy: DropScorePolicy | undefined): LeagueDropPolicyFormDTO {
+    if (!policy || policy.strategy === 'none') {
+      return { strategy: 'none' };
+    }
+
+    if (policy.strategy === 'bestNResults') {
+      const n = typeof policy.count === 'number' ? policy.count : undefined;
+      return n !== undefined ? { strategy: 'bestNResults', n } : { strategy: 'none' };
+    }
+
+    if (policy.strategy === 'dropWorstN') {
+      const n = typeof policy.dropCount === 'number' ? policy.dropCount : undefined;
+      return n !== undefined ? { strategy: 'dropWorstN', n } : { strategy: 'none' };
+    }
+
+    return { strategy: 'none' };
+  }
+}

packages/racing/application/use-cases/GetLeagueScoringConfigQuery.ts

@@ -0,0 +1,190 @@
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
+import type { IGameRepository } from '../../domain/repositories/IGameRepository';
+import type { LeagueScoringConfigDTO } from '../dto/LeagueScoringConfigDTO';
+import type { LeagueScoringChampionshipDTO } from '../dto/LeagueScoringConfigDTO';
+import type {
+  LeagueScoringPresetProvider,
+  LeagueScoringPresetDTO,
+} from '../ports/LeagueScoringPresetProvider';
+import type { ChampionshipConfig } from '../../domain/value-objects/ChampionshipConfig';
+import type { PointsTable } from '../../domain/value-objects/PointsTable';
+import type { BonusRule } from '../../domain/value-objects/BonusRule';
+
+/**
+ * Query returning a league's scoring configuration for its active season.
+ *
+ * Designed for the league detail "Scoring" tab.
+ */
+export class GetLeagueScoringConfigQuery {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly gameRepository: IGameRepository,
+    private readonly presetProvider: LeagueScoringPresetProvider,
+  ) {}
+
+  async execute(params: { leagueId: string }): Promise<LeagueScoringConfigDTO | null> {
+    const { leagueId } = params;
+
+    const league = await this.leagueRepository.findById(leagueId);
+    if (!league) {
+      return null;
+    }
+
+    const seasons = await this.seasonRepository.findByLeagueId(leagueId);
+    if (!seasons || seasons.length === 0) {
+      return null;
+    }
+
+    const activeSeason =
+      seasons.find((s) => s.status === 'active') ?? seasons[0];
+
+    const scoringConfig =
+      await this.leagueScoringConfigRepository.findBySeasonId(activeSeason.id);
+    if (!scoringConfig) {
+      return null;
+    }
+
+    const game = await this.gameRepository.findById(activeSeason.gameId);
+    if (!game) {
+      return null;
+    }
+
+    const presetId = scoringConfig.scoringPresetId;
+    const preset: LeagueScoringPresetDTO | undefined =
+      presetId ? this.presetProvider.getPresetById(presetId) : undefined;
+
+    const championships: LeagueScoringChampionshipDTO[] =
+      scoringConfig.championships.map((champ) =>
+        this.mapChampionship(champ),
+      );
+
+    const dropPolicySummary =
+      preset?.dropPolicySummary ??
+      this.deriveDropPolicyDescriptionFromChampionships(
+        scoringConfig.championships,
+      );
+
+    return {
+      leagueId: league.id,
+      seasonId: activeSeason.id,
+      gameId: game.id,
+      gameName: game.name,
+      scoringPresetId: presetId,
+      scoringPresetName: preset?.name,
+      dropPolicySummary,
+      championships,
+    };
+  }
+
+  private mapChampionship(championship: ChampionshipConfig): LeagueScoringChampionshipDTO {
+    const sessionTypes = championship.sessionTypes.map((s) => s.toString());
+    const pointsPreview = this.buildPointsPreview(championship.pointsTableBySessionType);
+    const bonusSummary = this.buildBonusSummary(
+      championship.bonusRulesBySessionType ?? {},
+    );
+    const dropPolicyDescription = this.deriveDropPolicyDescription(
+      championship.dropScorePolicy,
+    );
+
+    return {
+      id: championship.id,
+      name: championship.name,
+      type: championship.type,
+      sessionTypes,
+      pointsPreview,
+      bonusSummary,
+      dropPolicyDescription,
+    };
+  }
+
+  private buildPointsPreview(
+    tables: Record<string, PointsTable>,
+  ): Array<{ sessionType: string; position: number; points: number }> {
+    const preview: Array<{
+      sessionType: string;
+      position: number;
+      points: number;
+    }> = [];
+
+    const maxPositions = 10;
+
+    for (const [sessionType, table] of Object.entries(tables)) {
+      for (let pos = 1; pos <= maxPositions; pos++) {
+        const points = table.getPoints(pos);
+        if (points && points !== 0) {
+          preview.push({
+            sessionType,
+            position: pos,
+            points,
+          });
+        }
+      }
+    }
+
+    return preview;
+  }
+
+  private buildBonusSummary(
+    bonusRulesBySessionType: Record<string, BonusRule[]>,
+  ): string[] {
+    const summaries: string[] = [];
+
+    for (const [sessionType, rules] of Object.entries(bonusRulesBySessionType)) {
+      for (const rule of rules) {
+        if (rule.type === 'fastestLap') {
+          const base = `Fastest lap in ${sessionType}`;
+          if (rule.requiresFinishInTopN) {
+            summaries.push(
+              `${base} +${rule.points} points if finishing P${rule.requiresFinishInTopN} or better`,
+            );
+          } else {
+            summaries.push(`${base} +${rule.points} points`);
+          }
+        } else {
+          summaries.push(
+            `${rule.type} bonus in ${sessionType} worth ${rule.points} points`,
+          );
+        }
+      }
+    }
+
+    return summaries;
+  }
+
+  private deriveDropPolicyDescriptionFromChampionships(
+    championships: ChampionshipConfig[],
+  ): string {
+    const first = championships[0];
+    if (!first) {
+      return 'All results count';
+    }
+    return this.deriveDropPolicyDescription(first.dropScorePolicy);
+  }
+
+  private deriveDropPolicyDescription(policy: {
+    strategy: string;
+    count?: number;
+    dropCount?: number;
+  }): string {
+    if (!policy || policy.strategy === 'none') {
+      return 'All results count';
+    }
+
+    if (policy.strategy === 'bestNResults' && typeof policy.count === 'number') {
+      return `Best ${policy.count} results count towards the championship`;
+    }
+
+    if (
+      policy.strategy === 'dropWorstN' &&
+      typeof policy.dropCount === 'number'
+    ) {
+      return `Worst ${policy.dropCount} results are dropped from the championship total`;
+    }
+
+    return 'Custom drop score rules apply';
+  }
+}

packages/racing/application/use-cases/ListLeagueScoringPresetsQuery.ts

@@ -0,0 +1,18 @@
+import type {
+  LeagueScoringPresetDTO,
+  LeagueScoringPresetProvider,
+} from '../ports/LeagueScoringPresetProvider';
+
+/**
+ * Read-only query exposing league scoring presets for UI consumption.
+ *
+ * Backed by the in-memory preset registry via a LeagueScoringPresetProvider
+ * implementation in the infrastructure layer.
+ */
+export class ListLeagueScoringPresetsQuery {
+  constructor(private readonly presetProvider: LeagueScoringPresetProvider) {}
+
+  async execute(): Promise<LeagueScoringPresetDTO[]> {
+    return this.presetProvider.listPresets();
+  }
+}

packages/racing/application/use-cases/PreviewLeagueScheduleQuery.ts

@@ -0,0 +1,90 @@
+import { SeasonScheduleGenerator } from '../../domain/services/SeasonScheduleGenerator';
+import type { LeagueSchedulePreviewDTO, LeagueScheduleDTO } from '../dto/LeagueScheduleDTO';
+import { scheduleDTOToSeasonSchedule } from '../dto/LeagueScheduleDTO';
+
+interface PreviewLeagueScheduleQueryParams {
+  schedule: LeagueScheduleDTO;
+  maxRounds?: number;
+}
+
+export class PreviewLeagueScheduleQuery {
+  constructor(
+    private readonly scheduleGenerator: typeof SeasonScheduleGenerator = SeasonScheduleGenerator,
+  ) {}
+
+  execute(params: PreviewLeagueScheduleQueryParams): LeagueSchedulePreviewDTO {
+    const seasonSchedule = scheduleDTOToSeasonSchedule(params.schedule);
+
+    const maxRounds =
+      params.maxRounds && params.maxRounds > 0
+        ? Math.min(params.maxRounds, seasonSchedule.plannedRounds)
+        : seasonSchedule.plannedRounds;
+
+    const slots = this.scheduleGenerator.generateSlotsUpTo(seasonSchedule, maxRounds);
+
+    const rounds = slots.map((slot) => ({
+      roundNumber: slot.roundNumber,
+      scheduledAt: slot.scheduledAt.toISOString(),
+      timezoneId: slot.timezone.getId(),
+    }));
+
+    const summary = this.buildSummary(params.schedule, rounds);
+
+    return {
+      rounds,
+      summary,
+    };
+  }
+
+  private buildSummary(
+    schedule: LeagueScheduleDTO,
+    rounds: Array<{ roundNumber: number; scheduledAt: string; timezoneId: string }>,
+  ): string {
+    if (rounds.length === 0) {
+      return 'No rounds scheduled.';
+    }
+
+    const first = new Date(rounds[0].scheduledAt);
+    const last = new Date(rounds[rounds.length - 1].scheduledAt);
+
+    const firstDate = first.toISOString().slice(0, 10);
+    const lastDate = last.toISOString().slice(0, 10);
+
+    const timePart = schedule.raceStartTime;
+    const tz = schedule.timezoneId;
+
+    let recurrenceDescription: string;
+
+    if (schedule.recurrenceStrategy === 'weekly') {
+      const days = (schedule.weekdays ?? []).join(', ');
+      recurrenceDescription = `Every ${days}`;
+    } else if (schedule.recurrenceStrategy === 'everyNWeeks') {
+      const interval = schedule.intervalWeeks ?? 1;
+      const days = (schedule.weekdays ?? []).join(', ');
+      recurrenceDescription = `Every ${interval} week(s) on ${days}`;
+    } else if (schedule.recurrenceStrategy === 'monthlyNthWeekday') {
+      const ordinalLabel = this.ordinalToLabel(schedule.monthlyOrdinal ?? 1);
+      const weekday = schedule.monthlyWeekday ?? 'Mon';
+      recurrenceDescription = `Every ${ordinalLabel} ${weekday}`;
+    } else {
+      recurrenceDescription = 'Custom recurrence';
+    }
+
+    return `${recurrenceDescription} at ${timePart} ${tz}, starting ${firstDate} — ${rounds.length} rounds from ${firstDate} to ${lastDate}.`;
+  }
+
+  private ordinalToLabel(ordinal: 1 | 2 | 3 | 4): string {
+    switch (ordinal) {
+      case 1:
+        return '1st';
+      case 2:
+        return '2nd';
+      case 3:
+        return '3rd';
+      case 4:
+        return '4th';
+      default:
+        return `${ordinal}th`;
+    }
+  }
+}