import { Provider } from '@nestjs/common';
import { EnsureInitialData } from '../../../../../adapters/bootstrap/EnsureInitialData';
import type { RacingSeedDependencies } from '../../../../../adapters/bootstrap/SeedRacingData';
import { SignupWithEmailUseCase, type SignupWithEmailResult } from '@core/identity/application/use-cases/SignupWithEmailUseCase';
import {
  CreateAchievementUseCase,
  type CreateAchievementResult,
  type IAchievementRepository,
} from '@core/identity/application/use-cases/achievement/CreateAchievementUseCase';
import type { IUserRepository } from '@core/identity/domain/repositories/IUserRepository';
import type { IdentitySessionPort } from '@core/identity/application/ports/IdentitySessionPort';
import type { Logger } from '@core/shared/application';
import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
import { InMemoryUserRepository } from '../../../../../adapters/identity/persistence/inmemory/InMemoryUserRepository';
import { InMemoryAchievementRepository } from '../../../../../adapters/persistence/inmemory/achievement/InMemoryAchievementRepository';
import { CookieIdentitySessionAdapter } from '../../../../../adapters/identity/session/CookieIdentitySessionAdapter';

// Define tokens
export const USER_REPOSITORY_TOKEN = 'IUserRepository_Bootstrap';
export const ACHIEVEMENT_REPOSITORY_TOKEN = 'IAchievementRepository_Bootstrap';
export const IDENTITY_SESSION_PORT_TOKEN = 'IdentitySessionPort_Bootstrap';
export const SIGNUP_USE_CASE_TOKEN = 'SignupWithEmailUseCase_Bootstrap';
export const CREATE_ACHIEVEMENT_USE_CASE_TOKEN = 'CreateAchievementUseCase_Bootstrap';

export const RACING_SEED_DEPENDENCIES_TOKEN = 'RacingSeedDependencies';
export const ENSURE_INITIAL_DATA_TOKEN = 'EnsureInitialData_Bootstrap';

// Adapter classes for output ports
class SignupWithEmailOutputAdapter implements UseCaseOutputPort<SignupWithEmailResult> {
  present(result: SignupWithEmailResult): void {
    // Bootstrap doesn't need to handle output, just log success
    console.log('[Bootstrap] Signup completed', result);
  }
}

class CreateAchievementOutputAdapter implements UseCaseOutputPort<CreateAchievementResult> {
  present(result: CreateAchievementResult): void {
    // Bootstrap doesn't need to handle output, just log success
    console.log('[Bootstrap] Achievement created', result);
  }
}

export const BootstrapProviders: Provider[] = [
  {
    provide: RACING_SEED_DEPENDENCIES_TOKEN,
    useFactory: (
      driverRepository: RacingSeedDependencies['driverRepository'],
      leagueRepository: RacingSeedDependencies['leagueRepository'],
      raceRepository: RacingSeedDependencies['raceRepository'],
      resultRepository: RacingSeedDependencies['resultRepository'],
      standingRepository: RacingSeedDependencies['standingRepository'],
      leagueMembershipRepository: RacingSeedDependencies['leagueMembershipRepository'],
      raceRegistrationRepository: RacingSeedDependencies['raceRegistrationRepository'],
      teamRepository: RacingSeedDependencies['teamRepository'],
      teamMembershipRepository: RacingSeedDependencies['teamMembershipRepository'],
      feedRepository: RacingSeedDependencies['feedRepository'],
      socialGraphRepository: RacingSeedDependencies['socialGraphRepository'],
    ): RacingSeedDependencies => ({
      driverRepository,
      leagueRepository,
      raceRepository,
      resultRepository,
      standingRepository,
      leagueMembershipRepository,
      raceRegistrationRepository,
      teamRepository,
      teamMembershipRepository,
      feedRepository,
      socialGraphRepository,
    }),
    inject: [
      'IDriverRepository',
      'ILeagueRepository',
      'IRaceRepository',
      'IResultRepository',
      'IStandingRepository',
      'ILeagueMembershipRepository',
      'IRaceRegistrationRepository',
      'ITeamRepository',
      'ITeamMembershipRepository',
      'IFeedRepository',
      'ISocialGraphRepository',
    ],
  },
  {
    provide: USER_REPOSITORY_TOKEN,
    useFactory: (logger: Logger) => new InMemoryUserRepository(logger),
    inject: ['Logger'],
  },
  {
    provide: ACHIEVEMENT_REPOSITORY_TOKEN,
    useClass: InMemoryAchievementRepository,
  },
  {
    provide: IDENTITY_SESSION_PORT_TOKEN,
    useFactory: (logger: Logger) => new CookieIdentitySessionAdapter(logger),
    inject: ['Logger'],
  },
  {
    provide: SIGNUP_USE_CASE_TOKEN,
    useFactory: (
      userRepository: IUserRepository, 
      sessionPort: IdentitySessionPort,
      logger: Logger
    ) => {
      return new SignupWithEmailUseCase(
        userRepository, 
        sessionPort, 
        logger,
        new SignupWithEmailOutputAdapter()
      );
    },
    inject: [USER_REPOSITORY_TOKEN, IDENTITY_SESSION_PORT_TOKEN, 'Logger'],
  },
  {
    provide: CREATE_ACHIEVEMENT_USE_CASE_TOKEN,
    useFactory: (
      achievementRepository: IAchievementRepository,
      logger: Logger
    ) => {
      return new CreateAchievementUseCase(
        achievementRepository,
        logger,
        new CreateAchievementOutputAdapter()
      );
    },
    inject: [ACHIEVEMENT_REPOSITORY_TOKEN, 'Logger'],
  },
  {
    provide: ENSURE_INITIAL_DATA_TOKEN,
    useFactory: (
      signupUseCase: SignupWithEmailUseCase,
      createAchievementUseCase: CreateAchievementUseCase,
      logger: Logger,
    ) => {
      return new EnsureInitialData(signupUseCase, createAchievementUseCase, logger);
    },
    inject: [SIGNUP_USE_CASE_TOKEN, CREATE_ACHIEVEMENT_USE_CASE_TOKEN, 'Logger'],
  },
];