import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
import { GetDriversLeaderboardUseCase } from './GetDriversLeaderboardUseCase';
import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
import type { IRankingService } from '../../domain/services/IRankingService';
import type { IDriverStatsService } from '../../domain/services/IDriverStatsService';
import type { IImageServicePort } from '../ports/IImageServicePort';
import type { Logger } from '@core/shared/application';

describe('GetDriversLeaderboardUseCase', () => {
  let mockDriverRepo: { findAll: Mock };
  let mockRankingService: { getAllDriverRankings: Mock };
  let mockDriverStatsService: { getDriverStats: Mock };
  let mockImageService: { getDriverAvatar: Mock };
  let mockLogger: Logger;

  beforeEach(() => {
    mockDriverRepo = { findAll: vi.fn() };
    mockRankingService = { getAllDriverRankings: vi.fn() };
    mockDriverStatsService = { getDriverStats: vi.fn() };
    mockImageService = { getDriverAvatar: vi.fn() };
    mockLogger = {
      debug: vi.fn(),
      info: vi.fn(),
      warn: vi.fn(),
      error: vi.fn(),
    };
  });

  it('should return drivers leaderboard data', async () => {
    const useCase = new GetDriversLeaderboardUseCase(
      mockDriverRepo as unknown as IDriverRepository,
      mockRankingService as unknown as IRankingService,
      mockDriverStatsService as unknown as IDriverStatsService,
      mockImageService as unknown as IImageServicePort,
      mockLogger,
    );

    const driver1 = { id: 'driver1', name: 'Driver One' };
    const driver2 = { id: 'driver2', name: 'Driver Two' };
    const rankings = { driver1: 1, driver2: 2 };
    const stats1 = { wins: 5, losses: 2 };
    const stats2 = { wins: 3, losses: 1 };

    mockDriverRepo.findAll.mockResolvedValue([driver1, driver2]);
    mockRankingService.getAllDriverRankings.mockReturnValue(rankings);
    mockDriverStatsService.getDriverStats.mockImplementation((id) => {
      if (id === 'driver1') return stats1;
      if (id === 'driver2') return stats2;
      return null;
    });
    mockImageService.getDriverAvatar.mockImplementation((id) => `avatar-${id}`);

    const result = await useCase.execute();

    expect(result.isOk()).toBe(true);
    expect(result.value).toEqual({
      drivers: [driver1, driver2],
      rankings,
      stats: { driver1: stats1, driver2: stats2 },
      avatarUrls: { driver1: 'avatar-driver1', driver2: 'avatar-driver2' },
    });
    expect(mockLogger.debug).toHaveBeenCalledWith('Executing GetDriversLeaderboardUseCase');
    expect(mockLogger.debug).toHaveBeenCalledWith('Successfully retrieved drivers leaderboard.');
  });

  it('should return empty result when no drivers', async () => {
    const useCase = new GetDriversLeaderboardUseCase(
      mockDriverRepo as unknown as IDriverRepository,
      mockRankingService as unknown as IRankingService,
      mockDriverStatsService as unknown as IDriverStatsService,
      mockImageService as unknown as IImageServicePort,
      mockLogger,
    );

    mockDriverRepo.findAll.mockResolvedValue([]);
    mockRankingService.getAllDriverRankings.mockReturnValue({});

    const result = await useCase.execute();

    expect(result.isOk()).toBe(true);
    expect(result.value).toEqual({
      drivers: [],
      rankings: {},
      stats: {},
      avatarUrls: {},
    });
  });

  it('should handle drivers without stats', async () => {
    const useCase = new GetDriversLeaderboardUseCase(
      mockDriverRepo as unknown as IDriverRepository,
      mockRankingService as unknown as IRankingService,
      mockDriverStatsService as unknown as IDriverStatsService,
      mockImageService as unknown as IImageServicePort,
      mockLogger,
    );

    const driver1 = { id: 'driver1', name: 'Driver One' };
    const rankings = { driver1: 1 };

    mockDriverRepo.findAll.mockResolvedValue([driver1]);
    mockRankingService.getAllDriverRankings.mockReturnValue(rankings);
    mockDriverStatsService.getDriverStats.mockReturnValue(null);
    mockImageService.getDriverAvatar.mockReturnValue('avatar-driver1');

    const result = await useCase.execute();

    expect(result.isOk()).toBe(true);
    expect(result.value).toEqual({
      drivers: [driver1],
      rankings,
      stats: {},
      avatarUrls: { driver1: 'avatar-driver1' },
    });
  });

  it('should return error when repository throws', async () => {
    const useCase = new GetDriversLeaderboardUseCase(
      mockDriverRepo as unknown as IDriverRepository,
      mockRankingService as unknown as IRankingService,
      mockDriverStatsService as unknown as IDriverStatsService,
      mockImageService as unknown as IImageServicePort,
      mockLogger,
    );

    const error = new Error('Repository error');
    mockDriverRepo.findAll.mockRejectedValue(error);

    const result = await useCase.execute();

    expect(result.isErr()).toBe(true);
    expect(result.unwrapErr().message).toBe('Repository error');
    expect(mockLogger.error).toHaveBeenCalledWith('Error executing GetDriversLeaderboardUseCase', error);
  });
});