import { describe, it, expect, beforeEach } from 'vitest';
import { TeamsTestContext } from '../TeamsTestContext';
import { Team } from '../../../../core/racing/domain/entities/Team';

describe('CreateTeamUseCase', () => {
  const context = new TeamsTestContext();
  const createTeamUseCase = context.createCreateTeamUseCase();

  beforeEach(() => {
    context.clear();
  });

  describe('Success Path', () => {
    it('should create a team with all required fields', async () => {
      const driverId = 'd1';
      const leagueId = 'l1';
      
      const result = await createTeamUseCase.execute({
        name: 'Test Team',
        tag: 'TT',
        description: 'A test team',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isOk()).toBe(true);
      const { team } = result.unwrap();
      
      expect(team.name.toString()).toBe('Test Team');
      expect(team.tag.toString()).toBe('TT');
      expect(team.description.toString()).toBe('A test team');
      expect(team.ownerId.toString()).toBe(driverId);
      expect(team.leagues.map(l => l.toString())).toContain(leagueId);
      
      const savedTeam = await context.teamRepository.findById(team.id.toString());
      expect(savedTeam).toBeDefined();
      expect(savedTeam?.name.toString()).toBe('Test Team');
      
      const membership = await context.membershipRepository.getMembership(team.id.toString(), driverId);
      expect(membership).toBeDefined();
      expect(membership?.role).toBe('owner');
      expect(membership?.status).toBe('active');
    });

    it('should create a team with optional description', async () => {
      const driverId = 'd2';
      const leagueId = 'l2';
      
      const result = await createTeamUseCase.execute({
        name: 'Team With Description',
        tag: 'TWD',
        description: 'This team has a detailed description',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isOk()).toBe(true);
      const { team } = result.unwrap();
      expect(team.description.toString()).toBe('This team has a detailed description');
    });
  });

  describe('Validation', () => {
    it('should reject team creation with empty team name', async () => {
      const driverId = 'd4';
      const leagueId = 'l4';
      
      const result = await createTeamUseCase.execute({
        name: '',
        tag: 'TT',
        description: 'A test team',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isErr()).toBe(true);
      const error = result.unwrapErr();
      expect(error.code).toBe('REPOSITORY_ERROR');
    });

    it('should reject team creation with empty description', async () => {
      const driverId = 'd3';
      const leagueId = 'l3';
      
      const result = await createTeamUseCase.execute({
        name: 'Minimal Team',
        tag: 'MT',
        description: '',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isErr()).toBe(true);
      const error = result.unwrapErr();
      expect(error.code).toBe('REPOSITORY_ERROR');
    });

    it('should reject team creation when driver already belongs to a team', async () => {
      const driverId = 'd6';
      const leagueId = 'l6';
      
      const existingTeam = Team.create({ id: 'existing', name: 'Existing Team', tag: 'ET', description: 'Existing', ownerId: driverId, leagues: [] });
      await context.teamRepository.create(existingTeam);
      await context.membershipRepository.saveMembership({
        teamId: 'existing',
        driverId: driverId,
        role: 'driver',
        status: 'active',
        joinedAt: new Date()
      });
      
      const result = await createTeamUseCase.execute({
        name: 'New Team',
        tag: 'NT',
        description: 'A new team',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isErr()).toBe(true);
      const error = result.unwrapErr();
      expect(error.code).toBe('VALIDATION_ERROR');
      expect(error.details.message).toContain('already belongs to a team');
    });
  });

  describe('Business Logic', () => {
    it('should set the creating driver as team captain', async () => {
      const driverId = 'd10';
      const leagueId = 'l10';
      
      const result = await createTeamUseCase.execute({
        name: 'Captain Team',
        tag: 'CT',
        description: 'A team with captain',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isOk()).toBe(true);
      const { team } = result.unwrap();
      
      const membership = await context.membershipRepository.getMembership(team.id.toString(), driverId);
      expect(membership).toBeDefined();
      expect(membership?.role).toBe('owner');
    });

    it('should generate unique team ID', async () => {
      const driverId = 'd11';
      const leagueId = 'l11';
      
      const result = await createTeamUseCase.execute({
        name: 'Unique Team',
        tag: 'UT',
        description: 'A unique team',
        ownerId: driverId,
        leagues: [leagueId]
      });

      expect(result.isOk()).toBe(true);
      const { team } = result.unwrap();
      expect(team.id.toString()).toBeDefined();
      expect(team.id.toString().length).toBeGreaterThan(0);
      
      const existingTeam = await context.teamRepository.findById(team.id.toString());
      expect(existingTeam).toBeDefined();
      expect(existingTeam?.id.toString()).toBe(team.id.toString());
    });

    it('should set creation timestamp', async () => {
      const driverId = 'd12';
      const leagueId = 'l12';
      
      const beforeCreate = new Date();
      const result = await createTeamUseCase.execute({
        name: 'Timestamp Team',
        tag: 'TT',
        description: 'A team with timestamp',
        ownerId: driverId,
        leagues: [leagueId]
      });
      const afterCreate = new Date();

      expect(result.isOk()).toBe(true);
      const { team } = result.unwrap();
      expect(team.createdAt).toBeDefined();
      
      const createdAt = team.createdAt.toDate();
      expect(createdAt.getTime()).toBeGreaterThanOrEqual(beforeCreate.getTime());
      expect(createdAt.getTime()).toBeLessThanOrEqual(afterCreate.getTime());
    });
  });
});