import { describe, it, expect, vi, type Mock } from 'vitest';
import { GetAvatarUseCase } from './GetAvatarUseCase';
import type { IAvatarRepository } from '../../domain/repositories/IAvatarRepository';
import type { IGetAvatarPresenter } from '../presenters/IGetAvatarPresenter';
import type { Logger } from '@core/shared/application';
import { Avatar } from '../../domain/entities/Avatar';
import { MediaUrl } from '../../domain/value-objects/MediaUrl';

interface TestPresenter extends IGetAvatarPresenter {
  result?: any;
}

describe('GetAvatarUseCase', () => {
  let avatarRepo: {
    findActiveByDriverId: Mock;
    save: Mock;
  };
  let logger: Logger;
  let presenter: TestPresenter;
  let useCase: GetAvatarUseCase;

  beforeEach(() => {
    avatarRepo = {
      findActiveByDriverId: vi.fn(),
      save: vi.fn(),
    } as unknown as IAvatarRepository 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.result = result;
      }),
    } as unknown as TestPresenter;

    useCase = new GetAvatarUseCase(
      avatarRepo as unknown as IAvatarRepository,
      logger,
    );
  });

  it('presents error when no avatar exists for driver', async () => {
    avatarRepo.findActiveByDriverId.mockResolvedValue(null);

    await useCase.execute({ driverId: 'driver-1' }, presenter);

    expect(avatarRepo.findActiveByDriverId).toHaveBeenCalledWith('driver-1');
    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
      success: false,
      errorMessage: 'Avatar not found',
    });
  });

  it('presents avatar details when avatar exists', async () => {
    const avatar = Avatar.create({
      id: 'avatar-1',
      driverId: 'driver-1',
      mediaUrl: MediaUrl.create('https://example.com/avatar.png'),
    });

    avatarRepo.findActiveByDriverId.mockResolvedValue(avatar);

    await useCase.execute({ driverId: 'driver-1' }, presenter);

    expect(avatarRepo.findActiveByDriverId).toHaveBeenCalledWith('driver-1');
    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
      success: true,
      avatar: {
        id: avatar.id,
        driverId: avatar.driverId,
        mediaUrl: avatar.mediaUrl.value,
        selectedAt: avatar.selectedAt,
      },
    });
  });

  it('handles errors by logging and presenting failure', async () => {
    avatarRepo.findActiveByDriverId.mockRejectedValue(new Error('DB error'));

    await useCase.execute({ driverId: 'driver-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 retrieving avatar',
    });
  });
});