[NP] Services & Microservices

import java.util.Scanner;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.List;
import java.util.*;

class Microservice {
    String microserviceName;
    List<Log> logs;

    public Microservice(String microserviceName) {
        this.microserviceName = microserviceName;
        this.logs= new ArrayList<>();
    }

    public String getMicroserviceName() {
        return microserviceName;
    }


    public int getSerenity(){
        return logs.stream().mapToInt(i->i.getLogSerenity()).sum();
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder= new StringBuilder();
        for(Log l : logs){
            stringBuilder.append(String.format("%s %s",microserviceName,l.toString()));
        }
        return stringBuilder.toString().trim();
    }
}

class Log {
    String type;
    String message;
    int timestamp;

    public Log(String type, String message, int timestamp) {

        this.type = type;
        this.message = message;
        this.timestamp = timestamp;
    }


    public String getType() {
        return type;
    }

    public String getMessage() {
        return message;
    }

    public int getLogSerenity(){
        int serenity=0;
        if(type.equals("WARN")){
            serenity++;
            if(message.contains("might cause error"))
                serenity++;
        }
        else if(type.equals("ERROR")){
            serenity+=3;
            if(message.contains("fatal"))
                serenity+=2;
            if(message.contains("exception"))
                serenity+=3;
        }
        return serenity;
    }

    public int getTimestamp() {
        return timestamp;
    }

    @Override
    public String toString() {
        return String.format(" [%s]%s %d T:%d",type,message,timestamp,timestamp);
    }
}


class LogCollector {
    Map<String,Service> services;
    public LogCollector() {
        services= new HashMap<>();
    }

    public void addLog(String log) {
        String[] parts= log.split("\\s+");
        String service = parts[0];
        String microservice = parts[1];
        String type = parts[2];
        String message="";
        for(int i=3;i<parts.length-1;i++){
            message= message.concat(" "+parts[i]);
        }
        int timestamp= Integer.parseInt(parts[parts.length-1]);
        services.putIfAbsent(service,new Service(service));
        services.get(service).microservices.putIfAbsent(microservice,new Microservice(microservice));
        services.get(service).microservices.get(microservice).logs.add(new Log(type,message,timestamp));

    }

    public void printServicesBySeverity() {
        services.values().stream().sorted().forEach(i-> System.out.println(i));
    }

    public Map<Integer, Long> getSeverityDistribution(String service, String microservice) {
        if(microservice==null)
            return services.get(service).microservices.values().stream().flatMap(list->list.logs.stream()).collect(Collectors.groupingBy(
                    Log::getLogSerenity,
                    Collectors.counting()
            ));

        return services.get(service).microservices.get(microservice).logs.stream().collect(Collectors.groupingBy(
                Log::getLogSerenity,
                Collectors.counting()
        ));
    }

    public void displayLogs(String service, String microservice, String order) {

        Comparator<Log> OLDEST_FIRST = Comparator.comparing(Log::getTimestamp);
        Comparator<Log> NEWEST_FIRST = OLDEST_FIRST.reversed();
        Comparator<Log> LEAST_SEVERE_FIRST = Comparator.comparing(Log::getLogSerenity);
        Comparator<Log> MOST_SEVERE_FIRST = LEAST_SEVERE_FIRST.reversed();
        Comparator<Log> comparator;
        if(order.equals("OLDEST_FIRST"))
            comparator= OLDEST_FIRST;
        else if(order.equals("NEWEST_FIRST"))
            comparator= NEWEST_FIRST;
        else if(order.equals("LEAST_SEVERE_FIRST"))
            comparator= LEAST_SEVERE_FIRST;
        else
            comparator= MOST_SEVERE_FIRST;

        if(microservice==null){
            System.out.println(String.format("displayLogs %s %s",service,order));
            services.get(service).microservices.values()
                    .stream().flatMap(list->list.logs.stream()).sorted(comparator).forEach(i-> System.out.println(String.format("%s%s",service,i.toString())));
        }
        else{
            System.out.println(String.format("displayLogs %s %s %s",service,microservice,order));
            services.get(service).microservices.get(microservice)
                    .logs.stream().sorted(comparator).forEach(i-> System.out.println(String.format("%s|%s%s",service,microservice,i.toString())));
        }

    }
}

class Service implements Comparable<Service>{
    String serviceName;
    Map<String,Microservice> microservices;

    public int getSerenity(){
        return microservices.values().stream().mapToInt(i->i.getSerenity()).sum();
    }

    public double getAvgSerenity(){
        return getSerenity()/(double)getNumberOfLogs();
    }

    public int getNumberOfLogs(){
        return (int)microservices.values().stream().flatMap(list->list.logs.stream()).count();
    }

    public Service(String serviceName) {
        this.serviceName = serviceName;
        this.microservices = new HashMap<>();
    }

    @Override
    public String toString() {
        return String.format("Service name: %s Count of microservices: %d " +
                "Total logs in service: %d Average severity for all logs: %.2f " +
                "Average number of logs per microservice: %.2f",serviceName, microservices.size(),getNumberOfLogs()
                ,getAvgSerenity(),getNumberOfLogs()/(double)microservices.size());
    }

    @Override
    public int compareTo(Service o) {
        return Comparator.comparing(Service::getAvgSerenity).reversed().compare(this,o);
    }
}

public class LogsTester {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        LogCollector collector = new LogCollector();
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            if (line.startsWith("addLog")) {
                collector.addLog(line.replace("addLog ", ""));
            } else if (line.startsWith("printServicesBySeverity")) {
                collector.printServicesBySeverity();
            } else if (line.startsWith("getSeverityDistribution")) {
                String[] parts = line.split("\\s+");
                String service = parts[1];
                String microservice = null;
                if (parts.length == 3) {
                    microservice = parts[2];
                }
                collector.getSeverityDistribution(service, microservice).forEach((k,v)-> System.out.printf("%d -> %d%n", k,v));
            }

            else if (line.startsWith("displayLogs")){
                String[] parts = line.split("\\s+");
                String service = parts[1];
                String microservice = null;
                String order = null;
                if (parts.length == 4) {
                    microservice = parts[2];
                    order = parts[3];
                } else {
                    order = parts[2];
                }
                collector.displayLogs(service, microservice, order);
            }

        }
    }
}