import { describe, it, expect } from 'vitest';

import {
  InMemorySeasonRepository,
} from '@core/racing/infrastructure/repositories/InMemoryScoringRepositories';
import { Season } from '@core/racing/domain/entities/Season';
import type { ILeagueRepository } from '@core/racing/domain/repositories/ILeagueRepository';
import {
  GetSeasonDetailsUseCase,
} from '@core/racing/application/use-cases/GetSeasonDetailsUseCase';
import type { Logger } from '@core/shared/application';

const logger: Logger = {
  debug: () => {},
  info: () => {},
  warn: () => {},
  error: () => {},
};

function createFakeLeagueRepository(seed: Array<{ id: string }>): ILeagueRepository {
  return {
    findById: async (id: string) => seed.find((l) => l.id === id) ?? null,
    findAll: async () => seed,
    create: async (league: any) => league,
    update: async (league: any) => league,
  } as unknown as ILeagueRepository;
}

describe('GetSeasonDetailsUseCase', () => {
  it('returns full details for a season belonging to the league', async () => {
    const leagueRepo = createFakeLeagueRepository([{ id: 'league-1' }]);
    const seasonRepo = new InMemorySeasonRepository(logger);

    const season = Season.create({
      id: 'season-1',
      leagueId: 'league-1',
      gameId: 'iracing',
      name: 'Detailed Season',
      status: 'planned',
    }).withMaxDrivers(24);

    await seasonRepo.add(season);

    const useCase = new GetSeasonDetailsUseCase(leagueRepo, seasonRepo);

    const result = await useCase.execute({
      leagueId: 'league-1',
      seasonId: 'season-1',
    });

    expect(result.isOk()).toBe(true);
    const dto = result.value;
    expect(dto.seasonId).toBe('season-1');
    expect(dto.leagueId).toBe('league-1');
    expect(dto.gameId).toBe('iracing');
    expect(dto.name).toBe('Detailed Season');
    expect(dto.status).toBe('planned');
    expect(dto.maxDrivers).toBe(24);
  });
});