import type { ITeamRepository } from '../../domain/repositories/ITeamRepository';
import type { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
import type {
  TeamMembership,
  TeamMembershipStatus,
  TeamRole,
} from '../../domain/types/TeamMembership';
import type { JoinTeamCommandDTO } from '../dto/TeamCommandAndQueryDTO';
import type { AsyncUseCase } from '@core/shared/application';
import type { Logger } from '@core/shared/application';
import {
  BusinessRuleViolationError,
  EntityNotFoundError,
} from '../errors/RacingApplicationError';
 
export class JoinTeamUseCase implements AsyncUseCase<JoinTeamCommandDTO, void> {
  constructor(
    private readonly teamRepository: ITeamRepository,
    private readonly membershipRepository: ITeamMembershipRepository,
    private readonly logger: Logger,
  ) {}

  async execute(command: JoinTeamCommandDTO): Promise<void> {
    this.logger.debug('Attempting to join team', { command });
    const { teamId, driverId } = command;

    try {
      const existingActive = await this.membershipRepository.getActiveMembershipForDriver(
        driverId,
      );
      if (existingActive) {
        this.logger.warn('Driver already belongs to a team', { driverId, teamId });
        throw new BusinessRuleViolationError('Driver already belongs to a team');
      }

      const existingMembership = await this.membershipRepository.getMembership(teamId, driverId);
      if (existingMembership) {
        this.logger.warn('Driver already has a pending or active membership request', { driverId, teamId });
        throw new BusinessRuleViolationError('Already a member or have a pending request');
      }

      const team = await this.teamRepository.findById(teamId);
      if (!team) {
        this.logger.error('Team not found', { entity: 'team', id: teamId });
        throw new EntityNotFoundError({ entity: 'team', id: teamId });
      }

      const membership: TeamMembership = {
        teamId,
        driverId,
        role: 'driver' as TeamRole,
        status: 'active' as TeamMembershipStatus,
        joinedAt: new Date(),
      };

      await this.membershipRepository.saveMembership(membership);
      this.logger.info('Driver successfully joined team', { driverId, teamId });
    } catch (error) {
      if (error instanceof BusinessRuleViolationError || error instanceof EntityNotFoundError) {
        throw error;
      }
      this.logger.error('Failed to join team due to an unexpected error', { error, command });
      throw error;
    }
  }
}