TournamentService.java

package hdm.mi.sthbackend.service;

import hdm.mi.sthbackend.dto.PlayerDTO;
import hdm.mi.sthbackend.dto.TeamDTO;
import hdm.mi.sthbackend.exeptions.PlayerIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TeamIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.Player;
import hdm.mi.sthbackend.model.Team;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.IMatchRepository;
import hdm.mi.sthbackend.repository.IPlayerRepository;
import hdm.mi.sthbackend.repository.ITeamRepository;
import hdm.mi.sthbackend.repository.ITournamentRepository;
import lombok.AllArgsConstructor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Service
@AllArgsConstructor
public class TournamentService {

    private final Logger logger = LogManager.getLogger(TournamentService.class);

    ITournamentRepository tournamentRepository;
    IPlayerRepository playerRepository;
    ITeamRepository teamRepository;
    IMatchRepository matchRepository;

    public Player addPlayerToTeam(UUID teamId,
                                  String playerName) throws TeamIdNotFoundException {
        Team team = teamRepository.findById(teamId)
                .orElseThrow(() -> new TeamIdNotFoundException(teamId));

        Player newPlayer = new Player(UUID.randomUUID(), playerName);
        team.getTeamMembers()
                .add(newPlayer.getPlayerId());

        playerRepository.insert(newPlayer);
        teamRepository.save(team);

        return newPlayer;
    }

    public PlayerDTO findPlayerById(UUID playerId) throws PlayerIdNotFoundException {
        Player player = playerRepository.findById(playerId)
                .orElseThrow(() -> new PlayerIdNotFoundException(playerId));

        return new PlayerDTO(player.getPlayerId(), player.getName());
    }

    public PlayerDTO removePlayerFromTeam(UUID teamId,
                                          UUID playerId) throws PlayerIdNotFoundException, TeamIdNotFoundException {
        Team team = teamRepository.findById(teamId)
                .orElseThrow(() -> new TeamIdNotFoundException(teamId));
        Player playerToDelete = playerRepository.findById(playerId)
                .orElseThrow(() -> new PlayerIdNotFoundException(playerId));
        try {
            team.getTeamMembers()
                    .remove(playerToDelete.getPlayerId());
        } catch (NullPointerException e) {
            throw new PlayerIdNotFoundException(playerId);
        }

        playerRepository.delete(playerToDelete);
        teamRepository.save(team);

        return new PlayerDTO(playerToDelete.getPlayerId(), playerToDelete.getName());
    }

    public UUID updatePlayerName(UUID playerId,
                                 String newPlayerName) throws PlayerIdNotFoundException {
        Player player = playerRepository.findById(playerId)
                .orElseThrow(() -> new PlayerIdNotFoundException(playerId));
        player.setName(newPlayerName);
        playerRepository.save(player);
        return playerId;
    }

    public TeamDTO findTeamById(UUID teamId) throws TeamIdNotFoundException {
        Team team = teamRepository.findById(teamId)
                .orElseThrow(() -> new TeamIdNotFoundException(teamId));

        Map<UUID, PlayerDTO> teamMembers = new HashMap<>();

        team.getTeamMembers().
                forEach(pId -> playerRepository.findById(pId)
                        .ifPresent(p -> teamMembers.put(p.getPlayerId(), new PlayerDTO(p.getPlayerId(), p.getName()))));

        return new TeamDTO(team.getId(), team.getTeamName(), teamMembers);
    }

    public Team createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));

        Team newTeam = new Team(UUID.randomUUID(), teamName, new ArrayList<>());

        tournament.getTeams()
                .add(newTeam.getId());

        teamRepository.insert(newTeam);
        tournamentRepository.save(tournament);
        return newTeam;
    }

    public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId,
                                                  UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));

        Team teamToDelete = teamRepository.findById(teamId)
                .orElseThrow(() -> new TeamIdNotFoundException(teamId));
        try {
            tournament.getTeams()
                    .remove(teamToDelete.getId());
        } catch (NullPointerException e) {
            throw new TeamIdNotFoundException(tournamentId);
        }
        teamRepository.delete(teamToDelete);
        tournamentRepository.save(tournament);
        return teamId;
    }

    public Tournament createTournament(String tournamentName) {
        Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new ArrayList<>());
        tournamentRepository.insert(tournament);
        return tournament;
    }

    // determineWinner and assignTeamToMatch


}