import { describe, it, expect, vi, beforeEach } from 'vitest';
import { CreateLeagueUseCase } from './CreateLeagueUseCase';
import { LeagueCreateCommand } from '../ports/LeagueCreateCommand';

describe('CreateLeagueUseCase', () => {
  let mockLeagueRepository: any;
  let mockEventPublisher: any;
  let useCase: CreateLeagueUseCase;

  beforeEach(() => {
    mockLeagueRepository = {
      create: vi.fn().mockImplementation((data) => Promise.resolve(data)),
      updateStats: vi.fn().mockResolvedValue(undefined),
      updateFinancials: vi.fn().mockResolvedValue(undefined),
      updateStewardingMetrics: vi.fn().mockResolvedValue(undefined),
      updatePerformanceMetrics: vi.fn().mockResolvedValue(undefined),
      updateRatingMetrics: vi.fn().mockResolvedValue(undefined),
      updateTrendMetrics: vi.fn().mockResolvedValue(undefined),
      updateSuccessRateMetrics: vi.fn().mockResolvedValue(undefined),
      updateResolutionTimeMetrics: vi.fn().mockResolvedValue(undefined),
      updateComplexSuccessRateMetrics: vi.fn().mockResolvedValue(undefined),
      updateComplexResolutionTimeMetrics: vi.fn().mockResolvedValue(undefined),
    };
    mockEventPublisher = {
      emitLeagueCreated: vi.fn().mockResolvedValue(undefined),
    };
    useCase = new CreateLeagueUseCase(mockLeagueRepository, mockEventPublisher);
  });

  it('should create a league and initialize all metrics', async () => {
    const command: LeagueCreateCommand = {
      name: 'New League',
      ownerId: 'owner-1',
      visibility: 'public',
      approvalRequired: false,
      lateJoinAllowed: true,
      bonusPointsEnabled: true,
      penaltiesEnabled: true,
      protestsEnabled: true,
      appealsEnabled: true,
    };

    const result = await useCase.execute(command);

    expect(result.name).toBe('New League');
    expect(result.ownerId).toBe('owner-1');
    expect(mockLeagueRepository.create).toHaveBeenCalled();
    expect(mockLeagueRepository.updateStats).toHaveBeenCalled();
    expect(mockLeagueRepository.updateFinancials).toHaveBeenCalled();
    expect(mockEventPublisher.emitLeagueCreated).toHaveBeenCalled();
  });

  it('should throw error if name is missing', async () => {
    const command: any = { ownerId: 'owner-1' };
    await expect(useCase.execute(command)).rejects.toThrow('League name is required');
  });

  it('should throw error if ownerId is missing', async () => {
    const command: any = { name: 'League' };
    await expect(useCase.execute(command)).rejects.toThrow('Owner ID is required');
  });
});