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

// Import core interfaces
import { IAvatarGenerationRepository } from '@core/media/domain/repositories/IAvatarGenerationRepository';
import { IMediaRepository } from '@core/media/domain/repositories/IMediaRepository';
import { IAvatarRepository } from '@core/media/domain/repositories/IAvatarRepository';
import { FaceValidationPort } from '@core/media/application/ports/FaceValidationPort';
import { AvatarGenerationPort } from '@core/media/application/ports/AvatarGenerationPort';
import { MediaStoragePort } from '@core/media/application/ports/MediaStoragePort';
import type { Logger, UseCaseOutputPort } from '@core/shared/application';

// Import use cases
import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
import { UploadMediaUseCase } from '@core/media/application/use-cases/UploadMediaUseCase';
import { GetMediaUseCase } from '@core/media/application/use-cases/GetMediaUseCase';
import { DeleteMediaUseCase } from '@core/media/application/use-cases/DeleteMediaUseCase';
import { GetAvatarUseCase } from '@core/media/application/use-cases/GetAvatarUseCase';
import { UpdateAvatarUseCase } from '@core/media/application/use-cases/UpdateAvatarUseCase';

// Import result types
import type { RequestAvatarGenerationResult } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
import type { UploadMediaResult } from '@core/media/application/use-cases/UploadMediaUseCase';
import type { GetMediaResult } from '@core/media/application/use-cases/GetMediaUseCase';
import type { DeleteMediaResult } from '@core/media/application/use-cases/DeleteMediaUseCase';
import type { GetAvatarResult } from '@core/media/application/use-cases/GetAvatarUseCase';
import type { UpdateAvatarResult } from '@core/media/application/use-cases/UpdateAvatarUseCase';

// Import presenters
import { RequestAvatarGenerationPresenter } from './presenters/RequestAvatarGenerationPresenter';
import { UploadMediaPresenter } from './presenters/UploadMediaPresenter';
import { GetMediaPresenter } from './presenters/GetMediaPresenter';
import { DeleteMediaPresenter } from './presenters/DeleteMediaPresenter';
import { GetAvatarPresenter } from './presenters/GetAvatarPresenter';
import { UpdateAvatarPresenter } from './presenters/UpdateAvatarPresenter';

// Define injection tokens
export const AVATAR_GENERATION_REPOSITORY_TOKEN = 'IAvatarGenerationRepository';
export const MEDIA_REPOSITORY_TOKEN = 'IMediaRepository';
export const AVATAR_REPOSITORY_TOKEN = 'IAvatarRepository';
export const FACE_VALIDATION_PORT_TOKEN = 'FaceValidationPort';
export const AVATAR_GENERATION_PORT_TOKEN = 'AvatarGenerationPort';
export const MEDIA_STORAGE_PORT_TOKEN = 'MediaStoragePort';
export const LOGGER_TOKEN = 'Logger';

// Use case tokens
export const REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN = 'RequestAvatarGenerationUseCase';
export const UPLOAD_MEDIA_USE_CASE_TOKEN = 'UploadMediaUseCase';
export const GET_MEDIA_USE_CASE_TOKEN = 'GetMediaUseCase';
export const DELETE_MEDIA_USE_CASE_TOKEN = 'DeleteMediaUseCase';
export const GET_AVATAR_USE_CASE_TOKEN = 'GetAvatarUseCase';
export const UPDATE_AVATAR_USE_CASE_TOKEN = 'UpdateAvatarUseCase';

// Output port tokens
export const REQUEST_AVATAR_GENERATION_OUTPUT_PORT_TOKEN = 'RequestAvatarGenerationOutputPort';
export const UPLOAD_MEDIA_OUTPUT_PORT_TOKEN = 'UploadMediaOutputPort';
export const GET_MEDIA_OUTPUT_PORT_TOKEN = 'GetMediaOutputPort';
export const DELETE_MEDIA_OUTPUT_PORT_TOKEN = 'DeleteMediaOutputPort';
export const GET_AVATAR_OUTPUT_PORT_TOKEN = 'GetAvatarOutputPort';
export const UPDATE_AVATAR_OUTPUT_PORT_TOKEN = 'UpdateAvatarOutputPort';

import type { AvatarGenerationRequest } from '@core/media/domain/entities/AvatarGenerationRequest';
import type { Media } from '@core/media/domain/entities/Media';
import type { Avatar } from '@core/media/domain/entities/Avatar';
import type { FaceValidationResult } from '@core/media/application/ports/FaceValidationPort';
import type { AvatarGenerationResult } from '@core/media/application/ports/AvatarGenerationPort';
import type { UploadResult } from '@core/media/application/ports/MediaStoragePort';

// Mock implementations
class MockAvatarGenerationRepository implements IAvatarGenerationRepository {
  async save(): Promise<void> {}
  async findById(): Promise<AvatarGenerationRequest | null> { return null; }
  async findByUserId(): Promise<AvatarGenerationRequest[]> { return []; }
  async findLatestByUserId(): Promise<AvatarGenerationRequest | null> { return null; }
  async delete(): Promise<void> {}
}

class MockMediaRepository implements IMediaRepository {
  async save(): Promise<void> {}
  async findById(): Promise<Media | null> { return null; }
  async findByUploadedBy(): Promise<Media[]> { return []; }
  async delete(): Promise<void> {}
}

