import { Provider } from '@nestjs/common';
import { DriverService } from './DriverService';

// Import core interfaces
import { DriverExtendedProfileProvider } from '@core/racing/application/ports/DriverExtendedProfileProvider';
import { IDriverRepository } from '@core/racing/domain/repositories/IDriverRepository';
import { IRaceRegistrationRepository } from '@core/racing/domain/repositories/IRaceRegistrationRepository';
import type { ITeamMembershipRepository } from '@core/racing/domain/repositories/ITeamMembershipRepository';
import type { ITeamRepository } from '@core/racing/domain/repositories/ITeamRepository';
import { IDriverStatsService } from '@core/racing/domain/services/IDriverStatsService';
import { IRankingService } from '@core/racing/domain/services/IRankingService';
import type { Logger } from '@core/shared/application';
import type { ISocialGraphRepository } from '@core/social/domain/repositories/ISocialGraphRepository';

// Import use cases
import { CompleteDriverOnboardingUseCase } from '@core/racing/application/use-cases/CompleteDriverOnboardingUseCase';
import { GetDriversLeaderboardUseCase } from '@core/racing/application/use-cases/GetDriversLeaderboardUseCase';
import { GetProfileOverviewUseCase } from '@core/racing/application/use-cases/GetProfileOverviewUseCase';
import { GetTotalDriversUseCase } from '@core/racing/application/use-cases/GetTotalDriversUseCase';
import { IsDriverRegisteredForRaceUseCase } from '@core/racing/application/use-cases/IsDriverRegisteredForRaceUseCase';
import { UpdateDriverProfileUseCase } from '@core/racing/application/use-cases/UpdateDriverProfileUseCase';

// Import concrete in-memory implementations
import { ConsoleLogger } from '@adapters/logging/ConsoleLogger';
import { InMemoryImageServiceAdapter } from '@adapters/media/ports/InMemoryImageServiceAdapter';
import { InMemoryNotificationPreferenceRepository } from '@adapters/notifications/persistence/inmemory/InMemoryNotificationPreferenceRepository';
import { InMemoryDriverRepository } from '@adapters/racing/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryRaceRegistrationRepository } from '@adapters/racing/persistence/inmemory/InMemoryRaceRegistrationRepository';
import { InMemoryTeamMembershipRepository } from '@adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
import { InMemoryTeamRepository } from '@adapters/racing/persistence/inmemory/InMemoryTeamRepository';
import { InMemoryDriverExtendedProfileProvider } from '@adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
import { InMemoryDriverRatingProvider } from '@adapters/racing/ports/InMemoryDriverRatingProvider';
import { InMemoryDriverStatsService } from '@adapters/racing/services/InMemoryDriverStatsService';
import { InMemoryRankingService } from '@adapters/racing/services/InMemoryRankingService';
import { IImageServicePort } from '@core/racing/application/ports/IImageServicePort';
import { InMemorySocialGraphRepository } from '@core/social/infrastructure/inmemory/InMemorySocialAndFeed';

// Import presenters
import { CompleteOnboardingPresenter } from './presenters/CompleteOnboardingPresenter';
import { DriverPresenter } from './presenters/DriverPresenter';
import { DriverProfilePresenter } from './presenters/DriverProfilePresenter';
import { DriverRegistrationStatusPresenter } from './presenters/DriverRegistrationStatusPresenter';
import { DriversLeaderboardPresenter } from './presenters/DriversLeaderboardPresenter';
import { DriverStatsPresenter } from './presenters/DriverStatsPresenter';

// Import types for output ports
import type { UseCaseOutputPort } from '@core/shared/application';

// Define injection tokens
export const DRIVER_REPOSITORY_TOKEN = 'IDriverRepository';
export const RANKING_SERVICE_TOKEN = 'IRankingService';
export const DRIVER_STATS_SERVICE_TOKEN = 'IDriverStatsService';
export const DRIVER_RATING_PROVIDER_TOKEN = 'DriverRatingProvider';
export const DRIVER_EXTENDED_PROFILE_PROVIDER_TOKEN = 'DriverExtendedProfileProvider';
export const IMAGE_SERVICE_PORT_TOKEN = 'IImageServicePort';
export const RACE_REGISTRATION_REPOSITORY_TOKEN = 'IRaceRegistrationRepository';
export const NOTIFICATION_PREFERENCE_REPOSITORY_TOKEN = 'INotificationPreferenceRepository';
export const TEAM_REPOSITORY_TOKEN = 'ITeamRepository';
export const TEAM_MEMBERSHIP_REPOSITORY_TOKEN = 'ITeamMembershipRepository';
export const SOCIAL_GRAPH_REPOSITORY_TOKEN = 'ISocialGraphRepository';
export const LOGGER_TOKEN = 'Logger';

