import type { Team, TeamJoinRequest } from '@gridpilot/racing';
import type { DriverDTO } from '@gridpilot/racing/application/dto/DriverDTO';
import { EntityMappers } from '@gridpilot/racing/application/mappers/EntityMappers';
import {
  getDriverRepository,
  getGetTeamJoinRequestsUseCase,
  getApproveTeamJoinRequestUseCase,
  getRejectTeamJoinRequestUseCase,
  getUpdateTeamUseCase,
} from '@/lib/di-container';

export interface TeamAdminJoinRequestViewModel {
  id: string;
  teamId: string;
  driverId: string;
  requestedAt: Date;
  message?: string;
  driver?: DriverDTO;
}

export interface TeamAdminTeamSummaryViewModel {
  id: string;
  name: string;
  tag: string;
  description: string;
  ownerId: string;
}

export interface TeamAdminViewModel {
  team: TeamAdminTeamSummaryViewModel;
  requests: TeamAdminJoinRequestViewModel[];
}

/**
 * Load join requests plus driver DTOs for a team.
 */
export async function loadTeamAdminViewModel(team: Team): Promise<TeamAdminViewModel> {
  const requests = await loadTeamJoinRequests(team.id);
  return {
    team: {
      id: team.id,
      name: team.name,
      tag: team.tag,
      description: team.description,
      ownerId: team.ownerId,
    },
    requests,
  };
}

export async function loadTeamJoinRequests(teamId: string): Promise<TeamAdminJoinRequestViewModel[]> {
  const getRequestsUseCase = getGetTeamJoinRequestsUseCase();
  await getRequestsUseCase.execute({ teamId });
  const presenterVm = getRequestsUseCase.presenter.getViewModel();

  const driverRepo = getDriverRepository();
  const allDrivers = await driverRepo.findAll();
  const driversById: Record<string, DriverDTO> = {};

  for (const driver of allDrivers) {
    const dto = EntityMappers.toDriverDTO(driver);
    if (dto) {
      driversById[dto.id] = dto;
    }
  }

  return presenterVm.requests.map((req) => ({
    id: req.requestId,
    teamId: req.teamId,
    driverId: req.driverId,
    requestedAt: new Date(req.requestedAt),
    message: req.message,
    driver: driversById[req.driverId],
  }));
}

/**
 * Approve a team join request and return updated request view models.
 */
export async function approveTeamJoinRequestAndReload(
  requestId: string,
  teamId: string,
): Promise<TeamAdminJoinRequestViewModel[]> {
  const useCase = getApproveTeamJoinRequestUseCase();
  await useCase.execute({ requestId });
  return loadTeamJoinRequests(teamId);
}

/**
 * Reject a team join request and return updated request view models.
 */
export async function rejectTeamJoinRequestAndReload(
  requestId: string,
  teamId: string,
): Promise<TeamAdminJoinRequestViewModel[]> {
  const useCase = getRejectTeamJoinRequestUseCase();
  await useCase.execute({ requestId });
  return loadTeamJoinRequests(teamId);
}

/**
 * Update team basic details.
 */
export async function updateTeamDetails(params: {
  teamId: string;
  name: string;
  tag: string;
  description: string;
  updatedByDriverId: string;
}): Promise<void> {
  const useCase = getUpdateTeamUseCase();
  await useCase.execute({
    teamId: params.teamId,
    updates: {
      name: params.name,
      tag: params.tag,
      description: params.description,
    },
    updatedBy: params.updatedByDriverId,
  });
}