import { describe, it, expect, vi, beforeEach } from 'vitest';
import { GenerateAvatarsMutation } from './GenerateAvatarsMutation';
import { OnboardingService } from '@/lib/services/onboarding/OnboardingService';
import { Result } from '@/lib/contracts/Result';
import { GenerateAvatarsViewDataBuilder } from '@/lib/builders/view-data/GenerateAvatarsViewDataBuilder';

// Mock dependencies
vi.mock('@/lib/services/onboarding/OnboardingService', () => {
  return {
    OnboardingService: vi.fn(),
  };
});

vi.mock('@/lib/builders/view-data/GenerateAvatarsViewDataBuilder', () => ({
  GenerateAvatarsViewDataBuilder: {
    build: vi.fn(),
  },
}));

vi.mock('@/lib/contracts/mutations/MutationError', () => ({
  mapToMutationError: vi.fn((err) => err.type || 'unknown'),
}));

describe('GenerateAvatarsMutation', () => {
  let mutation: GenerateAvatarsMutation;
  let mockServiceInstance: any;

  beforeEach(() => {
    vi.clearAllMocks();
    mutation = new GenerateAvatarsMutation();
    mockServiceInstance = {
      generateAvatars: vi.fn(),
    };
    // Use mockImplementation to return the instance
    (OnboardingService as any).mockImplementation(function() {
      return mockServiceInstance;
    });
  });

  it('should return success result when service succeeds', async () => {
    const input = { prompt: 'test prompt' };
    const serviceOutput = { success: true, avatarUrls: ['url1'] };
    const viewData = { success: true, avatarUrls: ['url1'], errorMessage: undefined };

    mockServiceInstance.generateAvatars.mockResolvedValue(Result.ok(serviceOutput));
    (GenerateAvatarsViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await mutation.execute(input);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
    expect(mockServiceInstance.generateAvatars).toHaveBeenCalledWith(input);
    expect(GenerateAvatarsViewDataBuilder.build).toHaveBeenCalledWith(serviceOutput);
  });

  it('should return error result when service fails', async () => {
    const input = { prompt: 'test prompt' };
    const domainError = { type: 'notImplemented', message: 'Not implemented' };

    mockServiceInstance.generateAvatars.mockResolvedValue(Result.err(domainError));

    const result = await mutation.execute(input);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('notImplemented');
  });
});