import { describe, it, expect, vi, type Mock } from 'vitest';
import { DeleteMediaUseCase } from './DeleteMediaUseCase';
import type { IMediaRepository } from '../../domain/repositories/IMediaRepository';
import type { MediaStoragePort } from '../ports/MediaStoragePort';
import type { IDeleteMediaPresenter } from '../presenters/IDeleteMediaPresenter';
import type { Logger } from '@core/shared/application';
import { Media } from '../../domain/entities/Media';
import { MediaUrl } from '../../domain/value-objects/MediaUrl';

describe('DeleteMediaUseCase', () => {
  let mediaRepo: {
    findById: Mock;
    delete: Mock;
  };
  let mediaStorage: {
    deleteMedia: Mock;
  };
  let logger: Logger;
  let presenter: IDeleteMediaPresenter & { result?: any };
  let useCase: DeleteMediaUseCase;

  beforeEach(() => {
    mediaRepo = {
      findById: vi.fn(),
      delete: vi.fn(),
    } as unknown as IMediaRepository as any;

    mediaStorage = {
      deleteMedia: vi.fn(),
    } as unknown as MediaStoragePort as any;

    logger = {
      debug: vi.fn(),
      info: vi.fn(),
      warn: vi.fn(),
      error: vi.fn(),
    } as unknown as Logger;

    presenter = {
      present: vi.fn((result) => {
        (presenter as any).result = result;
      }),
    } as unknown as IDeleteMediaPresenter & { result?: any };

    useCase = new DeleteMediaUseCase(
      mediaRepo as unknown as IMediaRepository,
      mediaStorage as unknown as MediaStoragePort,
      logger,
    );
  });

  it('returns error result when media is not found', async () => {
    mediaRepo.findById.mockResolvedValue(null);

    await useCase.execute({ mediaId: 'missing' }, presenter);

    expect(mediaRepo.findById).toHaveBeenCalledWith('missing');
    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
      success: false,
      errorMessage: 'Media not found',
    });
  });

  it('deletes media from storage and repository on success', async () => {
    const media = Media.create({
      id: 'media-1',
      filename: 'file.png',
      originalName: 'file.png',
      mimeType: 'image/png',
      size: 123,
      url: MediaUrl.create('https://example.com/file.png'),
      type: 'image',
      uploadedBy: 'user-1',
    });

    mediaRepo.findById.mockResolvedValue(media);

    await useCase.execute({ mediaId: 'media-1' }, presenter);

    expect(mediaRepo.findById).toHaveBeenCalledWith('media-1');
    expect(mediaStorage.deleteMedia).toHaveBeenCalledWith(media.url.value);
    expect(mediaRepo.delete).toHaveBeenCalledWith('media-1');
    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({ success: true });
  });

  it('handles errors and presents failure result', async () => {
    mediaRepo.findById.mockRejectedValue(new Error('DB error'));

    await useCase.execute({ mediaId: 'media-1' }, presenter);

    expect((logger.error as unknown as Mock)).toHaveBeenCalled();
    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
      success: false,
      errorMessage: 'Internal error occurred while deleting media',
    });
  });
});