/**
 * View Data Layer Tests - Drivers Functionality
 *
 * This test file covers the view data layer for drivers functionality.
 *
 * The view data layer is responsible for:
 * - DTO → UI model mapping
 * - Formatting, sorting, and grouping
 * - Derived fields and defaults
 * - UI-specific semantics
 *
 * This layer isolates the UI from API churn by providing a stable interface
 * between the API layer and the presentation layer.
 *
 * Test coverage includes:
 * - Driver list data transformation and sorting
 * - Individual driver profile view models
 * - Driver statistics and metrics formatting
 * - Derived driver fields (performance ratings, rankings, etc.)
 * - Default values and fallbacks for driver views
 * - Driver-specific formatting (lap times, points, positions, etc.)
 * - Data grouping and categorization for driver components
 * - Driver search and filtering view models
 * - Driver comparison data transformation
 */

import { DriversViewDataBuilder } from '@/lib/builders/view-data/DriversViewDataBuilder';
import { DriverProfileViewDataBuilder } from '@/lib/builders/view-data/DriverProfileViewDataBuilder';
import { RatingDisplay } from '@/lib/display-objects/RatingDisplay';
import { NumberDisplay } from '@/lib/display-objects/NumberDisplay';
import { DateDisplay } from '@/lib/display-objects/DateDisplay';
import { FinishDisplay } from '@/lib/display-objects/FinishDisplay';
import { PercentDisplay } from '@/lib/display-objects/PercentDisplay';
import type { DriversLeaderboardDTO } from '@/lib/types/generated/DriversLeaderboardDTO';
import type { DriverLeaderboardItemDTO } from '@/lib/types/generated/DriverLeaderboardItemDTO';
import type { GetDriverProfileOutputDTO } from '@/lib/types/generated/GetDriverProfileOutputDTO';
import type { DriverProfileDriverSummaryDTO } from '@/lib/types/generated/DriverProfileDriverSummaryDTO';
import type { DriverProfileStatsDTO } from '@/lib/types/generated/DriverProfileStatsDTO';
import type { DriverProfileFinishDistributionDTO } from '@/lib/types/generated/DriverProfileFinishDistributionDTO';
import type { DriverProfileTeamMembershipDTO } from '@/lib/types/generated/DriverProfileTeamMembershipDTO';
import type { DriverProfileSocialSummaryDTO } from '@/lib/types/generated/DriverProfileSocialSummaryDTO';
import type { DriverProfileExtendedProfileDTO } from '@/lib/types/generated/DriverProfileExtendedProfileDTO';

