import { Inject, Injectable } from '@nestjs/common';

// DTOs
import { GetRaceDetailParamsDTO } from './dtos/GetRaceDetailParamsDTO';
import { ImportRaceResultsDTO } from './dtos/ImportRaceResultsDTO';
import { RaceActionParamsDTO } from './dtos/RaceActionParamsDTO';
import { RegisterForRaceParamsDTO } from './dtos/RegisterForRaceParamsDTO';
import { WithdrawFromRaceParamsDTO } from './dtos/WithdrawFromRaceParamsDTO';

// Core imports
import type { Logger } from '@core/shared/application/Logger';

// Use cases
import { CancelRaceUseCase } from '@core/racing/application/use-cases/CancelRaceUseCase';
import { CompleteRaceUseCase } from '@core/racing/application/use-cases/CompleteRaceUseCase';
import { FileProtestUseCase } from '@core/racing/application/use-cases/FileProtestUseCase';
import { GetAllRacesPageDataUseCase } from '@core/racing/application/use-cases/GetAllRacesPageDataUseCase';
import { GetAllRacesUseCase } from '@core/racing/application/use-cases/GetAllRacesUseCase';
import { GetRaceDetailUseCase } from '@core/racing/application/use-cases/GetRaceDetailUseCase';
import { GetRacePenaltiesUseCase } from '@core/racing/application/use-cases/GetRacePenaltiesUseCase';
import { GetRaceProtestsUseCase } from '@core/racing/application/use-cases/GetRaceProtestsUseCase';
import { GetRaceResultsDetailUseCase } from '@core/racing/application/use-cases/GetRaceResultsDetailUseCase';
import { GetRacesPageDataUseCase } from '@core/racing/application/use-cases/GetRacesPageDataUseCase';
import { GetRaceWithSOFUseCase } from '@core/racing/application/use-cases/GetRaceWithSOFUseCase';
import { GetTotalRacesUseCase } from '@core/racing/application/use-cases/GetTotalRacesUseCase';
import { ImportRaceResultsApiUseCase } from '@core/racing/application/use-cases/ImportRaceResultsApiUseCase';
import { QuickPenaltyUseCase } from '@core/racing/application/use-cases/QuickPenaltyUseCase';
import { RegisterForRaceUseCase } from '@core/racing/application/use-cases/RegisterForRaceUseCase';
import { ReopenRaceUseCase } from '@core/racing/application/use-cases/ReopenRaceUseCase';
import { RequestProtestDefenseUseCase } from '@core/racing/application/use-cases/RequestProtestDefenseUseCase';
import { ReviewProtestUseCase } from '@core/racing/application/use-cases/ReviewProtestUseCase';
import { WithdrawFromRaceUseCase } from '@core/racing/application/use-cases/WithdrawFromRaceUseCase';

// Presenters
import { AllRacesPageDataPresenter } from './presenters/AllRacesPageDataPresenter';
import { CommandResultPresenter } from './presenters/CommandResultPresenter';
import { GetAllRacesPresenter } from './presenters/GetAllRacesPresenter';
import { GetTotalRacesPresenter } from './presenters/GetTotalRacesPresenter';
import { ImportRaceResultsApiPresenter } from './presenters/ImportRaceResultsApiPresenter';
import { RaceDetailPresenter } from './presenters/RaceDetailPresenter';
import { RacePenaltiesPresenter } from './presenters/RacePenaltiesPresenter';
import { RaceProtestsPresenter } from './presenters/RaceProtestsPresenter';
import { RaceResultsDetailPresenter } from './presenters/RaceResultsDetailPresenter';
import { RacesPageDataPresenter } from './presenters/RacesPageDataPresenter';
import { RaceWithSOFPresenter } from './presenters/RaceWithSOFPresenter';

// Command DTOs
import { ApplyPenaltyCommandDTO } from './dtos/ApplyPenaltyCommandDTO';
import { FileProtestCommandDTO } from './dtos/FileProtestCommandDTO';
import { QuickPenaltyCommandDTO } from './dtos/QuickPenaltyCommandDTO';
import { RequestProtestDefenseCommandDTO } from './dtos/RequestProtestDefenseCommandDTO';
import { ReviewProtestCommandDTO } from './dtos/ReviewProtestCommandDTO';

