MOBA Challenger

package TechFundamentals;

import com.sun.source.tree.WhileLoopTree;

import java.sql.SQLOutput;
import java.util.*;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.spi.AbstractResourceBundleProvider;
import java.util.stream.Collectors;
import java.util.stream.IntStream;


public class array_temp {


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

        String input = scanner.nextLine();

        Map<String, Map<String, Integer>> mobaPlayer = new TreeMap<>();

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

                Map<String, Integer> positionAndSkill = mobaPlayer.get(name);
                if (!mobaPlayer.containsKey(name)) {
                    positionAndSkill = new HashMap<>();
                    positionAndSkill.put(position, skill);
                    mobaPlayer.put(name, positionAndSkill);
                } else {
                    if (!mobaPlayer.get(name).containsKey(position)) {
                        mobaPlayer.get(name).put(position, skill);
                    } else {
                        if (skill > mobaPlayer.get(name).get(position)) {
                            mobaPlayer.get(name).put(position, skill);
                        }
                    }
                }
            } else {
                String[] tokens = input.split(" vs ");
                String firstName = tokens[0];
                String secondName = tokens[1];

                if (mobaPlayer.containsKey(firstName)
                        && mobaPlayer.containsKey(secondName)) {
                    boolean checkOne = true;
                    boolean checkTwo = true;
                    for (Map.Entry<String, Integer> entryFirstName : mobaPlayer.get(firstName).entrySet()) {
                        for (Map.Entry<String, Integer> entrySecondName : mobaPlayer.get(secondName).entrySet()) {
                            if (entryFirstName.getKey().equals(entrySecondName.getKey())) {
                                int firstTotalSkill = 0;
                                int secondTotalSkill = 0;
                                for (Map.Entry<String, Integer> entryFirstTotalSkil : mobaPlayer.get(firstName).entrySet()) {
                                    firstTotalSkill += entryFirstTotalSkil.getValue();
                                }
                                for (Map.Entry<String, Integer> entrySecondTotalSkil : mobaPlayer.get(secondName).entrySet()) {
                                    secondTotalSkill += entrySecondTotalSkil.getValue();
                                }
                                if (firstTotalSkill > secondTotalSkill) {
                                    checkTwo = false;
                                    break;
                                } else if (firstTotalSkill < secondTotalSkill) {
                                    checkOne = false;
                                    break;
                                }

                            }
                        }
                    }
                    if (!checkOne) {
                        mobaPlayer.remove(firstName);
                    } else if (!checkTwo) {
                        mobaPlayer.remove(secondName);
                    }
                }
            }
            input = scanner.nextLine();
        }

        mobaPlayer.entrySet().stream()
                .sorted((f, s) -> {
                    int firstTotalSkill = 0;
                    int secondTotalSkill = 0;

                    for (Map.Entry<String, Integer> entryFirst : f.getValue().entrySet()) {
                        firstTotalSkill += entryFirst.getValue();
                    }
                    for (Map.Entry<String, Integer> entrySecond : s.getValue().entrySet()) {
                        secondTotalSkill += entrySecond.getValue();
                    }
                    if (firstTotalSkill - secondTotalSkill == 0) {
                        return f.getKey().compareTo(s.getKey());
                    } else {
                        return Integer.compare(secondTotalSkill, firstTotalSkill);
                    }
                })
                .forEach(e -> {
                    int totalSkill = 0;
                    for (Map.Entry<String, Integer> entry : e.getValue().entrySet()) {
                        totalSkill += entry.getValue();
                    }
                    System.out.printf("%s: %d skill%n", e.getKey(), totalSkill);

                    e.getValue().entrySet().stream().sorted((f, s) -> {
                        int sorted = s.getValue() - (f.getValue());
                        if (sorted == 0) {
                            return f.getKey().compareTo(s.getKey());
                        } else {
                            return s.getValue().compareTo(f.getValue());
                        }
                    })
                            .forEach(a -> System.out.printf("- %s <::> %d%n", a.getKey(), a.getValue()));
                });

    }
}