class MockAvatarRepository implements IAvatarRepository {
  async save(): Promise<void> {}
  async findById(): Promise<Avatar | null> { return null; }
  async findActiveByDriverId(): Promise<Avatar | null> { return null; }
  async findByDriverId(): Promise<Avatar[]> { return []; }
  async delete(): Promise<void> {}
}

class MockFaceValidationAdapter implements FaceValidationPort {
  async validateFacePhoto(): Promise<FaceValidationResult> {
    return {
      isValid: true,
      hasFace: true,
      faceCount: 1,
      confidence: 0.95,
    };
  }
}

class MockAvatarGenerationAdapter implements AvatarGenerationPort {
  async generateAvatars(): Promise<AvatarGenerationResult> {
    return {
      success: true,
      avatars: [
        { url: 'https://cdn.example.com/avatars/mock-avatar-1.png' },
        { url: 'https://cdn.example.com/avatars/mock-avatar-2.png' },
        { url: 'https://cdn.example.com/avatars/mock-avatar-3.png' },
      ],
    };
  }
}

class MockMediaStorageAdapter implements MediaStoragePort {
  async uploadMedia(): Promise<UploadResult> {
    return {
      success: true,
      url: 'https://cdn.example.com/media/mock-file.png',
      filename: 'mock-file.png',
    };
  }
  async deleteMedia(): Promise<void> {}
}

class MockLogger implements Logger {
  debug(): void {}
  info(): void {}
  warn(): void {}
  error(): void {}
}

export const MediaProviders: Provider[] = [
  MediaService, // Provide the service itself
  RequestAvatarGenerationPresenter,
  UploadMediaPresenter,
  GetMediaPresenter,
  DeleteMediaPresenter,
  GetAvatarPresenter,
  UpdateAvatarPresenter,
  {
    provide: AVATAR_GENERATION_REPOSITORY_TOKEN,
    useClass: MockAvatarGenerationRepository,
  },
  {
    provide: MEDIA_REPOSITORY_TOKEN,
    useClass: MockMediaRepository,
  },
  {
    provide: AVATAR_REPOSITORY_TOKEN,
    useClass: MockAvatarRepository,
  },
  {
    provide: FACE_VALIDATION_PORT_TOKEN,
    useClass: MockFaceValidationAdapter,
  },
  {
    provide: AVATAR_GENERATION_PORT_TOKEN,
    useClass: MockAvatarGenerationAdapter,
  },
  {
    provide: MEDIA_STORAGE_PORT_TOKEN,
    useClass: MockMediaStorageAdapter,
  },
  {
    provide: LOGGER_TOKEN,
    useClass: MockLogger,
  },
  // Output ports
  {
    provide: REQUEST_AVATAR_GENERATION_OUTPUT_PORT_TOKEN,
    useExisting: RequestAvatarGenerationPresenter,
  },
  {
    provide: UPLOAD_MEDIA_OUTPUT_PORT_TOKEN,
    useExisting: UploadMediaPresenter,
  },
  {
    provide: GET_MEDIA_OUTPUT_PORT_TOKEN,
    useExisting: GetMediaPresenter,
  },
  {
    provide: DELETE_MEDIA_OUTPUT_PORT_TOKEN,
    useExisting: DeleteMediaPresenter,
  },
  {
    provide: GET_AVATAR_OUTPUT_PORT_TOKEN,
    useExisting: GetAvatarPresenter,
  },
  {
    provide: UPDATE_AVATAR_OUTPUT_PORT_TOKEN,
    useExisting: UpdateAvatarPresenter,
  },
  // Use cases
  {
    provide: REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarGenerationRepository, faceValidation: FaceValidationPort, avatarGeneration: AvatarGenerationPort, output: UseCaseOutputPort<RequestAvatarGenerationResult>, logger: Logger) =>
      new RequestAvatarGenerationUseCase(avatarRepo, faceValidation, avatarGeneration, output, logger),
    inject: [AVATAR_GENERATION_REPOSITORY_TOKEN, FACE_VALIDATION_PORT_TOKEN, AVATAR_GENERATION_PORT_TOKEN, REQUEST_AVATAR_GENERATION_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: UPLOAD_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, output: UseCaseOutputPort<UploadMediaResult>, logger: Logger) =>
      new UploadMediaUseCase(mediaRepo, mediaStorage, output, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, UPLOAD_MEDIA_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, output: UseCaseOutputPort<GetMediaResult>, logger: Logger) =>
      new GetMediaUseCase(mediaRepo, output, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, GET_MEDIA_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: DELETE_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, output: UseCaseOutputPort<DeleteMediaResult>, logger: Logger) =>
      new DeleteMediaUseCase(mediaRepo, mediaStorage, output, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, DELETE_MEDIA_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_AVATAR_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarRepository, output: UseCaseOutputPort<GetAvatarResult>, logger: Logger) =>
      new GetAvatarUseCase(avatarRepo, output, logger),
    inject: [AVATAR_REPOSITORY_TOKEN, GET_AVATAR_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: UPDATE_AVATAR_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarRepository, output: UseCaseOutputPort<UpdateAvatarResult>, logger: Logger) =>
      new UpdateAvatarUseCase(avatarRepo, output, logger),
    inject: [AVATAR_REPOSITORY_TOKEN, UPDATE_AVATAR_OUTPUT_PORT_TOKEN, LOGGER_TOKEN],
  },
];