import { describe, it, expect } from 'vitest';
import { DriversViewModelBuilder } from './DriversViewModelBuilder';
import type { DriversLeaderboardDTO } from '@/lib/types/generated/DriversLeaderboardDTO';

describe('DriversViewModelBuilder', () => {
  describe('happy paths', () => {
    it('should transform DriversLeaderboardDTO to DriverLeaderboardViewModel correctly', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers).toHaveLength(2);
      expect(result.drivers[0].id).toBe('driver-1');
      expect(result.drivers[0].name).toBe('Driver 1');
      expect(result.drivers[0].country).toBe('US');
      expect(result.drivers[0].avatarUrl).toBe('avatar-url');
      expect(result.drivers[0].rating).toBe(1500);
      expect(result.drivers[0].globalRank).toBe(1);
      expect(result.drivers[0].consistency).toBe(95);
      expect(result.drivers[1].id).toBe('driver-2');
      expect(result.drivers[1].name).toBe('Driver 2');
      expect(result.drivers[1].country).toBe('UK');
      expect(result.drivers[1].avatarUrl).toBe('avatar-url');
      expect(result.drivers[1].rating).toBe(1450);
      expect(result.drivers[1].globalRank).toBe(2);
      expect(result.drivers[1].consistency).toBe(90);
    });

    it('should handle empty drivers array', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers).toHaveLength(0);
    });

    it('should handle single driver', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers).toHaveLength(1);
    });

    it('should handle multiple drivers', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
          {
            id: 'driver-3',
            name: 'Driver 3',
            country: 'DE',
            avatarUrl: 'avatar-url',
            rating: 1400,
            globalRank: 3,
            consistency: 85,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers).toHaveLength(3);
    });
  });

  describe('data transformation', () => {
    it('should preserve all DTO fields in the output', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].id).toBe(driversLeaderboardDto.drivers[0].id);
      expect(result.drivers[0].name).toBe(driversLeaderboardDto.drivers[0].name);
      expect(result.drivers[0].country).toBe(driversLeaderboardDto.drivers[0].country);
      expect(result.drivers[0].avatarUrl).toBe(driversLeaderboardDto.drivers[0].avatarUrl);
      expect(result.drivers[0].rating).toBe(driversLeaderboardDto.drivers[0].rating);
      expect(result.drivers[0].globalRank).toBe(driversLeaderboardDto.drivers[0].globalRank);
      expect(result.drivers[0].consistency).toBe(driversLeaderboardDto.drivers[0].consistency);
    });

    it('should not modify the input DTO', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const originalDto = { ...driversLeaderboardDto };
      DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(driversLeaderboardDto).toEqual(originalDto);
    });
  });

  describe('edge cases', () => {
    it('should handle driver without avatar', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: null,
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].avatarUrl).toBeNull();
    });

    it('should handle driver without country', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: null,
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].country).toBeNull();
    });

    it('should handle driver without rating', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: null,
            globalRank: 1,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].rating).toBeNull();
    });

    it('should handle driver without global rank', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: null,
            consistency: 95,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].globalRank).toBeNull();
    });

    it('should handle driver without consistency', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: null,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].consistency).toBeNull();
    });

    it('should handle different countries', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
          {
            id: 'driver-3',
            name: 'Driver 3',
            country: 'DE',
            avatarUrl: 'avatar-url',
            rating: 1400,
            globalRank: 3,
            consistency: 85,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].country).toBe('US');
      expect(result.drivers[1].country).toBe('UK');
      expect(result.drivers[2].country).toBe('DE');
    });

    it('should handle different ratings', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
          {
            id: 'driver-3',
            name: 'Driver 3',
            country: 'DE',
            avatarUrl: 'avatar-url',
            rating: 1400,
            globalRank: 3,
            consistency: 85,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].rating).toBe(1500);
      expect(result.drivers[1].rating).toBe(1450);
      expect(result.drivers[2].rating).toBe(1400);
    });

    it('should handle different global ranks', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
          {
            id: 'driver-3',
            name: 'Driver 3',
            country: 'DE',
            avatarUrl: 'avatar-url',
            rating: 1400,
            globalRank: 3,
            consistency: 85,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].globalRank).toBe(1);
      expect(result.drivers[1].globalRank).toBe(2);
      expect(result.drivers[2].globalRank).toBe(3);
    });

    it('should handle different consistency values', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'Driver 1',
            country: 'US',
            avatarUrl: 'avatar-url',
            rating: 1500,
            globalRank: 1,
            consistency: 95,
          },
          {
            id: 'driver-2',
            name: 'Driver 2',
            country: 'UK',
            avatarUrl: 'avatar-url',
            rating: 1450,
            globalRank: 2,
            consistency: 90,
          },
          {
            id: 'driver-3',
            name: 'Driver 3',
            country: 'DE',
            avatarUrl: 'avatar-url',
            rating: 1400,
            globalRank: 3,
            consistency: 85,
          },
        ],
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers[0].consistency).toBe(95);
      expect(result.drivers[1].consistency).toBe(90);
      expect(result.drivers[2].consistency).toBe(85);
    });

    it('should handle large number of drivers', () => {
      const driversLeaderboardDto: DriversLeaderboardDTO = {
        drivers: Array.from({ length: 100 }, (_, i) => ({
          id: `driver-${i + 1}`,
          name: `Driver ${i + 1}`,
          country: 'US',
          avatarUrl: 'avatar-url',
          rating: 1500 - i,
          globalRank: i + 1,
          consistency: 95 - i * 0.1,
        })),
      };

      const result = DriversViewModelBuilder.build(driversLeaderboardDto);

      expect(result.drivers).toHaveLength(100);
      expect(result.drivers[0].id).toBe('driver-1');
      expect(result.drivers[99].id).toBe('driver-100');
    });
  });
});