import { describe, it, expect, vi } from 'vitest';
import { GetTeamsLeaderboardUseCase } from './GetTeamsLeaderboardUseCase';
import { Result } from '@core/shared/domain/Result';
import type { TeamRepository } from '../../domain/repositories/TeamRepository';
import type { TeamMembershipRepository } from '../../domain/repositories/TeamMembershipRepository';
import type { Logger } from '@core/shared/domain/Logger';
import type { Team } from '../../domain/entities/Team';

describe('GetTeamsLeaderboardUseCase', () => {
  const mockTeamRepository = {
    findAll: vi.fn(),
  } as unknown as TeamRepository;

  const mockTeamMembershipRepository = {
    getTeamMembers: vi.fn(),
  } as unknown as TeamMembershipRepository;

  const mockGetDriverStats = vi.fn();

  const mockLogger = {
    error: vi.fn(),
  } as unknown as Logger;

  const useCase = new GetTeamsLeaderboardUseCase(
    mockTeamRepository,
    mockTeamMembershipRepository,
    mockGetDriverStats,
    mockLogger
  );

  it('should return teams leaderboard with calculated stats', async () => {
    const mockTeam1 = { id: 'team-1', name: 'Team 1' } as unknown as Team;
    const mockTeam2 = { id: 'team-2', name: 'Team 2' } as unknown as Team;
    vi.mocked(mockTeamRepository.findAll).mockResolvedValue([mockTeam1, mockTeam2]);

    vi.mocked(mockTeamMembershipRepository.getTeamMembers).mockImplementation(async (teamId) => {
      if (teamId === 'team-1') return [{ driverId: 'driver-1' }, { driverId: 'driver-2' }] as any;
      if (teamId === 'team-2') return [{ driverId: 'driver-3' }] as any;
      return [];
    });

    mockGetDriverStats.mockImplementation((driverId) => {
      if (driverId === 'driver-1') return { rating: 1000, wins: 1, totalRaces: 5 };
      if (driverId === 'driver-2') return { rating: 2000, wins: 2, totalRaces: 10 };
      if (driverId === 'driver-3') return { rating: 1500, wins: 0, totalRaces: 2 };
      return null;
    });

    const result = await useCase.execute({ leagueId: 'league-1' });

    expect(result.isOk()).toBe(true);
    const data = result.unwrap();
    expect(data.items).toHaveLength(2);

    const item1 = data.items.find(i => i.team.id === 'team-1');
    expect(item1?.rating).toBe(1500); // (1000 + 2000) / 2
    expect(item1?.totalWins).toBe(3);
    expect(item1?.totalRaces).toBe(15);

    const item2 = data.items.find(i => i.team.id === 'team-2');
    expect(item2?.rating).toBe(1500);
    expect(item2?.totalWins).toBe(0);
    expect(item2?.totalRaces).toBe(2);

    expect(data.topItems).toHaveLength(2);
  });

  it('should handle teams with no members', async () => {
    const mockTeam = { id: 'team-empty', name: 'Empty Team' } as unknown as Team;
    vi.mocked(mockTeamRepository.findAll).mockResolvedValue([mockTeam]);
    vi.mocked(mockTeamMembershipRepository.getTeamMembers).mockResolvedValue([]);

    const result = await useCase.execute({ leagueId: 'league-1' });

    expect(result.isOk()).toBe(true);
    const data = result.unwrap();
    expect(data.items[0].rating).toBeNull();
    expect(data.items[0].performanceLevel).toBe('beginner');
  });

  it('should return error when repository fails', async () => {
    vi.mocked(mockTeamRepository.findAll).mockRejectedValue(new Error('DB Error'));

    const result = await useCase.execute({ leagueId: 'league-1' });

    expect(result.isErr()).toBe(true);
    expect(result.error.code).toBe('REPOSITORY_ERROR');
    expect(mockLogger.error).toHaveBeenCalled();
  });
});