// Use case tokens
export const GET_DRIVERS_LEADERBOARD_USE_CASE_TOKEN = 'GetDriversLeaderboardUseCase';
export const GET_TOTAL_DRIVERS_USE_CASE_TOKEN = 'GetTotalDriversUseCase';
export const COMPLETE_DRIVER_ONBOARDING_USE_CASE_TOKEN = 'CompleteDriverOnboardingUseCase';
export const IS_DRIVER_REGISTERED_FOR_RACE_USE_CASE_TOKEN = 'IsDriverRegisteredForRaceUseCase';
export const UPDATE_DRIVER_PROFILE_USE_CASE_TOKEN = 'UpdateDriverProfileUseCase';
export const GET_PROFILE_OVERVIEW_USE_CASE_TOKEN = 'GetProfileOverviewUseCase';

// Output port tokens
export const GET_DRIVERS_LEADERBOARD_OUTPUT_PORT_TOKEN = 'GetDriversLeaderboardOutputPort_TOKEN';
export const GET_TOTAL_DRIVERS_OUTPUT_PORT_TOKEN = 'GetTotalDriversOutputPort_TOKEN';
export const COMPLETE_DRIVER_ONBOARDING_OUTPUT_PORT_TOKEN = 'CompleteDriverOnboardingOutputPort_TOKEN';
export const IS_DRIVER_REGISTERED_FOR_RACE_OUTPUT_PORT_TOKEN = 'IsDriverRegisteredForRaceOutputPort_TOKEN';
export const UPDATE_DRIVER_PROFILE_OUTPUT_PORT_TOKEN = 'UpdateDriverProfileOutputPort_TOKEN';
export const GET_PROFILE_OVERVIEW_OUTPUT_PORT_TOKEN = 'GetProfileOverviewOutputPort_TOKEN';

