Сръбско Unleashed

/*
* Сръбско Unleashed
*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.util.Comparator.comparing;

public class SrpskoUnleashed {
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private final static Pattern validInputPattern = Pattern
            .compile("(?:(?:(?:\\w+\\s\\w+)|(?:\\w+))\\s\\@(?:(?:\\w+\\s\\w+)|(?:\\w+))\\s\\d+\\s\\d+)");
    private final static Pattern singerNamePattern = Pattern
            .compile("(?:(?:\\w+\\s\\w+)|(?:\\w+))(?=\\s\\@)");
    private final static Pattern locationMPattern = Pattern
            .compile("(?<=\\@)(?:((?:[a-zA-Z])+\\s)){1,2}");
    private final static Pattern moneyPattern = Pattern
            .compile("\\d+\\s\\d+");
    private static List<String> validInput;
    private static Map<String, Map<String, Singer>> singersPerLocation;

    public static void main(String[] args) {
        singersPerLocation = new HashMap<>();
        List<String> inputList = new LinkedList<>();

        String[] input = null;

        while(true) {
            String line = null;

            try {
                line = reader.readLine().trim();
            } catch (IOException e) {
                e.printStackTrace();
            }

            if(line.equals("End"))
                break;

            inputList.add(line);
        }

        input = inputList.toArray(new String[0]);

        validInput = new LinkedList<>();
        for (String iString : input) {
            validateInputAndCollectValidData(iString);
        }
        int counter = 0;

        for (String inputItem : validInput) {
            Map<String, Singer> singersOfCurrentLocation;
            String singerName = extractSingerName(inputItem);
            int singerMoney = extractMoney(inputItem);
            String location = extractLocation(inputItem);
            Singer singer = null;

            if(singersPerLocation.containsKey(location)) {
                singersOfCurrentLocation = singersPerLocation.get(location);
            } else {
                singersOfCurrentLocation = new HashMap<>();
            }



            if (singersOfCurrentLocation.containsKey(singerName)) {
                singer = singersOfCurrentLocation.get(singerName);

            } else {
                singer = new Singer(singerName, counter);
                counter++;
            }

            singer.addMoney(singerMoney);

            singersOfCurrentLocation.put(singerName, singer);
            singersPerLocation.put(location, singersOfCurrentLocation);
        }


        singersPerLocation.entrySet().stream().map(x -> {
            return x.getKey();
        })
        .sorted(comparing(String::toString).reversed())
        .forEach(loc -> {
            System.out.println(loc);
            singersPerLocation.get(loc)
            .entrySet()
            .stream()
            .map(singerEntry -> {
                return singerEntry.getValue();
            })
            .sorted()
            .map(singer -> {
                return String.format("#  %s -> %d", singer.getName(), singer.getTotalMoney());
            })
            .forEach(System.out::println);
        });
    }

    private static String extractSingerName(String input) {
        String name = null;
        Matcher m = singerNamePattern.matcher(input);

        while (m.find() && name == null) {
            name = m.group();
        }

        return name;
    }

    private static int extractMoney(String input) {
        String money = null;
        Matcher m = moneyPattern.matcher(input);

        while (m.find() && money == null)
            money = m.group();

        Integer[] moneyAsNumbers =
                Arrays.asList(money.split("\\s+"))
                .stream()
                .map(x -> {
                    return Integer.valueOf(x);
                })
                .toArray(Integer[]::new);

        int output = 1;
        for (Integer i : moneyAsNumbers)
            output *= i;

        return output;
    }

    private static String extractLocation(String input) {
        String location = null;
        Matcher m = locationMPattern.matcher(input);

        while (m.find() && location == null)
            location = m.group().trim();

        return location;
    }

    private static void validateInputAndCollectValidData(String input) {
        String validData = null;
        Matcher m = validInputPattern.matcher(input);

        while (m.find()) {
            validData = m.group();
        }

        if (validData != null)
            validInput.add(validData);
    }

}

class Singer implements Comparable<Singer> {
    private String name;
    private int money;
    private int inputOrder;

    public Singer(String name, int counter) {
        this.name = name;
        this.money = 0;
        this.inputOrder = counter;
    }

    public String getName() {
        return this.name;
    }

    public int getTotalMoney() {
        return this.money;
    }

    public void addMoney(int money) {
        this.money += money;
    }

    public int getInputOrder() {
        return this.inputOrder;
    }

    @Override
    public int compareTo(Singer other) {
        int comparisson = -(this.getTotalMoney() - other.getTotalMoney());
        if (comparisson == 0) {
            return this.getInputOrder() - other.getInputOrder();
        } else
            return comparisson;
    }

    @Override
    public String toString() {
        return this.getName() + ": " + this.getTotalMoney();
    }



}