/**
 * Use Case: DeleteMediaUseCase
 *
 * Handles the business logic for deleting media files.
 */

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

export interface DeleteMediaInput {
  mediaId: string;
}

export interface DeleteMediaResult {
  success: boolean;
  errorMessage?: string;
}

export interface IDeleteMediaPresenter {
  present(result: DeleteMediaResult): void;
}

export class DeleteMediaUseCase {
  constructor(
    private readonly mediaRepo: IMediaRepository,
    private readonly mediaStorage: MediaStoragePort,
    private readonly logger: Logger,
  ) {}

  async execute(
    input: DeleteMediaInput,
    presenter: IDeleteMediaPresenter,
  ): Promise<void> {
    try {
      this.logger.info('[DeleteMediaUseCase] Deleting media', {
        mediaId: input.mediaId,
      });

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

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

      // Delete from storage
      await this.mediaStorage.deleteMedia(media.url.value);

      // Delete from repository
      await this.mediaRepo.delete(input.mediaId);

      presenter.present({
        success: true,
      });

      this.logger.info('[DeleteMediaUseCase] Media deleted successfully', {
        mediaId: input.mediaId,
      });

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

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