export const DriverProviders: Provider[] = [
  DriverService,
  
  // Presenters
  DriversLeaderboardPresenter,
  DriverStatsPresenter,
  CompleteOnboardingPresenter,
  DriverRegistrationStatusPresenter,
  DriverPresenter,
  DriverProfilePresenter,

  // Output ports (point to presenters)
  {
    provide: GET_DRIVERS_LEADERBOARD_OUTPUT_PORT_TOKEN,
    useExisting: DriversLeaderboardPresenter,
  },
  {
    provide: GET_TOTAL_DRIVERS_OUTPUT_PORT_TOKEN,
    useExisting: DriverStatsPresenter,
  },
  {
    provide: COMPLETE_DRIVER_ONBOARDING_OUTPUT_PORT_TOKEN,
    useExisting: CompleteOnboardingPresenter,
  },
  {
    provide: IS_DRIVER_REGISTERED_FOR_RACE_OUTPUT_PORT_TOKEN,
    useExisting: DriverRegistrationStatusPresenter,
  },
  {
    provide: UPDATE_DRIVER_PROFILE_OUTPUT_PORT_TOKEN,
    useExisting: DriverPresenter,
  },
  {
    provide: GET_PROFILE_OVERVIEW_OUTPUT_PORT_TOKEN,
    useExisting: DriverProfilePresenter,
  },

  // Logger
  {
    provide: LOGGER_TOKEN,
    useClass: ConsoleLogger,
  },

  // Repositories
  {
    provide: DRIVER_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryDriverRepository(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: RANKING_SERVICE_TOKEN,
    useFactory: (logger: Logger) => new InMemoryRankingService(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: DRIVER_STATS_SERVICE_TOKEN,
    useFactory: (logger: Logger) => new InMemoryDriverStatsService(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: DRIVER_RATING_PROVIDER_TOKEN,
    useFactory: (logger: Logger) => new InMemoryDriverRatingProvider(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: DRIVER_EXTENDED_PROFILE_PROVIDER_TOKEN,
    useFactory: (logger: Logger) => new InMemoryDriverExtendedProfileProvider(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: IMAGE_SERVICE_PORT_TOKEN,
    useFactory: (logger: Logger) => new InMemoryImageServiceAdapter(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: RACE_REGISTRATION_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryRaceRegistrationRepository(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: NOTIFICATION_PREFERENCE_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryNotificationPreferenceRepository(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: TEAM_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryTeamRepository(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: TEAM_MEMBERSHIP_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryTeamMembershipRepository(logger),
    inject: [LOGGER_TOKEN],
  },
  {
    provide: SOCIAL_GRAPH_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) =>
      new InMemorySocialGraphRepository(logger, { drivers: [], friendships: [], feedEvents: [] }),
    inject: [LOGGER_TOKEN],
  },

  // Use cases
  {
    provide: GET_DRIVERS_LEADERBOARD_USE_CASE_TOKEN,
    useFactory: (
      driverRepo: IDriverRepository,
      rankingService: IRankingService,
      driverStatsService: IDriverStatsService,
      imageService: IImageServicePort,
      logger: Logger,
    ) => new GetDriversLeaderboardUseCase(driverRepo, rankingService, driverStatsService, (driverId: string) => Promise.resolve(imageService.getDriverAvatar(driverId)), logger),
    inject: [DRIVER_REPOSITORY_TOKEN, RANKING_SERVICE_TOKEN, DRIVER_STATS_SERVICE_TOKEN, IMAGE_SERVICE_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_TOTAL_DRIVERS_USE_CASE_TOKEN,
    useFactory: (driverRepo: IDriverRepository) => new GetTotalDriversUseCase(driverRepo),
    inject: [DRIVER_REPOSITORY_TOKEN],
  },
  {
    provide: COMPLETE_DRIVER_ONBOARDING_USE_CASE_TOKEN,
    useFactory: (driverRepo: IDriverRepository, logger: Logger) => new CompleteDriverOnboardingUseCase(driverRepo, logger),
    inject: [DRIVER_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: IS_DRIVER_REGISTERED_FOR_RACE_USE_CASE_TOKEN,
    useFactory: (registrationRepo: IRaceRegistrationRepository, logger: Logger) =>
      new IsDriverRegisteredForRaceUseCase(registrationRepo, logger),
    inject: [RACE_REGISTRATION_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: UPDATE_DRIVER_PROFILE_USE_CASE_TOKEN,
    useFactory: (driverRepo: IDriverRepository, logger: Logger) => 
      new UpdateDriverProfileUseCase(driverRepo, logger),
    inject: [DRIVER_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_PROFILE_OVERVIEW_USE_CASE_TOKEN,
    useFactory: (
      driverRepo: IDriverRepository,
      teamRepository: ITeamRepository,
      teamMembershipRepository: ITeamMembershipRepository,
      socialRepository: ISocialGraphRepository,
      imageService: IImageServicePort,
      driverExtendedProfileProvider: DriverExtendedProfileProvider,
      driverStatsService: IDriverStatsService,
      rankingService: IRankingService,
    ) =>
      new GetProfileOverviewUseCase(
        driverRepo,
        teamRepository,
        teamMembershipRepository,
        socialRepository,
        imageService,
        driverExtendedProfileProvider,
        (driverId: string) => {
          const stats = driverStatsService.getDriverStats(driverId);
          if (!stats) {
            return null;
          }

          return {
            rating: stats.rating,
            wins: stats.wins,
            podiums: stats.podiums,
            dnfs: 0,
            totalRaces: stats.totalRaces,
            avgFinish: null,
            bestFinish: null,
            worstFinish: null,
            overallRank: stats.overallRank,
            consistency: null,
            percentile: null,
          };
        },
        () =>
          rankingService.getAllDriverRankings().map(ranking => ({
            driverId: ranking.driverId,
            rating: ranking.rating,
            overallRank: ranking.overallRank,
          })),
      ),
    inject: [
      DRIVER_REPOSITORY_TOKEN,
      TEAM_REPOSITORY_TOKEN,
      TEAM_MEMBERSHIP_REPOSITORY_TOKEN,
      SOCIAL_GRAPH_REPOSITORY_TOKEN,
      IMAGE_SERVICE_PORT_TOKEN,
      DRIVER_EXTENDED_PROFILE_PROVIDER_TOKEN,
      DRIVER_STATS_SERVICE_TOKEN,
      RANKING_SERVICE_TOKEN,
    ],
  },
];