JF-Maps-MoreExercise-03.MOBA(90/100)

package com.company;

import java.util.*;

public class MOBAChallenger {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String input = sc.nextLine();
        Map<String, HashMap<String, Integer>> players = new HashMap<>();
        Map<String, Integer> totalSkillPoints = new TreeMap<>();

        while (!input.equals("Season end")) {

            if (input.contains("->")) {
                String[] tokens = input.split(" -> ");
                String name = tokens[0];
                String position = tokens[1];
                int skill = Integer.parseInt(tokens[2]);

                if (!players.containsKey(name)) {
                    players.put(name, new HashMap<>());
                    players.get(name).put(position, skill);

                } else {
                    if (players.get(name).containsKey(position)) {
                        int currSkill = players.get(name).get(position);
                        if (skill > currSkill) {
                            players.get(name).put(position, skill);

                        }
                    } else {
                        players.get(name).put(position, skill);

                    }
                }

            } else if (input.contains(" vs ")) {
                String[] tokens = input.split(" vs ");
                String player1 = tokens[0];
                String player2 = tokens[1];

                boolean commonPosition = false;
                if (players.containsKey(player1) && players.containsKey(player2)) {
                    for (Map.Entry<String, Integer> entry : players.get(player1).entrySet()) {
                        for (Map.Entry<String, Integer> entry2 : players.get(player2).entrySet()) {
                            if (entry.getKey().equals(entry2.getKey())) {
                                commonPosition = true;
                            }
                        }
                    }
                    if (commonPosition) {
                        int totalSkillsPlayer1 = 0;
                        int totalSkillsPlayer2 = 0;
                        for (Integer integer : players.get(player1).values()) {
                            totalSkillsPlayer1 += integer;
                        }

                        for (Integer integer : players.get(player2).values()) {
                            totalSkillsPlayer2 += integer;
                        }

                        if (totalSkillsPlayer1 > totalSkillsPlayer2) {
                            players.remove(player2);

                        } else if (totalSkillsPlayer2 > totalSkillsPlayer1) {
                            players.remove(player1);

                        }
                    }

                } else {
                    input = sc.nextLine();
                    continue;
                }

            }
            input = sc.nextLine();
        }


        Map<String, Integer> tempPlayPool = new LinkedHashMap<>();
        players.entrySet().stream().sorted((f, s) -> {

            int bestPointsFirst = 0;
            Map<String, Integer> skillF = f.getValue();
            for (Map.Entry<String, Integer> first : skillF.entrySet()) {
                bestPointsFirst += first.getValue();
            }
            int bestPointsSecond = 0;
            Map<String, Integer> skillS = s.getValue();
            for (Map.Entry<String, Integer> second : skillS.entrySet()) {
                bestPointsSecond += second.getValue();
            }
            if (bestPointsFirst == bestPointsSecond) {
                return f.getKey().compareTo(s.getKey());
            } else {
                return Integer.compare(bestPointsSecond, bestPointsFirst);
            }
        })
                .forEach(e -> {
                    for (HashMap.Entry<String, HashMap<String, Integer>> entry : players.entrySet()) {

                        Map<String, Integer> skill = e.getValue();
                        int sumAll = 0;
                        for (Map.Entry<String, Integer> skillSum : skill.entrySet()) {
                            sumAll += skillSum.getValue();
                        }
                        tempPlayPool.put(e.getKey(), sumAll);
                    }
                });
        for (Map.Entry<String, Integer> entry : tempPlayPool.entrySet()) {
            System.out.printf("%s: %d skill%n", entry.getKey(), entry.getValue());
            for (HashMap.Entry<String, HashMap<String, Integer>> pool : players.entrySet()) {
                Map<String, Integer> skill = pool.getValue();
                skill.entrySet().stream()
                        .sorted((f, s) -> s.getValue().compareTo(f.getValue()))
                        .forEach(e -> {
                            if (entry.getKey().equals(pool.getKey())) {

                                System.out.printf("- %s <::> %d%n", e.getKey(), e.getValue());
                            }
                        });
            }

        }
    }
}