import { describe, it, expect, vi, type Mock } from 'vitest';
import { SelectAvatarUseCase } from './SelectAvatarUseCase';
import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
import type { ISelectAvatarPresenter } from '../presenters/ISelectAvatarPresenter';
import type { Logger } from '@core/shared/application';
import { AvatarGenerationRequest } from '../../domain/entities/AvatarGenerationRequest';

interface TestPresenter extends ISelectAvatarPresenter {
  result?: any;
}

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

  beforeEach(() => {
    avatarRepo = {
      findById: vi.fn(),
      save: vi.fn(),
    } as unknown as IAvatarGenerationRepository 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 SelectAvatarUseCase(
      avatarRepo as unknown as IAvatarGenerationRepository,
      logger,
    );
  });

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

    await useCase.execute({ requestId: 'req-1', selectedIndex: 0 }, presenter);

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

  it('returns error when request is not completed', async () => {
    const request = AvatarGenerationRequest.create({
      id: 'req-1',
      userId: 'user-1',
      facePhotoUrl: 'photo',
      suitColor: 'red',
      style: 'realistic',
    });

    avatarRepo.findById.mockResolvedValue(request);

    await useCase.execute({ requestId: 'req-1', selectedIndex: 0 }, presenter);

    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
      success: false,
      errorMessage: 'Avatar generation is not completed yet',
    });
  });
});