import { describe, it, expect, beforeEach } from 'vitest';
import { MediaTestContext } from '../MediaTestContext';
import { AvatarGenerationRequest } from '@core/media/domain/entities/AvatarGenerationRequest';

describe('Avatar Management: Generation and Selection', () => {
  let ctx: MediaTestContext;

  beforeEach(() => {
    ctx = MediaTestContext.create();
    ctx.reset();
  });

  describe('RequestAvatarGenerationUseCase', () => {
    it('should request avatar generation from photo', async () => {
      const result = await ctx.requestAvatarGenerationUseCase.execute({
        userId: 'user-1',
        facePhotoData: 'https://example.com/face-photo.jpg',
        suitColor: 'red',
        style: 'realistic',
      });

      expect(result.isOk()).toBe(true);
      const successResult = result.unwrap();
      expect(successResult.requestId).toBeDefined();
      expect(successResult.status).toBe('completed');
      expect(successResult.avatarUrls).toHaveLength(3);

      const request = await ctx.avatarGenerationRepository.findById(successResult.requestId);
      expect(request).not.toBeNull();
      expect(request?.status).toBe('completed');
    });

    it('should reject generation with invalid face photo', async () => {
      const originalValidate = ctx.faceValidation.validateFacePhoto;
      ctx.faceValidation.validateFacePhoto = async () => ({
        isValid: false,
        hasFace: false,
        faceCount: 0,
        confidence: 0.0,
        errorMessage: 'No face detected',
      });

      const result = await ctx.requestAvatarGenerationUseCase.execute({
        userId: 'user-1',
        facePhotoData: 'https://example.com/invalid-photo.jpg',
        suitColor: 'red',
      });

      expect(result.isErr()).toBe(true);
      expect(result.unwrapErr().code).toBe('FACE_VALIDATION_FAILED');

      ctx.faceValidation.validateFacePhoto = originalValidate;
    });
  });

  describe('SelectAvatarUseCase', () => {
    it('should select a generated avatar', async () => {
      const request = AvatarGenerationRequest.create({
        id: 'request-1',
        userId: 'user-1',
        facePhotoUrl: 'https://example.com/face-photo.jpg',
        suitColor: 'red',
        style: 'realistic',
      });
      request.completeWithAvatars([
        'https://example.com/avatar-1.png',
        'https://example.com/avatar-2.png',
        'https://example.com/avatar-3.png',
      ]);
      await ctx.avatarGenerationRepository.save(request);

      const result = await ctx.selectAvatarUseCase.execute({
        requestId: 'request-1',
        selectedIndex: 1,
      });

      expect(result.isOk()).toBe(true);
      const successResult = result.unwrap();
      expect(successResult.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');

      const updatedRequest = await ctx.avatarGenerationRepository.findById('request-1');
      expect(updatedRequest?.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');
    });

    it('should reject selection when request does not exist', async () => {
      const result = await ctx.selectAvatarUseCase.execute({
        requestId: 'non-existent-request',
        selectedIndex: 0,
      });

      expect(result.isErr()).toBe(true);
      expect(result.unwrapErr().code).toBe('REQUEST_NOT_FOUND');
    });

    it('should reject selection when request is not completed', async () => {
      const request = AvatarGenerationRequest.create({
        id: 'request-1',
        userId: 'user-1',
        facePhotoUrl: 'https://example.com/face-photo.jpg',
        suitColor: 'red',
        style: 'realistic',
      });
      await ctx.avatarGenerationRepository.save(request);

      const result = await ctx.selectAvatarUseCase.execute({
        requestId: 'request-1',
        selectedIndex: 0,
      });

      expect(result.isErr()).toBe(true);
      expect(result.unwrapErr().code).toBe('REQUEST_NOT_COMPLETED');
    });
  });
});