import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { RacesTestContext } from '../RacesTestContext';
import { GetRaceDetailUseCase } from '../../../../core/racing/application/use-cases/GetRaceDetailUseCase';
import { Race } from '../../../../core/racing/domain/entities/Race';
import { League } from '../../../../core/racing/domain/entities/League';
import { Driver } from '../../../../core/racing/domain/entities/Driver';

describe('GetRaceDetailUseCase', () => {
  let context: RacesTestContext;
  let getRaceDetailUseCase: GetRaceDetailUseCase;

  beforeAll(() => {
    context = RacesTestContext.create();
    getRaceDetailUseCase = new GetRaceDetailUseCase(
      context.raceRepository,
      context.leagueRepository,
      context.driverRepository,
      context.raceRegistrationRepository,
      context.resultRepository,
      context.leagueMembershipRepository
    );
  });

  beforeEach(async () => {
    await context.clear();
  });

  it('should retrieve race detail with complete information', async () => {
    // Given: A race and league exist
    const leagueId = 'l1';
    const league = League.create({ id: leagueId, name: 'Pro League', description: 'Desc', ownerId: 'o1' });
    await context.leagueRepository.create(league);

    const raceId = 'r1';
    const race = Race.create({
      id: raceId,
      leagueId,
      scheduledAt: new Date(Date.now() + 86400000),
      track: 'Spa',
      car: 'GT3',
      status: 'scheduled'
    });
    await context.raceRepository.create(race);

    // When: GetRaceDetailUseCase.execute() is called
    const result = await getRaceDetailUseCase.execute({ raceId });

    // Then: The result should contain race and league information
    expect(result.isOk()).toBe(true);
    const data = result.unwrap();
    expect(data.race.id).toBe(raceId);
    expect(data.league?.id.toString()).toBe(leagueId);
    expect(data.isUserRegistered).toBe(false);
  });

  it('should throw error when race does not exist', async () => {
    // When: GetRaceDetailUseCase.execute() is called with non-existent race ID
    const result = await getRaceDetailUseCase.execute({ raceId: 'non-existent' });

    // Then: Should return RACE_NOT_FOUND error
    expect(result.isErr()).toBe(true);
    expect(result.unwrapErr().code).toBe('RACE_NOT_FOUND');
  });

  it('should identify if a driver is registered', async () => {
    // Given: A race and a registered driver
    const leagueId = 'l1';
    const raceId = 'r1';
    const driverId = 'd1';
    
    const race = Race.create({
      id: raceId,
      leagueId,
      scheduledAt: new Date(Date.now() + 86400000),
      track: 'Spa',
      car: 'GT3',
      status: 'scheduled'
    });
    await context.raceRepository.create(race);

    const driver = Driver.create({ id: driverId, iracingId: '100', name: 'John Doe', country: 'US' });
    await context.driverRepository.create(driver);

    // Mock registration
    await context.raceRegistrationRepository.register({
      raceId: raceId as any,
      driverId: driverId as any,
      registeredAt: new Date()
    } as any);

    // When: GetRaceDetailUseCase.execute() is called with driverId
    const result = await getRaceDetailUseCase.execute({ raceId, driverId });

    // Then: isUserRegistered should be true
    expect(result.isOk()).toBe(true);
    expect(result.unwrap().isUserRegistered).toBe(true);
  });
});