/**
 * Use Case: GetMediaUseCase
 *
 * Handles the business logic for retrieving media information.
 */

import type { IMediaRepository } from '../../domain/repositories/IMediaRepository';
import type { Logger } from '@core/shared/application';
import type { IGetMediaPresenter } from '../presenters/IGetMediaPresenter';

export interface GetMediaInput {
  mediaId: string;
}

export interface GetMediaResult {
  success: boolean;
  media?: {
    id: string;
    filename: string;
    originalName: string;
    mimeType: string;
    size: number;
    url: string;
    type: string;
    uploadedBy: string;
    uploadedAt: Date;
    metadata?: Record<string, any>;
  };
  errorMessage?: string;
}

export interface IGetMediaPresenter {
  present(result: GetMediaResult): void;
}

export class GetMediaUseCase {
  constructor(
    private readonly mediaRepo: IMediaRepository,
    private readonly logger: Logger,
  ) {}

  async execute(
    input: GetMediaInput,
    presenter: IGetMediaPresenter,
  ): Promise<void> {
    try {
      this.logger.info('[GetMediaUseCase] Getting media', {
        mediaId: input.mediaId,
      });

      const media = await this.mediaRepo.findById(input.mediaId);

      if (!media) {
        presenter.present({
          success: false,
          errorMessage: 'Media not found',
        });
        return;
      }

      presenter.present({
        success: true,
        media: {
          id: media.id,
          filename: media.filename,
          originalName: media.originalName,
          mimeType: media.mimeType,
          size: media.size,
          url: media.url.value,
          type: media.type,
          uploadedBy: media.uploadedBy,
          uploadedAt: media.uploadedAt,
          metadata: media.metadata,
        },
      });

    } catch (error) {
      this.logger.error('[GetMediaUseCase] Error getting media', {
        error: error instanceof Error ? error.message : 'Unknown error',
        mediaId: input.mediaId,
      });

      presenter.present({
        success: false,
        errorMessage: 'Internal error occurred while retrieving media',
      });
    }
  }
}