import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
import type { IResultRepository } from '../../domain/repositories/IResultRepository';
import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
import type { RaceDetailOutputPort } from '../ports/output/RaceDetailOutputPort';
import type { AsyncUseCase } from '@core/shared/application/AsyncUseCase';
import { Result } from '@core/shared/application/Result';
import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';

/**
 * Use Case: GetRaceDetailUseCase
 *
 * Given a race id and current driver id:
 * - When the race exists, it builds a view model with race, league, entry list, registration flags and user result.
 * - When the race does not exist, it presents a view model with an error and no race data.
 *
 * Given a completed race with a result for the driver:
 * - When computing rating change, it applies the same position-based formula used in the legacy UI.
 */
export interface GetRaceDetailQueryParams {
  raceId: string;
  driverId: string;
}

type GetRaceDetailErrorCode = 'RACE_NOT_FOUND';

export class GetRaceDetailUseCase
  implements AsyncUseCase<GetRaceDetailQueryParams, RaceDetailOutputPort, GetRaceDetailErrorCode>
{
  constructor(
    private readonly raceRepository: IRaceRepository,
    private readonly leagueRepository: ILeagueRepository,
    private readonly driverRepository: IDriverRepository,
    private readonly raceRegistrationRepository: IRaceRegistrationRepository,
    private readonly resultRepository: IResultRepository,
    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
  ) {}

  async execute(params: GetRaceDetailQueryParams): Promise<Result<RaceDetailOutputPort, ApplicationErrorCode<GetRaceDetailErrorCode>>> {
    const { raceId, driverId } = params;

    const race = await this.raceRepository.findById(raceId);
    if (!race) {
      return Result.err({ code: 'RACE_NOT_FOUND' });
    }

    const [league, registrations, membership] = await Promise.all([
      this.leagueRepository.findById(race.leagueId),
      this.raceRegistrationRepository.findByRaceId(race.id),
      this.leagueMembershipRepository.getMembership(race.leagueId, driverId),
    ]);

    const drivers = await Promise.all(
      registrations.map(registration => this.driverRepository.findById(registration.driverId.toString())),
    );

    const validDrivers = drivers.filter((driver): driver is NonNullable<typeof driver> => driver !== null);

    const isUserRegistered = registrations.some(reg => reg.driverId.toString() === driverId);
    const isUpcoming = race.status === 'scheduled' && race.scheduledAt > new Date();
    const canRegister = !!membership && membership.status === 'active' && isUpcoming;

    let userResult: Result | null = null;

    if (race.status === 'completed') {
      const results = await this.resultRepository.findByRaceId(race.id);
      userResult = results.find(r => r.driverId.toString() === driverId) ?? null;
    }

    const outputPort: RaceDetailOutputPort = {
      race,
      league,
      registrations,
      drivers: validDrivers,
      userResult,
      isUserRegistered,
      canRegister,
    };

    return Result.ok(outputPort);
  }

}