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

describe('ResolveMediaReferenceUseCase', () => {
  let mediaResolver: {
    resolve: Mock;
  };
  let useCase: ResolveMediaReferenceUseCase;

  beforeEach(() => {
    mediaResolver = {
      resolve: vi.fn(),
    };

    useCase = new ResolveMediaReferenceUseCase(
      mediaResolver as unknown as MediaResolverPort,
    );
  });

  it('returns resolved path when media reference is resolved', async () => {
    mediaResolver.resolve.mockResolvedValue('/resolved/path/to/media.png');

    const input = { reference: { type: 'team', id: 'team-123' } };
    const result = await useCase.execute(input);

    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult).toBe('/resolved/path/to/media.png');
  });

  it('returns null when media reference resolves to null', async () => {
    mediaResolver.resolve.mockResolvedValue(null);

    const input = { reference: { type: 'team', id: 'team-123' } };
    const result = await useCase.execute(input);

    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult).toBe(null);
  });

  it('returns empty string when media reference resolves to empty string', async () => {
    mediaResolver.resolve.mockResolvedValue('');

    const input = { reference: { type: 'team', id: 'team-123' } };
    const result = await useCase.execute(input);

    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
    expect(result.isOk()).toBe(true);

    const successResult = result.unwrap();
    expect(successResult).toBe('');
  });

  it('handles resolver errors by returning error', async () => {
    mediaResolver.resolve.mockRejectedValue(new Error('Resolver error'));

    const input = { reference: { type: 'team', id: 'team-123' } };
    const result = await useCase.execute(input);

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

  it('handles non-Error exceptions by wrapping in Error', async () => {
    mediaResolver.resolve.mockRejectedValue('string error');

    const input = { reference: { type: 'team', id: 'team-123' } };
    const result = await useCase.execute(input);

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

  it('resolves different reference types', async () => {
    const testCases = [
      { type: 'team', id: 'team-123' },
      { type: 'league', id: 'league-456' },
      { type: 'driver', id: 'driver-789' },
    ];

    for (const reference of testCases) {
      mediaResolver.resolve.mockResolvedValue(`/resolved/${reference.type}/${reference.id}.png`);

      const input = { reference };
      const result = await useCase.execute(input);

      expect(mediaResolver.resolve).toHaveBeenCalledWith(reference);
      expect(result.isOk()).toBe(true);

      const successResult = result.unwrap();
      expect(successResult).toBe(`/resolved/${reference.type}/${reference.id}.png`);
    }
  });
});