package Presenter.Evaluation;

import Model.Arrangement;
import Model.Interval;
import Model.Line;
import Presenter.Algorithms.*;
import Presenter.Generator.DatasetGenerator;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 01.08.2017.
 */
public class EvaluateAlgorithms {

    private  Arrangement arrangement;
    private Double[] lmsResult;
    private Double[] rmResult;
    private Double[] tsResult;

    private String[] names = {"MSE:\n", "RMSE:\n", "MAE:\n", "MdAE:\n"};

    public EvaluateAlgorithms(){
        this.arrangement = new Arrangement();
    }

    public static void main(String args[]){
        EvaluateAlgorithms e = new EvaluateAlgorithms();
        try {
            e.run();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
    }

    public void run() throws InterruptedException {

        Thread thread = new Thread(() -> {
            DatasetGenerator generator = new DatasetGenerator();
            arrangement.setLines(generator.generateDataset());

            IntersectionCounter counter = new IntersectionCounter();
            counter.run(arrangement.getLines(), new Interval(-99999,99999));
            counter.calculateIntersectionAbscissas(arrangement);
        });
        thread.start();
        thread.join();


        Thread lms = new Thread(() -> {
            LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines()
                                                                                    ,arrangement.getNodes());
            lmsAlg.run();
            lmsAlg.getResult();
            List<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
            lmsResult = getResults(errors);
        });
        Thread rm = new Thread(() -> {
            RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines());
            rmAlg.run();
            rmAlg.getResult();
            List<Double> errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
            rmResult = getResults(errors);
        });
        Thread ts = new Thread(() -> {
            TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes());
            tsAlg.run();
            tsAlg.getResult();
            List<Double> errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
            tsResult = getResults(errors);
        });

        lms.start();
        rm.start();
        ts.start();
        lms.join();
        rm.join();
        ts.join();

        for (int i=0;i<4;i++){
            System.out.print(names[i]);
            System.out.println("LMS: "+ lmsResult[i] + "\tTS: " + tsResult[i] + "\tRM: " + rmResult[i] + "\n\n");
        }
    }


    public Double[] getResults(List<Double> errorValues){

        Double[] ret = new Double[4];
        ret[0] = mse(errorValues);
        ret[1] = rmse(errorValues);
        ret[2] = mae(errorValues);
        ret[3] = mdae(errorValues);

        return ret;

    }

    /* Skalierungs Abhängige Approximationsgüten */
    public Double mse(List<Double> errorValues){
        double error = 0;

        for (Double d : errorValues){
            error += Math.pow(d,2);
        }

        error /= errorValues.size();

        return error;
    }

    public Double rmse(List<Double> errorValues){
        return Math.sqrt(mse(errorValues));
    }

    public Double mae(List<Double> errorValues){
        double error = 0;

        for (Double d : errorValues){
            error += Math.abs(d);
        }

        error /= errorValues.size();

        return error;
    }

    public Double mdae(List<Double> errorValues){
        return FastElementSelector.randomizedSelect((ArrayList<Double>) errorValues, errorValues.size()*0.5);
    }


    public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b){

        //Liste mit den Fehler zu jedem Punkt
        List<Double> sampsonerror = new ArrayList<>();

        for (Line line : lines){
            Double error = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m,2) + 1);
            sampsonerror.add(error);
        }

        return sampsonerror;
    }

}