import { Result } from '@core/shared/domain/Result';
import { describe, expect, it, vi, type Mock } from 'vitest';
import type { MediaStoragePort } from '../ports/MediaStoragePort';
import { GetUploadedMediaUseCase } from './GetUploadedMediaUseCase';

describe('GetUploadedMediaUseCase', () => {
  let mediaStorage: {
    getBytes: Mock;
    getMetadata: Mock;
  };
  let useCase: GetUploadedMediaUseCase;

  beforeEach(() => {
    mediaStorage = {
      getBytes: vi.fn(),
      getMetadata: vi.fn(),
    };

    useCase = new GetUploadedMediaUseCase(
      mediaStorage as unknown as MediaStoragePort,
    );
  });

  it('returns null when media is not found', async () => {
    mediaStorage.getBytes.mockResolvedValue(null);

    const input = { storageKey: 'missing-key' };
    const result = await useCase.execute(input);

    expect(mediaStorage.getBytes).toHaveBeenCalledWith('missing-key');
    expect(result).toBeInstanceOf(Result);
    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toBe(null);
  });

  it('returns media bytes and content type when found', async () => {
    const mockBytes = Buffer.from('test data');
    const mockMetadata = { size: 9, contentType: 'image/png' };

    mediaStorage.getBytes.mockResolvedValue(mockBytes);
    mediaStorage.getMetadata.mockResolvedValue(mockMetadata);

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(mediaStorage.getBytes).toHaveBeenCalledWith('media-key');
    expect(mediaStorage.getMetadata).toHaveBeenCalledWith('media-key');
    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult).not.toBeNull();
    expect(successResult!.bytes).toBeInstanceOf(Buffer);
    expect(successResult!.bytes.toString()).toBe('test data');
    expect(successResult!.contentType).toBe('image/png');
  });

  it('returns default content type when metadata is null', async () => {
    const mockBytes = Buffer.from('test data');

    mediaStorage.getBytes.mockResolvedValue(mockBytes);
    mediaStorage.getMetadata.mockResolvedValue(null);

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult!.contentType).toBe('application/octet-stream');
  });

  it('returns default content type when metadata has no contentType', async () => {
    const mockBytes = Buffer.from('test data');
    const mockMetadata = { size: 9 };

    mediaStorage.getBytes.mockResolvedValue(mockBytes);
    mediaStorage.getMetadata.mockResolvedValue(mockMetadata as any);

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult!.contentType).toBe('application/octet-stream');
  });

  it('handles storage errors by returning error', async () => {
    mediaStorage.getBytes.mockRejectedValue(new Error('Storage error'));

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr();
    expect(err.message).toBe('Storage error');
  });

  it('handles getMetadata errors by returning error', async () => {
    const mockBytes = Buffer.from('test data');

    mediaStorage.getBytes.mockResolvedValue(mockBytes);
    mediaStorage.getMetadata.mockRejectedValue(new Error('Metadata error'));

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(result.isErr()).toBe(true);
    const err = result.unwrapErr();
    expect(err.message).toBe('Metadata error');
  });

  it('returns bytes as Buffer', async () => {
    const mockBytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]); // "Hello"

    mediaStorage.getBytes.mockResolvedValue(mockBytes);
    mediaStorage.getMetadata.mockResolvedValue({ size: 5, contentType: 'text/plain' });

    const input = { storageKey: 'media-key' };
    const result = await useCase.execute(input);

    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult!.bytes).toBeInstanceOf(Buffer);
    expect(successResult!.bytes.toString()).toBe('Hello');
  });
});