describe('DriversViewDataBuilder', () => {
  describe('happy paths', () => {
    it('should transform DriversLeaderboardDTO to DriversViewData correctly', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            category: 'Elite',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
            avatarUrl: 'https://example.com/john.jpg',
          },
          {
            id: 'driver-2',
            name: 'Jane Smith',
            rating: 1100.75,
            skillLevel: 'Advanced',
            category: 'Pro',
            nationality: 'Canada',
            racesCompleted: 120,
            wins: 15,
            podiums: 45,
            isActive: true,
            rank: 2,
            avatarUrl: 'https://example.com/jane.jpg',
          },
        ],
        totalRaces: 270,
        totalWins: 40,
        activeCount: 2,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers).toHaveLength(2);
      expect(result.drivers[0].id).toBe('driver-1');
      expect(result.drivers[0].name).toBe('John Doe');
      expect(result.drivers[0].rating).toBe(1234.56);
      expect(result.drivers[0].ratingLabel).toBe('1,235');
      expect(result.drivers[0].skillLevel).toBe('Pro');
      expect(result.drivers[0].category).toBe('Elite');
      expect(result.drivers[0].nationality).toBe('USA');
      expect(result.drivers[0].racesCompleted).toBe(150);
      expect(result.drivers[0].wins).toBe(25);
      expect(result.drivers[0].podiums).toBe(60);
      expect(result.drivers[0].isActive).toBe(true);
      expect(result.drivers[0].rank).toBe(1);
      expect(result.drivers[0].avatarUrl).toBe('https://example.com/john.jpg');

      expect(result.drivers[1].id).toBe('driver-2');
      expect(result.drivers[1].name).toBe('Jane Smith');
      expect(result.drivers[1].rating).toBe(1100.75);
      expect(result.drivers[1].ratingLabel).toBe('1,101');
      expect(result.drivers[1].skillLevel).toBe('Advanced');
      expect(result.drivers[1].category).toBe('Pro');
      expect(result.drivers[1].nationality).toBe('Canada');
      expect(result.drivers[1].racesCompleted).toBe(120);
      expect(result.drivers[1].wins).toBe(15);
      expect(result.drivers[1].podiums).toBe(45);
      expect(result.drivers[1].isActive).toBe(true);
      expect(result.drivers[1].rank).toBe(2);
      expect(result.drivers[1].avatarUrl).toBe('https://example.com/jane.jpg');

      expect(result.totalRaces).toBe(270);
      expect(result.totalRacesLabel).toBe('270');
      expect(result.totalWins).toBe(40);
      expect(result.totalWinsLabel).toBe('40');
      expect(result.activeCount).toBe(2);
      expect(result.activeCountLabel).toBe('2');
      expect(result.totalDriversLabel).toBe('2');
    });

    it('should handle drivers with missing optional fields', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

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

    it('should handle empty drivers array', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [],
        totalRaces: 0,
        totalWins: 0,
        activeCount: 0,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers).toEqual([]);
      expect(result.totalRaces).toBe(0);
      expect(result.totalRacesLabel).toBe('0');
      expect(result.totalWins).toBe(0);
      expect(result.totalWinsLabel).toBe('0');
      expect(result.activeCount).toBe(0);
      expect(result.activeCountLabel).toBe('0');
      expect(result.totalDriversLabel).toBe('0');
    });
  });

  describe('data transformation', () => {
    it('should preserve all DTO fields in the output', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            category: 'Elite',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
            avatarUrl: 'https://example.com/john.jpg',
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers[0].name).toBe(driversDTO.drivers[0].name);
      expect(result.drivers[0].nationality).toBe(driversDTO.drivers[0].nationality);
      expect(result.drivers[0].skillLevel).toBe(driversDTO.drivers[0].skillLevel);
      expect(result.totalRaces).toBe(driversDTO.totalRaces);
      expect(result.totalWins).toBe(driversDTO.totalWins);
      expect(result.activeCount).toBe(driversDTO.activeCount);
    });

    it('should not modify the input DTO', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            category: 'Elite',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
            avatarUrl: 'https://example.com/john.jpg',
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const originalDTO = JSON.parse(JSON.stringify(driversDTO));
      DriversViewDataBuilder.build(driversDTO);

      expect(driversDTO).toEqual(originalDTO);
    });

    it('should transform all numeric fields to formatted strings where appropriate', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      // Rating label should be a formatted string
      expect(typeof result.drivers[0].ratingLabel).toBe('string');
      expect(result.drivers[0].ratingLabel).toBe('1,235');

      // Total counts should be formatted strings
      expect(typeof result.totalRacesLabel).toBe('string');
      expect(result.totalRacesLabel).toBe('150');
      expect(typeof result.totalWinsLabel).toBe('string');
      expect(result.totalWinsLabel).toBe('25');
      expect(typeof result.activeCountLabel).toBe('string');
      expect(result.activeCountLabel).toBe('1');
      expect(typeof result.totalDriversLabel).toBe('string');
      expect(result.totalDriversLabel).toBe('1');
    });

    it('should handle large numbers correctly', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 999999.99,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 10000,
            wins: 2500,
            podiums: 5000,
            isActive: true,
            rank: 1,
          },
        ],
        totalRaces: 10000,
        totalWins: 2500,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers[0].ratingLabel).toBe('1,000,000');
      expect(result.totalRacesLabel).toBe('10000');
      expect(result.totalWinsLabel).toBe('2500');
      expect(result.activeCountLabel).toBe('1');
      expect(result.totalDriversLabel).toBe('1');
    });
  });

  describe('edge cases', () => {
    it('should handle null/undefined rating', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 0,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers[0].ratingLabel).toBe('0');
    });

    it('should handle drivers with no category', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: true,
            rank: 1,
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 1,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers[0].category).toBeUndefined();
    });

    it('should handle inactive drivers', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          {
            id: 'driver-1',
            name: 'John Doe',
            rating: 1234.56,
            skillLevel: 'Pro',
            nationality: 'USA',
            racesCompleted: 150,
            wins: 25,
            podiums: 60,
            isActive: false,
            rank: 1,
          },
        ],
        totalRaces: 150,
        totalWins: 25,
        activeCount: 0,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.drivers[0].isActive).toBe(false);
      expect(result.activeCount).toBe(0);
      expect(result.activeCountLabel).toBe('0');
    });
  });

  describe('derived fields', () => {
    it('should correctly calculate total drivers label', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          { id: 'driver-1', name: 'John Doe', rating: 1234.56, skillLevel: 'Pro', nationality: 'USA', racesCompleted: 150, wins: 25, podiums: 60, isActive: true, rank: 1 },
          { id: 'driver-2', name: 'Jane Smith', rating: 1100.75, skillLevel: 'Advanced', nationality: 'Canada', racesCompleted: 120, wins: 15, podiums: 45, isActive: true, rank: 2 },
          { id: 'driver-3', name: 'Bob Wilson', rating: 950.25, skillLevel: 'Intermediate', nationality: 'UK', racesCompleted: 80, wins: 5, podiums: 20, isActive: false, rank: 3 },
        ],
        totalRaces: 350,
        totalWins: 45,
        activeCount: 2,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.totalDriversLabel).toBe('3');
    });

    it('should correctly calculate active count', () => {
      const driversDTO: DriversLeaderboardDTO = {
        drivers: [
          { id: 'driver-1', name: 'John Doe', rating: 1234.56, skillLevel: 'Pro', nationality: 'USA', racesCompleted: 150, wins: 25, podiums: 60, isActive: true, rank: 1 },
          { id: 'driver-2', name: 'Jane Smith', rating: 1100.75, skillLevel: 'Advanced', nationality: 'Canada', racesCompleted: 120, wins: 15, podiums: 45, isActive: true, rank: 2 },
          { id: 'driver-3', name: 'Bob Wilson', rating: 950.25, skillLevel: 'Intermediate', nationality: 'UK', racesCompleted: 80, wins: 5, podiums: 20, isActive: false, rank: 3 },
        ],
        totalRaces: 350,
        totalWins: 45,
        activeCount: 2,
      };

      const result = DriversViewDataBuilder.build(driversDTO);

      expect(result.activeCount).toBe(2);
      expect(result.activeCountLabel).toBe('2');
    });
  });

  describe('rating formatting', () => {
    it('should format ratings with thousands separators', () => {
      expect(RatingDisplay.format(1234.56)).toBe('1,235');
      expect(RatingDisplay.format(9999.99)).toBe('10,000');
      expect(RatingDisplay.format(100000.5)).toBe('100,001');
    });

    it('should handle null/undefined ratings', () => {
      expect(RatingDisplay.format(null)).toBe('—');
      expect(RatingDisplay.format(undefined)).toBe('—');
    });

    it('should round ratings correctly', () => {
      expect(RatingDisplay.format(1234.4)).toBe('1,234');
      expect(RatingDisplay.format(1234.6)).toBe('1,235');
      expect(RatingDisplay.format(1234.5)).toBe('1,235');
    });
  });

  describe('number formatting', () => {
    it('should format numbers with thousands separators', () => {
      expect(NumberDisplay.format(1234567)).toBe('1,234,567');
      expect(NumberDisplay.format(1000)).toBe('1,000');
      expect(NumberDisplay.format(999)).toBe('999');
    });

    it('should handle decimal numbers', () => {
      expect(NumberDisplay.format(1234.567)).toBe('1,234.567');
      expect(NumberDisplay.format(1000.5)).toBe('1,000.5');
    });
  });
});

