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 } 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';

// 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';

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
  {
    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,
  },
  // Use cases
  {
    provide: REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarGenerationRepository, faceValidation: FaceValidationPort, avatarGeneration: AvatarGenerationPort, logger: Logger) =>
      new RequestAvatarGenerationUseCase(avatarRepo, faceValidation, avatarGeneration, logger),
    inject: [AVATAR_GENERATION_REPOSITORY_TOKEN, FACE_VALIDATION_PORT_TOKEN, AVATAR_GENERATION_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: UPLOAD_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, logger: Logger) =>
      new UploadMediaUseCase(mediaRepo, mediaStorage, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, logger: Logger) =>
      new GetMediaUseCase(mediaRepo, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: DELETE_MEDIA_USE_CASE_TOKEN,
    useFactory: (mediaRepo: IMediaRepository, mediaStorage: MediaStoragePort, logger: Logger) =>
      new DeleteMediaUseCase(mediaRepo, mediaStorage, logger),
    inject: [MEDIA_REPOSITORY_TOKEN, MEDIA_STORAGE_PORT_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: GET_AVATAR_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarRepository, logger: Logger) =>
      new GetAvatarUseCase(avatarRepo, logger),
    inject: [AVATAR_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
  {
    provide: UPDATE_AVATAR_USE_CASE_TOKEN,
    useFactory: (avatarRepo: IAvatarRepository, logger: Logger) =>
      new UpdateAvatarUseCase(avatarRepo, logger),
    inject: [AVATAR_REPOSITORY_TOKEN, LOGGER_TOKEN],
  },
];