Problem01Ranking

package O7AssocietiveArrays.MoreExercise;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class Problem01Ranking {
    public static void main(String[] args) throws IOException {
        BufferedReader reader =
            new BufferedReader(
                new InputStreamReader(
                    System.in
                )
            );

        LinkedHashMap<String, String> initialInfo = new LinkedHashMap<>();

        String input1;

        while (!"end of contests".equalsIgnoreCase(input1= reader.readLine())) {
            String[] tokens = input1.split("\\s+:\\s+|:");
            String contest = tokens[0];
            String password = tokens[1];

            if (!initialInfo.containsKey(contest)) {
                initialInfo.put(contest, password);
            }

        }

        TreeMap<String, LinkedHashMap<String, Integer>> userDependence =
                new TreeMap<>();
        LinkedHashMap<String, Integer> sumUser = new LinkedHashMap<>();
        String input2;

        while (!"end of submissions".equalsIgnoreCase(input2=reader.readLine())) {
            String[] tokens = input2.split("=>");
            String contest = tokens[0];
            String password = tokens[1];
            String user = tokens[2];
            int points = Integer.parseInt(tokens[3]);

            if (initialInfo.containsKey(contest)
                    &&
                    initialInfo.get(contest).equals(password)) {

                int subtractPoints = 0;

                if (!userDependence.containsKey(user)){
                    userDependence.put(user, new LinkedHashMap<>());
                    userDependence.get(user).put(contest, points);
                } else if (userDependence.containsKey(user)
                        && userDependence
                            .get(user)
                            .containsKey(contest)
                               && userDependence
                .get(user)
                .get(contest) <= points ) {

                    subtractPoints = userDependence.get(user).get(contest);
                    userDependence.get(user).put(contest, points);

                } else if (userDependence.containsKey(user)
                        && userDependence
                        .get(user)
                        .containsKey(contest)
                        && userDependence
                        .get(user)
                        .get(contest) > points ) {

                    subtractPoints = points;

                } else if (userDependence.containsKey(user)
                        && !userDependence
                        .get(user)
                        .containsKey(contest)){

                    userDependence
                            .get(user)
                            .put(contest, points);
                }

                if (!sumUser.containsKey(user)) {
                    sumUser.put(user, points);
                } else {

                    sumUser.put(user, sumUser.get(user)  + points - subtractPoints);

                }
            }

        }

        sumUser
                .entrySet()
                .stream()
                .sorted((e1,e2)->
                        Integer.compare(e2.getValue(), e1.getValue()))
                .limit(1)
                .forEach((key)->
                        System.out.println(
                                String.format(
                                        "Best candidate is %s with total %d points.",
                                        key.getKey()
                                        ,key.getValue()
                                        )));

        System.out.println("Ranking: ");
        for (Map.Entry<String, LinkedHashMap<String, Integer>> key : userDependence
                .entrySet()) {
            System.out.println(key.getKey());
            key
                    .getValue()
                    .entrySet()
                    .stream()
                    .sorted((p1, p2) ->
                            Integer.compare(p2.getValue(), p1.getValue()))
                    .forEach(e ->
                            System.out.println(String.format(
                                    "#  %s -> %d",
                                    e.getKey(),
                                    e.getValue()
                            )));
        }

    }
}