import { describe, it, expect } from 'vitest';
import { TeamDetailViewDataBuilder } from './TeamDetailViewDataBuilder';
import type { TeamDetailPageDto } from '@/lib/page-queries/TeamDetailPageQuery';

describe('TeamDetailViewDataBuilder', () => {
  describe('happy paths', () => {
    it('should transform TeamDetailPageDto to TeamDetailViewData correctly', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-123',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1', 'league-2'],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English', 'German'],
          category: 'Professional',
          membership: 'open',
          canManage: true,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result).toEqual({
        team: {
          id: 'team-123',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1', 'league-2'],
          createdAt: '2024-01-01',
          foundedDateLabel: 'January 2024',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English', 'German'],
          category: 'Professional',
          membership: 'open',
          canManage: true,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            joinedAtLabel: 'Jan 1, 2024',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
        isAdmin: true,
        teamMetrics: [
          {
            icon: 'users',
            label: 'Members',
            value: '1',
            color: 'text-primary-blue',
          },
          {
            icon: 'zap',
            label: 'Est. Reach',
            value: '15',
            color: 'text-purple-400',
          },
          {
            icon: 'calendar',
            label: 'Races',
            value: '2',
            color: 'text-neon-aqua',
          },
          {
            icon: 'users',
            label: 'Engagement',
            value: '82%',
            color: 'text-performance-green',
          },
        ],
        tabs: [
          { id: 'overview', label: 'Overview', visible: true },
          { id: 'roster', label: 'Roster', visible: true },
          { id: 'standings', label: 'Standings', visible: true },
          { id: 'admin', label: 'Admin', visible: true },
        ],
        memberCountLabel: '1',
        leagueCountLabel: '2',
      });
    });

    it('should handle team without leagues', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-456',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'member',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.leagues).toHaveLength(0);
      expect(result.teamMetrics[2].value).toBe('0');
      expect(result.leagueCountLabel).toBe('0');
    });

    it('should handle team without members', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-789',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1'],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.memberships).toHaveLength(0);
      expect(result.teamMetrics[0].value).toBe('0');
      expect(result.teamMetrics[1].value).toBe('0');
      expect(result.memberCountLabel).toBe('0');
    });

    it('should handle multiple members', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-101',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1'],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-2',
            driverName: 'Driver 2',
            role: 'manager',
            joinedAt: '2024-01-02',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-3',
            driverName: 'Driver 3',
            role: 'member',
            joinedAt: '2024-01-03',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.memberships).toHaveLength(3);
      expect(result.teamMetrics[0].value).toBe('3');
      expect(result.teamMetrics[1].value).toBe('45');
      expect(result.memberCountLabel).toBe('3');
    });
  });

  describe('data transformation', () => {
    it('should preserve all DTO fields in the output', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-102',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1'],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: true,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.id).toBe(teamDetailPageDto.team.id);
      expect(result.team.name).toBe(teamDetailPageDto.team.name);
      expect(result.team.tag).toBe(teamDetailPageDto.team.tag);
      expect(result.team.description).toBe(teamDetailPageDto.team.description);
      expect(result.team.ownerId).toBe(teamDetailPageDto.team.ownerId);
      expect(result.team.leagues).toEqual(teamDetailPageDto.team.leagues);
      expect(result.team.createdAt).toBe(teamDetailPageDto.team.createdAt);
      expect(result.team.specialization).toBe(teamDetailPageDto.team.specialization);
      expect(result.team.region).toBe(teamDetailPageDto.team.region);
      expect(result.team.languages).toEqual(teamDetailPageDto.team.languages);
      expect(result.team.category).toBe(teamDetailPageDto.team.category);
      expect(result.team.membership).toBe(teamDetailPageDto.team.membership);
      expect(result.team.canManage).toBe(teamDetailPageDto.team.canManage);
      expect(result.currentDriverId).toBe(teamDetailPageDto.currentDriverId);
    });

    it('should not modify the input DTO', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-103',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const originalDto = { ...teamDetailPageDto };
      TeamDetailViewDataBuilder.build(teamDetailPageDto);

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

  describe('edge cases', () => {
    it('should handle team without createdAt', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-104',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: null,
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.foundedDateLabel).toBe('Unknown');
    });

    it('should handle team without description', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-105',
          name: 'Test Team',
          tag: 'TT',
          description: null,
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.description).toBeNull();
    });

    it('should handle team without tag', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-106',
          name: 'Test Team',
          tag: null,
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.tag).toBeNull();
    });

    it('should handle team without specialization', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-107',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: null,
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.specialization).toBeNull();
    });

    it('should handle team without region', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-108',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: null,
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.region).toBeNull();
    });

    it('should handle team without languages', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-109',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: null,
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.languages).toBeNull();
    });

    it('should handle team without category', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-110',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: null,
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.category).toBeNull();
    });

    it('should handle team without membership', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-111',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: null,
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.membership).toBeNull();
    });

    it('should handle member without avatar', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-112',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: null,
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

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

    it('should handle member without role', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-113',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: null,
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.memberships[0].role).toBeNull();
    });

    it('should handle member without isActive', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-114',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: null,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.memberships[0].isActive).toBeNull();
    });

    it('should handle current driver not in members', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-115',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-2',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.isAdmin).toBe(false);
      expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
    });

    it('should handle current driver as manager', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-116',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'manager',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.isAdmin).toBe(true);
      expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(true);
    });

    it('should handle current driver as member', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-117',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'member',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.isAdmin).toBe(false);
      expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
    });

    it('should handle current driver as steward', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-118',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'steward',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.isAdmin).toBe(false);
      expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
    });

    it('should handle different membership types', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-119',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'closed',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.membership).toBe('closed');
    });

    it('should handle different categories', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-120',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Amateur',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.category).toBe('Amateur');
    });

    it('should handle different specializations', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-121',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Endurance',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.specialization).toBe('Endurance');
    });

    it('should handle different regions', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-122',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'NA',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.region).toBe('NA');
    });

    it('should handle multiple languages', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-123',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English', 'German', 'French'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.languages).toEqual(['English', 'German', 'French']);
    });

    it('should handle empty languages array', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-124',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: [],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.languages).toEqual([]);
    });

    it('should handle empty leagues array', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-125',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.leagues).toEqual([]);
    });

    it('should handle large number of leagues', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-126',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: ['league-1', 'league-2', 'league-3', 'league-4', 'league-5'],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.team.leagues).toHaveLength(5);
      expect(result.teamMetrics[2].value).toBe('5');
      expect(result.leagueCountLabel).toBe('5');
    });

    it('should handle large number of members', () => {
      const teamDetailPageDto: TeamDetailPageDto = {
        team: {
          id: 'team-127',
          name: 'Test Team',
          tag: 'TT',
          description: 'Test Description',
          ownerId: 'owner-1',
          leagues: [],
          createdAt: '2024-01-01',
          specialization: 'Racing',
          region: 'EU',
          languages: ['English'],
          category: 'Professional',
          membership: 'open',
          canManage: false,
        },
        memberships: [
          {
            driverId: 'driver-1',
            driverName: 'Driver 1',
            role: 'owner',
            joinedAt: '2024-01-01',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-2',
            driverName: 'Driver 2',
            role: 'member',
            joinedAt: '2024-01-02',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-3',
            driverName: 'Driver 3',
            role: 'member',
            joinedAt: '2024-01-03',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-4',
            driverName: 'Driver 4',
            role: 'member',
            joinedAt: '2024-01-04',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
          {
            driverId: 'driver-5',
            driverName: 'Driver 5',
            role: 'member',
            joinedAt: '2024-01-05',
            isActive: true,
            avatarUrl: 'avatar-url',
          },
        ],
        currentDriverId: 'driver-1',
      };

      const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);

      expect(result.memberships).toHaveLength(5);
      expect(result.teamMetrics[0].value).toBe('5');
      expect(result.teamMetrics[1].value).toBe('75');
      expect(result.memberCountLabel).toBe('5');
    });
  });
});