TournamentService.java

package hdm.mi.sthbackend.service;

import com.mongodb.client.MongoClient;
import hdm.mi.sthbackend.exeptions.MatchIdNotFoundException;
import hdm.mi.sthbackend.exeptions.PlayerIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TeamIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.*;
import hdm.mi.sthbackend.repository.ITournamentRepository;
import hdm.mi.sthbackend.repository.MongoManager;
import lombok.AllArgsConstructor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
@AllArgsConstructor
public class TournamentService {

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

    ITournamentRepository tournamentRepository;

    public Player addPlayerToTeam(UUID tournamentId,
                                  UUID teamId,
                                  String playerName) throws TournamentIdNotFoundException {
        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
        Player newPlayer = new Player(UUID.randomUUID(), playerName);
        tournament
                .getTeams()
                .get(teamId)
                .getTeamMembers()
                .put(newPlayer.getPlayerId(), newPlayer);
        tournamentRepository.save(tournament);
        log.debug("Player " + newPlayer.getPlayerId() + " added to Team " + teamId + " in Tournament " + tournamentId);
        return newPlayer;
    }



    /*
    Wie gehen wir damit um, wenn zwei Player denselben Namen haben? Also: Stefan vs Stefan = Stefan gewinnt
    Sollte man hier in den Methoden das ausschließen und dann geben die Spieler ihren ersten Buchstaben vom Nachnamen an? z.B. Stefan S. vs Stefan w.
    oder geben wir die UUID auch mit an zum PlayerName
     */




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

        Player removedPlayer = tournament.getTeams()
                .get(teamId)
                .getTeamMembers()
                .remove(playerId);

        tournamentRepository.save(tournament);
        log.debug("Player " + playerId + " removed from Team " + teamId + " in Tournament " + tournamentId);
        return removedPlayer;
    }


    /*
    Kann es passieren, dass hier bei der Methode removePlayerFromTeam() es den Player gar nicht gibt?
    und dann eine PlayerIdNotFoundException geworfen werden muss? oder ist durch die Übergabe von UUID playerId schon safe die playerId vorhanden
     */

    public UUID updatePlayerName(UUID tournamentId,
                                 UUID teamId,
                                 UUID playerId,
                                 String newPlayerName) throws TournamentIdNotFoundException, PlayerIdNotFoundException {
        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));

        tournament.getTeams()
                .get(teamId)
                .getTeamMembers()
                .get(playerId)
                .setName(newPlayerName);

        tournamentRepository.save(tournament);
        log.debug("Player " + playerId + " changed Name to " + newPlayerName + " in " +  teamId + " in Tournament " + tournamentId);
        return playerId;
    }

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

        Team team = new Team(UUID.randomUUID(), teamName, new HashMap<>() {
        });

        tournament.getTeams()
                .put(team.getId(), team);

        tournamentRepository.save(tournament);
        log.debug("Team " +  team.getId() + " added to Tournament " + tournamentId);
        return team;
    }

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

        Optional.ofNullable(tournament.getTeams()
                        .remove(teamId))
                .orElseThrow(() -> new TeamIdNotFoundException(tournamentId));
        tournamentRepository.save(tournament);
        log.debug("Team " + teamId + " added to Tournament " + tournamentId);
        return teamId;
    }

    public Tournament createTournament(String tournamentName) {
        MongoManager manager = new MongoManager();
        MongoClient client = manager.getMongoClient();
        manager.getTestCollection(client);

        Tournament tournament = new Tournament(UUID.randomUUID(), tournamentName, new ArrayList<>(), new HashMap<>());
        tournamentRepository.insert(tournament);
        tournamentRepository.save(tournament);// Muss es hier nochmal gespeichert werden?
        log.debug("created Tournament " + tournament.getTournamentId());
        return tournament;
    }

    public UUID determineWinner (UUID tournamentId, UUID matchId) throws TournamentIdNotFoundException, MatchIdNotFoundException{

        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));

        Match match = tournament.getMatches().stream()
                .filter(m -> m.getMatchId().equals(matchId))
                .findFirst()
                .orElseThrow(() -> new MatchIdNotFoundException(matchId));

        UUID winnerTeamId = match.getTeamScores().entrySet().stream()
                .max(Comparator.<Map.Entry<UUID, Number>, Double>comparing(entry -> entry.getValue().doubleValue()))
                .map(Map.Entry::getKey)
                .orElse(null);

        match.setWinnerTeamId(winnerTeamId);
        tournamentRepository.save(tournament);
        log.debug("The Winner " + winnerTeamId + " is determined for Match " + matchId + " in Tournament " + tournamentId);
        return winnerTeamId;
    }

    public void assignTeamToMatch(UUID tournamentId, UUID matchId, UUID teamId, int score) throws TournamentIdNotFoundException, MatchIdNotFoundException {
        Tournament tournament = tournamentRepository.findById(tournamentId)
                .orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));

        Match match = tournament.getMatches().stream()
                .filter(m -> m.getMatchId().equals(matchId))
                .findFirst()
                .orElseThrow(() -> new MatchIdNotFoundException(matchId));


        match.getTeamScores().put(teamId,score);
        tournamentRepository.save(tournament);
        log.debug("Team " + teamId + " assign to Match " + matchId + " in Tournament " + tournamentId);
    }

    /*
    Weitere Methoden:
    Gewinner bestimmen, defineWinner()
    Teams Matches zuordnen,

     */


}