// Tokens
import { ApplyPenaltyUseCase } from '@core/racing/application/use-cases/ApplyPenaltyUseCase';
import {
  ALL_RACES_PAGE_DATA_PRESENTER_TOKEN,
  COMMAND_RESULT_PRESENTER_TOKEN,
  GET_ALL_RACES_PRESENTER_TOKEN,
  GET_TOTAL_RACES_PRESENTER_TOKEN,
  IMPORT_RACE_RESULTS_API_PRESENTER_TOKEN,
  LOGGER_TOKEN,
  RACE_DETAIL_PRESENTER_TOKEN,
  RACE_PENALTIES_PRESENTER_TOKEN,
  RACE_PROTESTS_PRESENTER_TOKEN,
  RACE_RESULTS_DETAIL_PRESENTER_TOKEN,
  RACE_WITH_SOF_PRESENTER_TOKEN,
  RACES_PAGE_DATA_PRESENTER_TOKEN
} from './RaceProviders';

@Injectable()
export class RaceService {
  constructor(
    private readonly getAllRacesUseCase: GetAllRacesUseCase,
    private readonly getTotalRacesUseCase: GetTotalRacesUseCase,
    private readonly importRaceResultsApiUseCase: ImportRaceResultsApiUseCase,
    private readonly getRaceDetailUseCase: GetRaceDetailUseCase,
    private readonly getRacesPageDataUseCase: GetRacesPageDataUseCase,
    private readonly getAllRacesPageDataUseCase: GetAllRacesPageDataUseCase,
    private readonly getRaceResultsDetailUseCase: GetRaceResultsDetailUseCase,
    private readonly getRaceWithSOFUseCase: GetRaceWithSOFUseCase,
    private readonly getRaceProtestsUseCase: GetRaceProtestsUseCase,
    private readonly getRacePenaltiesUseCase: GetRacePenaltiesUseCase,
    private readonly registerForRaceUseCase: RegisterForRaceUseCase,
    private readonly withdrawFromRaceUseCase: WithdrawFromRaceUseCase,
    private readonly cancelRaceUseCase: CancelRaceUseCase,
    private readonly completeRaceUseCase: CompleteRaceUseCase,
    private readonly fileProtestUseCase: FileProtestUseCase,
    private readonly quickPenaltyUseCase: QuickPenaltyUseCase,
    private readonly applyPenaltyUseCase: ApplyPenaltyUseCase,
    private readonly requestProtestDefenseUseCase: RequestProtestDefenseUseCase,
    private readonly reviewProtestUseCase: ReviewProtestUseCase,
    private readonly reopenRaceUseCase: ReopenRaceUseCase,
    @Inject(LOGGER_TOKEN) private readonly logger: Logger,
    // Injected presenters
    @Inject(GET_ALL_RACES_PRESENTER_TOKEN) private readonly getAllRacesPresenter: GetAllRacesPresenter,
    @Inject(GET_TOTAL_RACES_PRESENTER_TOKEN) private readonly getTotalRacesPresenter: GetTotalRacesPresenter,
    @Inject(IMPORT_RACE_RESULTS_API_PRESENTER_TOKEN) private readonly importRaceResultsApiPresenter: ImportRaceResultsApiPresenter,
    @Inject(RACE_DETAIL_PRESENTER_TOKEN) private readonly raceDetailPresenter: RaceDetailPresenter,
    @Inject(RACES_PAGE_DATA_PRESENTER_TOKEN) private readonly racesPageDataPresenter: RacesPageDataPresenter,
    @Inject(ALL_RACES_PAGE_DATA_PRESENTER_TOKEN) private readonly allRacesPageDataPresenter: AllRacesPageDataPresenter,
    @Inject(RACE_RESULTS_DETAIL_PRESENTER_TOKEN) private readonly raceResultsDetailPresenter: RaceResultsDetailPresenter,
    @Inject(RACE_WITH_SOF_PRESENTER_TOKEN) private readonly raceWithSOFPresenter: RaceWithSOFPresenter,
    @Inject(RACE_PROTESTS_PRESENTER_TOKEN) private readonly raceProtestsPresenter: RaceProtestsPresenter,
    @Inject(RACE_PENALTIES_PRESENTER_TOKEN) private readonly racePenaltiesPresenter: RacePenaltiesPresenter,
    @Inject(COMMAND_RESULT_PRESENTER_TOKEN) private readonly commandResultPresenter: CommandResultPresenter,
  ) {}

  async getAllRaces(): Promise<GetAllRacesPresenter> {
    this.logger.debug('[RaceService] Fetching all races.');
    await this.getAllRacesUseCase.execute({});
    return this.getAllRacesPresenter;
  }

