package com.dimitrija.LogProcessorTest;

import java.util.*;
import java.util.stream.Collectors;



interface Log {

    //todo: complete interface
    int getLogId();
    String getLogMessage();
    double getLogProblemValue();
    int getStatusCode();
}

class SystemALog implements Log {

    private int logId;
    private String logMessage;

    public SystemALog(int logId, String logMessage) {
        this.logId = logId;
        this.logMessage = logMessage;
    }

    @Override
    public int getLogId() {
        return logId;
    }

    @Override
    public String getLogMessage() {
        return logMessage;
    }

    @Override
    public double getLogProblemValue() {
        return logMessage.hashCode() + 2.45 * logId;
    }

    //todo: implement method
    @Override
    public int getStatusCode() {
        return 0;
    }

    @Override
    public String toString() {
        return "SystemALog{" +
                "logId=" + logId +
                ", logMessage='" + logMessage + '\'' +
                '}';
    }
}

class SystemBLog implements Log {

    private String logId;
    private String logMessage;

    public SystemBLog(String logId, String logMessage) {
        this.logId = logId;
        this.logMessage = logMessage;
    }

    @Override
    public int getLogId() {
        return logId.hashCode();
    }

    @Override
    public String getLogMessage() {
        return logMessage;
    }

    @Override
    public double getLogProblemValue() {
        return logMessage.hashCode() * 3.45 + getLogId() * 1.35;
    }

    //todo: implement method
    @Override
    public int getStatusCode() {
        return 0;
    }

    @Override
    public String toString() {
        return "SystemBLog{" +
                "logId='" + logId + '\'' +
                ", logMessage='" + logMessage + '\'' +
                '}';
    }
}

interface LogProcessor<R extends Log> {
    R compute(ArrayList<R> Logs);
}

class Logs<T extends Log>{

    //todo: add fields
    private ArrayList<T> logs;
    //todo: constructor

    public Logs(ArrayList<T> logs) {
        logs = new ArrayList<>();
    }

    public <R extends Log> void process(LogProcessor<T> processor) {
        System.out.println(processor.compute(logs));
    }
}

public class LogProcessorTest<T extends Log> {

    public static void main(String[] args) {

        ArrayList<SystemALog> systemALogsList = new ArrayList<>();
        ArrayList<SystemBLog> systemBLogsList = new ArrayList<>();

        String[] logTexts = {"STATUS CODE 500 SERVER ERROR", "STATUS CODE 304", "STATUS CODE 200 OK", "DATABASE DOWN ERROR", "SERVICE X NOT RUNNING",
                "STATUS CODE 201", "STATUS CODE 302", "SERVICE Z NOT RUNNING", "AUTHENTICATION ERROR", "AUTHORIZATION ERROR"};

        Scanner sc = new Scanner(System.in);
        int countSystemALogs;
        countSystemALogs = Integer.parseInt(sc.nextLine());
        while (countSystemALogs > 0) {
            int id = Integer.parseInt(sc.nextLine());
            systemALogsList.add(new SystemALog(id, logTexts[id]));
            --countSystemALogs;
        }

        int countSystemBLogs;
        countSystemBLogs = Integer.parseInt(sc.nextLine());
        while (countSystemBLogs > 0) {
            String line = sc.nextLine();
            String[] parts = line.split(":");
            String text = Arrays.stream(parts).skip(1).collect(Collectors.joining(" "));
            systemBLogsList.add(new SystemBLog(parts[0], text));
            --countSystemBLogs;
        }

        Logs<SystemALog> logsA = new Logs<>(systemALogsList);

        //todo: first processor
        LogProcessor<SystemALog> firstProcessor = (logs) -> {

        System.out.println(logs.stream().filter(x-> x.getLogMessage().contains("ERROR")).count());

        //NEZNAM STO DA VRATI ME FAKJA PANIKA
        return null;
        };

                System.out.println("----- RESULTS FROM THE FIRST PROCESSOR -----");
        logsA.process(firstProcessor);

        //todo: second processor
        LogProcessor<SystemALog> secondProcessor =(logs) -> {
            DoubleSummaryStatistics doubleSummaryStatistics = logs.stream().mapToDouble(SystemALog::getLogProblemValue).summaryStatistics();
            System.out.println(doubleSummaryStatistics);
            return null;
        };
                System.out.println("----- RESULTS FROM THE SECOND PROCESSOR -----");
        logsA.process(secondProcessor);

        Logs<SystemBLog> logsB = new Logs<>(systemBLogsList);

        //todo: third processor
        LogProcessor<SystemBLog> thirdProcessor =(logs) -> {
            logs =  logs.stream().sorted().collect(Collectors.toCollection(ArrayList::new));
            System.out.println(logs);
           return null;
        };
                System.out.println("----- RESULTS FROM THE THIRD PROCESSOR -----");
        logsB.process(thirdProcessor);

        //TODO fourth processor
        LogProcessor<SystemBLog> fourthProcessor =(logs) -> {
            double totalProblems = logs.stream().mapToDouble(SystemBLog::getLogProblemValue).sum();
            System.out.println(totalProblems);
            return null;
        };
                System.out.println("----- RESULTS FROM THE FOURTH PROCESSOR -----");
        logsB.process(fourthProcessor);
    }
}