import { describe, it, expect, beforeEach } from 'vitest';
import { DriversTestContext } from '../DriversTestContext';
import { Driver } from '../../../../core/racing/domain/entities/Driver';

describe('GetDriversLeaderboardUseCase Integration', () => {
  let context: DriversTestContext;

  beforeEach(() => {
    context = DriversTestContext.create();
    context.clear();
  });

  describe('Success Path', () => {
    it('should retrieve complete list of drivers with all data', async () => {
      const drivers = [
        Driver.create({ id: 'd1', iracingId: '1', name: 'Driver 1', country: 'US' }),
        Driver.create({ id: 'd2', iracingId: '2', name: 'Driver 2', country: 'UK' }),
        Driver.create({ id: 'd3', iracingId: '3', name: 'Driver 3', country: 'DE' }),
      ];
      
      for (const d of drivers) {
        await context.driverRepository.create(d);
      }

      await context.driverStatsRepository.saveDriverStats('d1', {
        rating: 2000,
        totalRaces: 10,
        wins: 2,
        podiums: 5,
        overallRank: 1,
        safetyRating: 4.5,
        sportsmanshipRating: 95,
        dnfs: 0,
        avgFinish: 3.5,
        bestFinish: 1,
        worstFinish: 10,
        consistency: 85,
        experienceLevel: 'pro'
      });
      await context.driverStatsRepository.saveDriverStats('d2', {
        rating: 1800,
        totalRaces: 8,
        wins: 1,
        podiums: 3,
        overallRank: 2,
        safetyRating: 4.0,
        sportsmanshipRating: 90,
        dnfs: 1,
        avgFinish: 5.2,
        bestFinish: 1,
        worstFinish: 15,
        consistency: 75,
        experienceLevel: 'intermediate'
      });
      await context.driverStatsRepository.saveDriverStats('d3', {
        rating: 1500,
        totalRaces: 5,
        wins: 0,
        podiums: 1,
        overallRank: 3,
        safetyRating: 3.5,
        sportsmanshipRating: 80,
        dnfs: 0,
        avgFinish: 8.0,
        bestFinish: 3,
        worstFinish: 12,
        consistency: 65,
        experienceLevel: 'rookie'
      });

      const result = await context.getDriversLeaderboardUseCase.execute({});

      expect(result.isOk()).toBe(true);
      const leaderboard = result.unwrap();
      
      expect(leaderboard.items).toHaveLength(3);
      expect(leaderboard.totalRaces).toBe(23);
      expect(leaderboard.totalWins).toBe(3);
      expect(leaderboard.activeCount).toBe(3);

      expect(leaderboard.items[0]!.driver.id).toBe('d1');
      expect(leaderboard.items[1]!.driver.id).toBe('d2');
      expect(leaderboard.items[2]!.driver.id).toBe('d3');
      
      expect(leaderboard.items[0]!.rating).toBe(2000);
      expect(leaderboard.items[1]!.rating).toBe(1800);
      expect(leaderboard.items[2]!.rating).toBe(1500);
    });

    it('should handle empty drivers list', async () => {
      const result = await context.getDriversLeaderboardUseCase.execute({});

      expect(result.isOk()).toBe(true);
      const leaderboard = result.unwrap();
      expect(leaderboard.items).toHaveLength(0);
      expect(leaderboard.totalRaces).toBe(0);
      expect(leaderboard.totalWins).toBe(0);
      expect(leaderboard.activeCount).toBe(0);
    });

    it('should correctly identify active drivers', async () => {
      await context.driverRepository.create(Driver.create({ id: 'active', iracingId: '1', name: 'Active', country: 'US' }));
      await context.driverRepository.create(Driver.create({ id: 'inactive', iracingId: '2', name: 'Inactive', country: 'UK' }));
      
      await context.driverStatsRepository.saveDriverStats('active', {
        rating: 1500,
        totalRaces: 1,
        wins: 0,
        podiums: 0,
        overallRank: 1,
        safetyRating: 3.0,
        sportsmanshipRating: 70,
        dnfs: 0,
        avgFinish: 10,
        bestFinish: 10,
        worstFinish: 10,
        consistency: 50,
        experienceLevel: 'rookie'
      });
      await context.driverStatsRepository.saveDriverStats('inactive', {
        rating: 1000,
        totalRaces: 0,
        wins: 0,
        podiums: 0,
        overallRank: null,
        safetyRating: 2.5,
        sportsmanshipRating: 50,
        dnfs: 0,
        avgFinish: 0,
        bestFinish: 0,
        worstFinish: 0,
        consistency: 0,
        experienceLevel: 'rookie'
      });

      const result = await context.getDriversLeaderboardUseCase.execute({});

      const leaderboard = result.unwrap();
      expect(leaderboard.activeCount).toBe(1);
      expect(leaderboard.items.find(i => i.driver.id === 'active')?.isActive).toBe(true);
      expect(leaderboard.items.find(i => i.driver.id === 'inactive')?.isActive).toBe(false);
    });
  });

  describe('Error Handling', () => {
    it('should handle repository errors gracefully', async () => {
      const originalFindAll = context.driverRepository.findAll.bind(context.driverRepository);
      context.driverRepository.findAll = async () => {
        throw new Error('Repository error');
      };

      const result = await context.getDriversLeaderboardUseCase.execute({});

      expect(result.isErr()).toBe(true);
      const error = result.unwrapErr();
      expect(error.code).toBe('REPOSITORY_ERROR');

      context.driverRepository.findAll = originalFindAll;
    });
  });
});