import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
import type { IPenaltyRepository } from '../../domain/repositories/IPenaltyRepository';
import type { RaceResultsDetailViewModel, RaceResultsPenaltySummaryViewModel } from '../presenters/IRaceResultsDetailPresenter';
import type { AsyncUseCase } from '@core/shared/application/AsyncUseCase';
import { Result } from '@core/shared/application/Result';
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
import type { League } from '../../domain/entities/League';
import type { Result as DomainResult } from '../../domain/entities/Result';
import type { Penalty } from '../../domain/entities/Penalty';

export interface GetRaceResultsDetailParams {
  raceId: string;
  driverId?: string;
}


type GetRaceResultsDetailErrorCode = 'RACE_NOT_FOUND';

export class GetRaceResultsDetailUseCase implements AsyncUseCase<GetRaceResultsDetailParams, RaceResultsDetailViewModel, GetRaceResultsDetailErrorCode> {
  constructor(
    private readonly raceRepository: IRaceRepository,
    private readonly leagueRepository: ILeagueRepository,
    private readonly resultRepository: IResultRepository,
    private readonly driverRepository: IDriverRepository,
    private readonly penaltyRepository: IPenaltyRepository,
  ) {}

  async execute(params: GetRaceResultsDetailParams): Promise<Result<RaceResultsDetailViewModel, ApplicationErrorCode<GetRaceResultsDetailErrorCode>>> {
    const { raceId, driverId } = params;

    const race = await this.raceRepository.findById(raceId);

    if (!race) {
      return Result.err({ code: 'RACE_NOT_FOUND' });
    }

    const [league, results, drivers, penalties] = await Promise.all([
      this.leagueRepository.findById(race.leagueId),
      this.resultRepository.findByRaceId(raceId),
      this.driverRepository.findAll(),
      this.penaltyRepository.findByRaceId(raceId),
    ]);

    const effectiveCurrentDriverId =
      driverId ?? (drivers.length > 0 ? drivers[0]!.id : undefined);

    const pointsSystem = this.buildPointsSystem(league);
    const fastestLapTime = this.getFastestLapTime(results);
    const penaltySummary = this.mapPenaltySummary(penalties);

    const viewModel: RaceResultsDetailViewModel = {
      race: {
        id: race.id,
        leagueId: race.leagueId,
        track: race.track,
        scheduledAt: race.scheduledAt,
        status: race.status,
      },
      league: league
        ? {
            id: league.id,
            name: league.name,
          }
        : null,
      results,
      drivers,
      penalties: penaltySummary,
      ...(pointsSystem ? { pointsSystem } : {}),
      ...(fastestLapTime !== undefined ? { fastestLapTime } : {}),
      ...(effectiveCurrentDriverId ? { currentDriverId: effectiveCurrentDriverId } : {}),
    };

    return Result.ok(viewModel);
  }

  private buildPointsSystem(league: League | null): Record<number, number> | undefined {
    if (!league) return undefined;

    const pointsSystems: Record<string, Record<number, number>> = {
      'f1-2024': {
        1: 25,
        2: 18,
        3: 15,
        4: 12,
        5: 10,
        6: 8,
        7: 6,
        8: 4,
        9: 2,
        10: 1,
      },
      indycar: {
        1: 50,
        2: 40,
        3: 35,
        4: 32,
        5: 30,
        6: 28,
        7: 26,
        8: 24,
        9: 22,
        10: 20,
        11: 19,
        12: 18,
        13: 17,
        14: 16,
        15: 15,
      },
    };

    const customPoints = league.settings.customPoints;
    if (customPoints) {
      return customPoints;
    }

    const preset = pointsSystems[league.settings.pointsSystem];
    if (preset) {
      return preset;
    }

    return pointsSystems['f1-2024'];
  }

  private getFastestLapTime(results: DomainResult[]): number | undefined {
    if (results.length === 0) return undefined;
    return Math.min(...results.map((r) => r.fastestLap));
  }

  private mapPenaltySummary(penalties: Penalty[]): RaceResultsPenaltySummaryViewModel[] {
    return penalties.map((p) => ({
      driverId: p.driverId,
      type: p.type,
      ...(p.value !== undefined ? { value: p.value } : {}),
    }));
  }
}