describe('DriverProfileViewDataBuilder', () => {
  describe('happy paths', () => {
    it('should transform GetDriverProfileOutputDTO to DriverProfileViewData correctly', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          avatarUrl: 'https://example.com/avatar.jpg',
          iracingId: '12345',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
          bio: 'Professional sim racer with 5 years of experience.',
          totalDrivers: 1000,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: 5.4,
          bestFinish: 1,
          worstFinish: 25,
          finishRate: 0.933,
          winRate: 0.167,
          podiumRate: 0.4,
          percentile: 95,
          rating: 1234.56,
          consistency: 85,
          overallRank: 42,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
        ],
        socialSummary: {
          friendsCount: 50,
          friends: [
            {
              id: 'friend-1',
              name: 'Jane Smith',
              country: 'Canada',
              avatarUrl: 'https://example.com/jane.jpg',
            },
          ],
        },
        extendedProfile: {
          socialHandles: [
            {
              platform: 'Twitter',
              handle: '@johndoe',
              url: 'https://twitter.com/johndoe',
            },
          ],
          achievements: [
            {
              id: 'ach-1',
              title: 'Champion',
              description: 'Won the championship',
              icon: 'trophy',
              rarity: 'Legendary',
              earnedAt: '2024-01-15T00:00:00Z',
            },
          ],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // Current driver
      expect(result.currentDriver).not.toBeNull();
      expect(result.currentDriver?.id).toBe('driver-123');
      expect(result.currentDriver?.name).toBe('John Doe');
      expect(result.currentDriver?.country).toBe('USA');
      expect(result.currentDriver?.avatarUrl).toBe('https://example.com/avatar.jpg');
      expect(result.currentDriver?.iracingId).toBe(12345);
      expect(result.currentDriver?.joinedAt).toBe('2024-01-15T00:00:00Z');
      expect(result.currentDriver?.joinedAtLabel).toBe('Jan 2024');
      expect(result.currentDriver?.rating).toBe(1234.56);
      expect(result.currentDriver?.ratingLabel).toBe('1,235');
      expect(result.currentDriver?.globalRank).toBe(42);
      expect(result.currentDriver?.globalRankLabel).toBe('#42');
      expect(result.currentDriver?.consistency).toBe(85);
      expect(result.currentDriver?.bio).toBe('Professional sim racer with 5 years of experience.');
      expect(result.currentDriver?.totalDrivers).toBe(1000);

      // Stats
      expect(result.stats).not.toBeNull();
      expect(result.stats?.totalRaces).toBe(150);
      expect(result.stats?.totalRacesLabel).toBe('150');
      expect(result.stats?.wins).toBe(25);
      expect(result.stats?.winsLabel).toBe('25');
      expect(result.stats?.podiums).toBe(60);
      expect(result.stats?.podiumsLabel).toBe('60');
      expect(result.stats?.dnfs).toBe(10);
      expect(result.stats?.dnfsLabel).toBe('10');
      expect(result.stats?.avgFinish).toBe(5.4);
      expect(result.stats?.avgFinishLabel).toBe('P5.4');
      expect(result.stats?.bestFinish).toBe(1);
      expect(result.stats?.bestFinishLabel).toBe('P1');
      expect(result.stats?.worstFinish).toBe(25);
      expect(result.stats?.worstFinishLabel).toBe('P25');
      expect(result.stats?.finishRate).toBe(0.933);
      expect(result.stats?.winRate).toBe(0.167);
      expect(result.stats?.podiumRate).toBe(0.4);
      expect(result.stats?.percentile).toBe(95);
      expect(result.stats?.rating).toBe(1234.56);
      expect(result.stats?.ratingLabel).toBe('1,235');
      expect(result.stats?.consistency).toBe(85);
      expect(result.stats?.consistencyLabel).toBe('85%');
      expect(result.stats?.overallRank).toBe(42);

      // Finish distribution
      expect(result.finishDistribution).not.toBeNull();
      expect(result.finishDistribution?.totalRaces).toBe(150);
      expect(result.finishDistribution?.wins).toBe(25);
      expect(result.finishDistribution?.podiums).toBe(60);
      expect(result.finishDistribution?.topTen).toBe(100);
      expect(result.finishDistribution?.dnfs).toBe(10);
      expect(result.finishDistribution?.other).toBe(55);

      // Team memberships
      expect(result.teamMemberships).toHaveLength(1);
      expect(result.teamMemberships[0].teamId).toBe('team-1');
      expect(result.teamMemberships[0].teamName).toBe('Elite Racing');
      expect(result.teamMemberships[0].teamTag).toBe('ER');
      expect(result.teamMemberships[0].role).toBe('Driver');
      expect(result.teamMemberships[0].joinedAt).toBe('2024-01-15T00:00:00Z');
      expect(result.teamMemberships[0].joinedAtLabel).toBe('Jan 2024');
      expect(result.teamMemberships[0].isCurrent).toBe(true);

      // Social summary
      expect(result.socialSummary.friendsCount).toBe(50);
      expect(result.socialSummary.friends).toHaveLength(1);
      expect(result.socialSummary.friends[0].id).toBe('friend-1');
      expect(result.socialSummary.friends[0].name).toBe('Jane Smith');
      expect(result.socialSummary.friends[0].country).toBe('Canada');
      expect(result.socialSummary.friends[0].avatarUrl).toBe('https://example.com/jane.jpg');

      // Extended profile
      expect(result.extendedProfile).not.toBeNull();
      expect(result.extendedProfile?.socialHandles).toHaveLength(1);
      expect(result.extendedProfile?.socialHandles[0].platform).toBe('Twitter');
      expect(result.extendedProfile?.socialHandles[0].handle).toBe('@johndoe');
      expect(result.extendedProfile?.socialHandles[0].url).toBe('https://twitter.com/johndoe');
      expect(result.extendedProfile?.achievements).toHaveLength(1);
      expect(result.extendedProfile?.achievements[0].id).toBe('ach-1');
      expect(result.extendedProfile?.achievements[0].title).toBe('Champion');
      expect(result.extendedProfile?.achievements[0].description).toBe('Won the championship');
      expect(result.extendedProfile?.achievements[0].icon).toBe('trophy');
      expect(result.extendedProfile?.achievements[0].rarity).toBe('Legendary');
      expect(result.extendedProfile?.achievements[0].rarityLabel).toBe('Legendary');
      expect(result.extendedProfile?.achievements[0].earnedAt).toBe('2024-01-15T00:00:00Z');
      expect(result.extendedProfile?.achievements[0].earnedAtLabel).toBe('Jan 15, 2024');
      expect(result.extendedProfile?.racingStyle).toBe('Aggressive');
      expect(result.extendedProfile?.favoriteTrack).toBe('Spa');
      expect(result.extendedProfile?.favoriteCar).toBe('Porsche 911 GT3');
      expect(result.extendedProfile?.timezone).toBe('America/New_York');
      expect(result.extendedProfile?.availableHours).toBe('Evenings');
      expect(result.extendedProfile?.lookingForTeam).toBe(false);
      expect(result.extendedProfile?.openToRequests).toBe(true);
    });

    it('should handle missing currentDriver gracefully', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver).toBeNull();
      expect(result.stats).not.toBeNull();
      expect(result.finishDistribution).not.toBeNull();
    });

    it('should handle missing stats gracefully', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver).not.toBeNull();
      expect(result.stats).toBeNull();
      expect(result.finishDistribution).not.toBeNull();
    });

    it('should handle missing finishDistribution gracefully', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver).not.toBeNull();
      expect(result.stats).not.toBeNull();
      expect(result.finishDistribution).toBeNull();
    });

    it('should handle missing extendedProfile gracefully', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver).not.toBeNull();
      expect(result.stats).not.toBeNull();
      expect(result.finishDistribution).not.toBeNull();
      expect(result.extendedProfile).toBeNull();
    });
  });

  describe('data transformation', () => {
    it('should preserve all DTO fields in the output', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          avatarUrl: 'https://example.com/avatar.jpg',
          iracingId: '12345',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
          bio: 'Professional sim racer.',
          totalDrivers: 1000,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: 5.4,
          bestFinish: 1,
          worstFinish: 25,
          finishRate: 0.933,
          winRate: 0.167,
          podiumRate: 0.4,
          percentile: 95,
          rating: 1234.56,
          consistency: 85,
          overallRank: 42,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
        ],
        socialSummary: {
          friendsCount: 50,
          friends: [
            {
              id: 'friend-1',
              name: 'Jane Smith',
              country: 'Canada',
              avatarUrl: 'https://example.com/jane.jpg',
            },
          ],
        },
        extendedProfile: {
          socialHandles: [
            {
              platform: 'Twitter',
              handle: '@johndoe',
              url: 'https://twitter.com/johndoe',
            },
          ],
          achievements: [
            {
              id: 'ach-1',
              title: 'Champion',
              description: 'Won the championship',
              icon: 'trophy',
              rarity: 'Legendary',
              earnedAt: '2024-01-15T00:00:00Z',
            },
          ],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.name).toBe(profileDTO.currentDriver?.name);
      expect(result.currentDriver?.country).toBe(profileDTO.currentDriver?.country);
      expect(result.currentDriver?.avatarUrl).toBe(profileDTO.currentDriver?.avatarUrl);
      expect(result.currentDriver?.iracingId).toBe(12345);
      expect(result.currentDriver?.joinedAt).toBe(profileDTO.currentDriver?.joinedAt);
      expect(result.currentDriver?.bio).toBe(profileDTO.currentDriver?.bio);
      expect(result.currentDriver?.totalDrivers).toBe(profileDTO.currentDriver?.totalDrivers);
    });

    it('should not modify the input DTO', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          avatarUrl: 'https://example.com/avatar.jpg',
          iracingId: '12345',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
          bio: 'Professional sim racer.',
          totalDrivers: 1000,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const originalDTO = JSON.parse(JSON.stringify(profileDTO));
      DriverProfileViewDataBuilder.build(profileDTO);

      expect(profileDTO).toEqual(originalDTO);
    });

    it('should transform all numeric fields to formatted strings where appropriate', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: 5.4,
          bestFinish: 1,
          worstFinish: 25,
          finishRate: 0.933,
          winRate: 0.167,
          podiumRate: 0.4,
          percentile: 95,
          rating: 1234.56,
          consistency: 85,
          overallRank: 42,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // Rating labels should be formatted strings
      expect(typeof result.currentDriver?.ratingLabel).toBe('string');
      expect(result.currentDriver?.ratingLabel).toBe('1,235');
      expect(typeof result.stats?.ratingLabel).toBe('string');
      expect(result.stats?.ratingLabel).toBe('1,235');

      // Rank labels should be formatted strings
      expect(typeof result.currentDriver?.globalRankLabel).toBe('string');
      expect(result.currentDriver?.globalRankLabel).toBe('#42');

      // Count labels should be formatted strings
      expect(typeof result.stats?.totalRacesLabel).toBe('string');
      expect(result.stats?.totalRacesLabel).toBe('150');
      expect(typeof result.stats?.winsLabel).toBe('string');
      expect(result.stats?.winsLabel).toBe('25');
      expect(typeof result.stats?.podiumsLabel).toBe('string');
      expect(result.stats?.podiumsLabel).toBe('60');
      expect(typeof result.stats?.dnfsLabel).toBe('string');
      expect(result.stats?.dnfsLabel).toBe('10');

      // Finish labels should be formatted strings
      expect(typeof result.stats?.avgFinishLabel).toBe('string');
      expect(result.stats?.avgFinishLabel).toBe('P5.4');
      expect(typeof result.stats?.bestFinishLabel).toBe('string');
      expect(result.stats?.bestFinishLabel).toBe('P1');
      expect(typeof result.stats?.worstFinishLabel).toBe('string');
      expect(result.stats?.worstFinishLabel).toBe('P25');

      // Consistency label should be formatted string
      expect(typeof result.stats?.consistencyLabel).toBe('string');
      expect(result.stats?.consistencyLabel).toBe('85%');
    });

    it('should handle iracingId as string and convert to number', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          iracingId: '12345',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.iracingId).toBe(12345);
    });

    it('should handle iracingId as number', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          iracingId: 12345,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.iracingId).toBe(12345);
    });

    it('should handle missing iracingId', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.iracingId).toBeNull();
    });

    it('should handle empty avatarUrl', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          avatarUrl: '',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.avatarUrl).toBe('');
    });

    it('should handle missing avatarUrl', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.avatarUrl).toBe('');
    });

    it('should handle missing avatarUrl in friends', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 1,
          friends: [
            {
              id: 'friend-1',
              name: 'Jane Smith',
              country: 'Canada',
            },
          ],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.socialSummary.friends[0].avatarUrl).toBe('');
    });

    it('should handle missing teamTag', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
        ],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.teamMemberships[0].teamTag).toBeNull();
    });
  });

  describe('edge cases', () => {
    it('should handle null/undefined rating in currentDriver', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: null,
          globalRank: null,
          consistency: null,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.currentDriver?.rating).toBeNull();
      expect(result.currentDriver?.ratingLabel).toBe('—');
      expect(result.currentDriver?.globalRank).toBeNull();
      expect(result.currentDriver?.globalRankLabel).toBe('—');
      expect(result.currentDriver?.consistency).toBeNull();
    });

    it('should handle null/undefined rating in stats', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          rating: null,
          consistency: null,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.stats?.rating).toBeNull();
      expect(result.stats?.ratingLabel).toBe('—');
      expect(result.stats?.consistency).toBeNull();
      expect(result.stats?.consistencyLabel).toBe('0%');
    });

    it('should handle null/undefined finish positions', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: null,
          bestFinish: null,
          worstFinish: null,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.stats?.avgFinish).toBeNull();
      expect(result.stats?.avgFinishLabel).toBe('—');
      expect(result.stats?.bestFinish).toBeNull();
      expect(result.stats?.bestFinishLabel).toBe('—');
      expect(result.stats?.worstFinish).toBeNull();
      expect(result.stats?.worstFinishLabel).toBe('—');
    });

    it('should handle null/undefined rates', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          finishRate: null,
          winRate: null,
          podiumRate: null,
          percentile: null,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.stats?.finishRate).toBeNull();
      expect(result.stats?.winRate).toBeNull();
      expect(result.stats?.podiumRate).toBeNull();
      expect(result.stats?.percentile).toBeNull();
    });

    it('should handle empty teamMemberships array', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.teamMemberships).toEqual([]);
    });

    it('should handle empty friends array', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.socialSummary.friends).toEqual([]);
      expect(result.socialSummary.friendsCount).toBe(0);
    });

    it('should handle empty socialHandles array', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
        extendedProfile: {
          socialHandles: [],
          achievements: [],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.extendedProfile?.socialHandles).toEqual([]);
    });

    it('should handle empty achievements array', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
        extendedProfile: {
          socialHandles: [],
          achievements: [],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.extendedProfile?.achievements).toEqual([]);
    });
  });

  describe('derived fields', () => {
    it('should correctly calculate finish distribution totals', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // Verify that finish distribution totals match the stats
      expect(result.finishDistribution?.totalRaces).toBe(150);
      expect(result.finishDistribution?.wins).toBe(25);
      expect(result.finishDistribution?.podiums).toBe(60);
      expect(result.finishDistribution?.dnfs).toBe(10);
    });

    it('should correctly calculate friend count', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 5,
          friends: [
            { id: 'friend-1', name: 'Alice', country: 'UK' },
            { id: 'friend-2', name: 'Bob', country: 'Germany' },
            { id: 'friend-3', name: 'Charlie', country: 'France' },
            { id: 'friend-4', name: 'Diana', country: 'USA' },
            { id: 'friend-5', name: 'Eve', country: 'Canada' },
          ],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.socialSummary.friendsCount).toBe(5);
      expect(result.socialSummary.friends).toHaveLength(5);
    });
  });

  describe('date formatting', () => {
    it('should format dates correctly', () => {
      expect(DateDisplay.formatShort('2024-01-15T00:00:00Z')).toBe('Jan 15, 2024');
      expect(DateDisplay.formatMonthYear('2024-01-15T00:00:00Z')).toBe('Jan 2024');
      expect(DateDisplay.formatShort('2024-12-25T00:00:00Z')).toBe('Dec 25, 2024');
      expect(DateDisplay.formatMonthYear('2024-12-25T00:00:00Z')).toBe('Dec 2024');
    });
  });

  describe('finish position formatting', () => {
    it('should format finish positions correctly', () => {
      expect(FinishDisplay.format(1)).toBe('P1');
      expect(FinishDisplay.format(5)).toBe('P5');
      expect(FinishDisplay.format(10)).toBe('P10');
      expect(FinishDisplay.format(100)).toBe('P100');
    });

    it('should handle null/undefined finish positions', () => {
      expect(FinishDisplay.format(null)).toBe('—');
      expect(FinishDisplay.format(undefined)).toBe('—');
    });

    it('should format average finish positions correctly', () => {
      expect(FinishDisplay.formatAverage(5.4)).toBe('P5.4');
      expect(FinishDisplay.formatAverage(1.5)).toBe('P1.5');
      expect(FinishDisplay.formatAverage(10.0)).toBe('P10.0');
    });

    it('should handle null/undefined average finish positions', () => {
      expect(FinishDisplay.formatAverage(null)).toBe('—');
      expect(FinishDisplay.formatAverage(undefined)).toBe('—');
    });
  });

  describe('percentage formatting', () => {
    it('should format percentages correctly', () => {
      expect(PercentDisplay.format(0.1234)).toBe('12.3%');
      expect(PercentDisplay.format(0.5)).toBe('50.0%');
      expect(PercentDisplay.format(1.0)).toBe('100.0%');
    });

    it('should handle null/undefined percentages', () => {
      expect(PercentDisplay.format(null)).toBe('0.0%');
      expect(PercentDisplay.format(undefined)).toBe('0.0%');
    });

    it('should format whole percentages correctly', () => {
      expect(PercentDisplay.formatWhole(85)).toBe('85%');
      expect(PercentDisplay.formatWhole(50)).toBe('50%');
      expect(PercentDisplay.formatWhole(100)).toBe('100%');
    });

    it('should handle null/undefined whole percentages', () => {
      expect(PercentDisplay.formatWhole(null)).toBe('0%');
      expect(PercentDisplay.formatWhole(undefined)).toBe('0%');
    });
  });

  describe('cross-component consistency', () => {
    it('should all use consistent formatting for numeric values', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: 5.4,
          bestFinish: 1,
          worstFinish: 25,
          finishRate: 0.933,
          winRate: 0.167,
          podiumRate: 0.4,
          percentile: 95,
          rating: 1234.56,
          consistency: 85,
          overallRank: 42,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // All numeric values should be formatted as strings
      expect(typeof result.currentDriver?.ratingLabel).toBe('string');
      expect(typeof result.currentDriver?.globalRankLabel).toBe('string');
      expect(typeof result.stats?.totalRacesLabel).toBe('string');
      expect(typeof result.stats?.winsLabel).toBe('string');
      expect(typeof result.stats?.podiumsLabel).toBe('string');
      expect(typeof result.stats?.dnfsLabel).toBe('string');
      expect(typeof result.stats?.avgFinishLabel).toBe('string');
      expect(typeof result.stats?.bestFinishLabel).toBe('string');
      expect(typeof result.stats?.worstFinishLabel).toBe('string');
      expect(typeof result.stats?.ratingLabel).toBe('string');
      expect(typeof result.stats?.consistencyLabel).toBe('string');
    });

    it('should all handle missing data gracefully', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 0,
          wins: 0,
          podiums: 0,
          dnfs: 0,
        },
        finishDistribution: {
          totalRaces: 0,
          wins: 0,
          podiums: 0,
          topTen: 0,
          dnfs: 0,
          other: 0,
        },
        teamMemberships: [],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // All fields should have safe defaults
      expect(result.currentDriver?.avatarUrl).toBe('');
      expect(result.currentDriver?.iracingId).toBeNull();
      expect(result.currentDriver?.rating).toBeNull();
      expect(result.currentDriver?.ratingLabel).toBe('—');
      expect(result.currentDriver?.globalRank).toBeNull();
      expect(result.currentDriver?.globalRankLabel).toBe('—');
      expect(result.currentDriver?.consistency).toBeNull();
      expect(result.currentDriver?.bio).toBeNull();
      expect(result.currentDriver?.totalDrivers).toBeNull();
      expect(result.stats?.avgFinish).toBeNull();
      expect(result.stats?.avgFinishLabel).toBe('—');
      expect(result.stats?.bestFinish).toBeNull();
      expect(result.stats?.bestFinishLabel).toBe('—');
      expect(result.stats?.worstFinish).toBeNull();
      expect(result.stats?.worstFinishLabel).toBe('—');
      expect(result.stats?.finishRate).toBeNull();
      expect(result.stats?.winRate).toBeNull();
      expect(result.stats?.podiumRate).toBeNull();
      expect(result.stats?.percentile).toBeNull();
      expect(result.stats?.rating).toBeNull();
      expect(result.stats?.ratingLabel).toBe('—');
      expect(result.stats?.consistency).toBeNull();
      expect(result.stats?.consistencyLabel).toBe('0%');
      expect(result.stats?.overallRank).toBeNull();
      expect(result.finishDistribution).not.toBeNull();
      expect(result.teamMemberships).toEqual([]);
      expect(result.socialSummary.friends).toEqual([]);
      expect(result.extendedProfile).toBeNull();
    });

    it('should all preserve ISO timestamps for serialization', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
        ],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
        extendedProfile: {
          socialHandles: [],
          achievements: [
            {
              id: 'ach-1',
              title: 'Champion',
              description: 'Won the championship',
              icon: 'trophy',
              rarity: 'Legendary',
              earnedAt: '2024-01-15T00:00:00Z',
            },
          ],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // All timestamps should be preserved as ISO strings
      expect(result.currentDriver?.joinedAt).toBe('2024-01-15T00:00:00Z');
      expect(result.teamMemberships[0].joinedAt).toBe('2024-01-15T00:00:00Z');
      expect(result.extendedProfile?.achievements[0].earnedAt).toBe('2024-01-15T00:00:00Z');
    });

    it('should all handle boolean flags correctly', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          joinedAt: '2024-01-15T00:00:00Z',
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
          {
            teamId: 'team-2',
            teamName: 'Old Team',
            teamTag: 'OT',
            role: 'Driver',
            joinedAt: '2023-01-15T00:00:00Z',
            isCurrent: false,
          },
        ],
        socialSummary: {
          friendsCount: 0,
          friends: [],
        },
        extendedProfile: {
          socialHandles: [],
          achievements: [],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: true,
          openToRequests: false,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      expect(result.teamMemberships[0].isCurrent).toBe(true);
      expect(result.teamMemberships[1].isCurrent).toBe(false);
      expect(result.extendedProfile?.lookingForTeam).toBe(true);
      expect(result.extendedProfile?.openToRequests).toBe(false);
    });
  });

  describe('data integrity', () => {
    it('should maintain data consistency across transformations', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          avatarUrl: 'https://example.com/avatar.jpg',
          iracingId: '12345',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 1234.56,
          globalRank: 42,
          consistency: 85,
          bio: 'Professional sim racer.',
          totalDrivers: 1000,
        },
        stats: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          dnfs: 10,
          avgFinish: 5.4,
          bestFinish: 1,
          worstFinish: 25,
          finishRate: 0.933,
          winRate: 0.167,
          podiumRate: 0.4,
          percentile: 95,
          rating: 1234.56,
          consistency: 85,
          overallRank: 42,
        },
        finishDistribution: {
          totalRaces: 150,
          wins: 25,
          podiums: 60,
          topTen: 100,
          dnfs: 10,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
        ],
        socialSummary: {
          friendsCount: 2,
          friends: [
            { id: 'friend-1', name: 'Alice', country: 'UK', avatarUrl: 'https://example.com/alice.jpg' },
            { id: 'friend-2', name: 'Bob', country: 'Germany' },
          ],
        },
        extendedProfile: {
          socialHandles: [
            { platform: 'Twitter', handle: '@johndoe', url: 'https://twitter.com/johndoe' },
          ],
          achievements: [
            { id: 'ach-1', title: 'Champion', description: 'Won the championship', icon: 'trophy', rarity: 'Legendary', earnedAt: '2024-01-15T00:00:00Z' },
          ],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // Verify derived fields match their source data
      expect(result.socialSummary.friendsCount).toBe(profileDTO.socialSummary.friends.length);
      expect(result.teamMemberships.length).toBe(profileDTO.teamMemberships.length);
      expect(result.extendedProfile?.achievements.length).toBe(profileDTO.extendedProfile?.achievements.length);
    });

    it('should handle complex real-world scenarios', () => {
      const profileDTO: GetDriverProfileOutputDTO = {
        currentDriver: {
          id: 'driver-123',
          name: 'John Doe',
          country: 'USA',
          avatarUrl: 'https://example.com/avatar.jpg',
          iracingId: '12345',
          joinedAt: '2024-01-15T00:00:00Z',
          rating: 2456.78,
          globalRank: 15,
          consistency: 92.5,
          bio: 'Professional sim racer with 5 years of experience. Specializes in GT3 racing.',
          totalDrivers: 1000,
        },
        stats: {
          totalRaces: 250,
          wins: 45,
          podiums: 120,
          dnfs: 15,
          avgFinish: 4.2,
          bestFinish: 1,
          worstFinish: 30,
          finishRate: 0.94,
          winRate: 0.18,
          podiumRate: 0.48,
          percentile: 98,
          rating: 2456.78,
          consistency: 92.5,
          overallRank: 15,
        },
        finishDistribution: {
          totalRaces: 250,
          wins: 45,
          podiums: 120,
          topTen: 180,
          dnfs: 15,
          other: 55,
        },
        teamMemberships: [
          {
            teamId: 'team-1',
            teamName: 'Elite Racing',
            teamTag: 'ER',
            role: 'Driver',
            joinedAt: '2024-01-15T00:00:00Z',
            isCurrent: true,
          },
          {
            teamId: 'team-2',
            teamName: 'Pro Team',
            teamTag: 'PT',
            role: 'Reserve Driver',
            joinedAt: '2023-06-15T00:00:00Z',
            isCurrent: false,
          },
        ],
        socialSummary: {
          friendsCount: 50,
          friends: [
            { id: 'friend-1', name: 'Alice', country: 'UK', avatarUrl: 'https://example.com/alice.jpg' },
            { id: 'friend-2', name: 'Bob', country: 'Germany' },
            { id: 'friend-3', name: 'Charlie', country: 'France', avatarUrl: 'https://example.com/charlie.jpg' },
          ],
        },
        extendedProfile: {
          socialHandles: [
            { platform: 'Twitter', handle: '@johndoe', url: 'https://twitter.com/johndoe' },
            { platform: 'Discord', handle: 'johndoe#1234', url: '' },
          ],
          achievements: [
            { id: 'ach-1', title: 'Champion', description: 'Won the championship', icon: 'trophy', rarity: 'Legendary', earnedAt: '2024-01-15T00:00:00Z' },
            { id: 'ach-2', title: 'Podium Finisher', description: 'Finished on podium 100 times', icon: 'medal', rarity: 'Rare', earnedAt: '2023-12-01T00:00:00Z' },
          ],
          racingStyle: 'Aggressive',
          favoriteTrack: 'Spa',
          favoriteCar: 'Porsche 911 GT3',
          timezone: 'America/New_York',
          availableHours: 'Evenings and Weekends',
          lookingForTeam: false,
          openToRequests: true,
        },
      };

      const result = DriverProfileViewDataBuilder.build(profileDTO);

      // Verify all transformations
      expect(result.currentDriver?.name).toBe('John Doe');
      expect(result.currentDriver?.ratingLabel).toBe('2,457');
      expect(result.currentDriver?.globalRankLabel).toBe('#15');
      expect(result.currentDriver?.consistency).toBe(92.5);
      expect(result.currentDriver?.bio).toBe('Professional sim racer with 5 years of experience. Specializes in GT3 racing.');

      expect(result.stats?.totalRacesLabel).toBe('250');
      expect(result.stats?.winsLabel).toBe('45');
      expect(result.stats?.podiumsLabel).toBe('120');
      expect(result.stats?.dnfsLabel).toBe('15');
      expect(result.stats?.avgFinishLabel).toBe('P4.2');
      expect(result.stats?.bestFinishLabel).toBe('P1');
      expect(result.stats?.worstFinishLabel).toBe('P30');
      expect(result.stats?.finishRate).toBe(0.94);
      expect(result.stats?.winRate).toBe(0.18);
      expect(result.stats?.podiumRate).toBe(0.48);
      expect(result.stats?.percentile).toBe(98);
      expect(result.stats?.ratingLabel).toBe('2,457');
      expect(result.stats?.consistencyLabel).toBe('92.5%');
      expect(result.stats?.overallRank).toBe(15);

      expect(result.finishDistribution?.totalRaces).toBe(250);
      expect(result.finishDistribution?.wins).toBe(45);
      expect(result.finishDistribution?.podiums).toBe(120);
      expect(result.finishDistribution?.topTen).toBe(180);
      expect(result.finishDistribution?.dnfs).toBe(15);
      expect(result.finishDistribution?.other).toBe(55);

      expect(result.teamMemberships).toHaveLength(2);
      expect(result.teamMemberships[0].isCurrent).toBe(true);
      expect(result.teamMemberships[1].isCurrent).toBe(false);

      expect(result.socialSummary.friendsCount).toBe(50);
      expect(result.socialSummary.friends).toHaveLength(3);
      expect(result.socialSummary.friends[0].avatarUrl).toBe('https://example.com/alice.jpg');
      expect(result.socialSummary.friends[1].avatarUrl).toBe('');
      expect(result.socialSummary.friends[2].avatarUrl).toBe('https://example.com/charlie.jpg');

      expect(result.extendedProfile?.socialHandles).toHaveLength(2);
      expect(result.extendedProfile?.achievements).toHaveLength(2);
      expect(result.extendedProfile?.achievements[0].rarityLabel).toBe('Legendary');
      expect(result.extendedProfile?.achievements[1].rarityLabel).toBe('Rare');
      expect(result.extendedProfile?.lookingForTeam).toBe(false);
      expect(result.extendedProfile?.openToRequests).toBe(true);
    });
  });
});