  async getTotalRaces(): Promise<GetTotalRacesPresenter> {
    this.logger.debug('[RaceService] Fetching total races count.');
    await this.getTotalRacesUseCase.execute({});
    return this.getTotalRacesPresenter;
  }

  async importRaceResults(input: ImportRaceResultsDTO): Promise<ImportRaceResultsApiPresenter> {
    this.logger.debug('Importing race results:', input);
    await this.importRaceResultsApiUseCase.execute({ raceId: input.raceId, resultsFileContent: input.resultsFileContent });
    return this.importRaceResultsApiPresenter;
  }

  async getRaceDetail(params: GetRaceDetailParamsDTO): Promise<RaceDetailPresenter> {
    this.logger.debug('[RaceService] Fetching race detail:', params);
    await this.getRaceDetailUseCase.execute(params);
    return this.raceDetailPresenter;
  }

  async getRacesPageData(leagueId: string): Promise<RacesPageDataPresenter> {
    this.logger.debug('[RaceService] Fetching races page data.');
    await this.getRacesPageDataUseCase.execute({ leagueId });
    return this.racesPageDataPresenter;
  }

  async getAllRacesPageData(): Promise<AllRacesPageDataPresenter> {
    this.logger.debug('[RaceService] Fetching all races page data.');
    await this.getAllRacesPageDataUseCase.execute({});
    return this.allRacesPageDataPresenter;
  }

  async getRaceResultsDetail(raceId: string): Promise<RaceResultsDetailPresenter> {
    this.logger.debug('[RaceService] Fetching race results detail:', { raceId });
    await this.getRaceResultsDetailUseCase.execute({ raceId });
    return this.raceResultsDetailPresenter;
  }

  async getRaceWithSOF(raceId: string): Promise<RaceWithSOFPresenter> {
    this.logger.debug('[RaceService] Fetching race with SOF:', { raceId });
    await this.getRaceWithSOFUseCase.execute({ raceId });
    return this.raceWithSOFPresenter;
  }

  async getRaceProtests(raceId: string): Promise<RaceProtestsPresenter> {
    this.logger.debug('[RaceService] Fetching race protests:', { raceId });
    await this.getRaceProtestsUseCase.execute({ raceId });
    return this.raceProtestsPresenter;
  }

  async getRacePenalties(raceId: string): Promise<RacePenaltiesPresenter> {
    this.logger.debug('[RaceService] Fetching race penalties:', { raceId });
    await this.getRacePenaltiesUseCase.execute({ raceId });
    return this.racePenaltiesPresenter;
  }

  async registerForRace(params: RegisterForRaceParamsDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Registering for race:', params);
    await this.registerForRaceUseCase.execute(params);
    return this.commandResultPresenter;
  }

  async withdrawFromRace(params: WithdrawFromRaceParamsDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Withdrawing from race:', params);
    await this.withdrawFromRaceUseCase.execute(params);
    return this.commandResultPresenter;
  }

  async cancelRace(params: RaceActionParamsDTO, cancelledById: string): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Cancelling race:', params);
    await this.cancelRaceUseCase.execute({ raceId: params.raceId, cancelledById });
    return this.commandResultPresenter;
  }

  async completeRace(params: RaceActionParamsDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Completing race:', params);
    await this.completeRaceUseCase.execute({ raceId: params.raceId });
    return this.commandResultPresenter;
  }

  async reopenRace(params: RaceActionParamsDTO, reopenedById: string): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Re-opening race:', params);
    await this.reopenRaceUseCase.execute({ raceId: params.raceId, reopenedById });
    return this.commandResultPresenter;
  }

  async fileProtest(command: FileProtestCommandDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Filing protest:', command);
    await this.fileProtestUseCase.execute(command);
    return this.commandResultPresenter;
  }

  async applyQuickPenalty(command: QuickPenaltyCommandDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Applying quick penalty:', command);
    await this.quickPenaltyUseCase.execute(command);
    return this.commandResultPresenter;
  }

  async applyPenalty(command: ApplyPenaltyCommandDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Applying penalty:', command);
    await this.applyPenaltyUseCase.execute(command);
    return this.commandResultPresenter;
  }

  async requestProtestDefense(command: RequestProtestDefenseCommandDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Requesting protest defense:', command);
    await this.requestProtestDefenseUseCase.execute(command);
    return this.commandResultPresenter;
  }

  async reviewProtest(command: ReviewProtestCommandDTO): Promise<CommandResultPresenter> {
    this.logger.debug('[RaceService] Reviewing protest:', command);
    await this.reviewProtestUseCase.execute(command);
    return this.commandResultPresenter;
  }
}