package Presenter.Evaluation;

import Model.LineModel;
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;
import java.util.Observable;

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

    private LineModel arrangement;
    private Object[] lmsResult;
    private Object[] rmResult;
    private Object[] tsResult;

    private Thread lmsThread;
    private Thread rmThread;
    private Thread tsThread;

    public EvaluateAlgorithms(){}

    public void run() throws InterruptedException {

        this.arrangement = new LineModel();

        DatasetGenerator generator = new DatasetGenerator();
        arrangement.setLines(generator.generateDataset());

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


        lmsThread = 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, "Least Median of Squares");
            setChanged();
            notifyObservers(lmsResult);
        });
        rmThread = 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, "Repeated-Median");
            setChanged();
            notifyObservers(rmResult);
        });
        tsThread = 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, "Theil-Sen");
            setChanged();
            notifyObservers(tsResult);
        });

        lmsThread.start();
        rmThread.start();
        tsThread.start();

        lmsThread.join();
        rmThread.join();
        tsThread.join();

    }


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

        String[] ret = new String[6];
        ret[0] = name;
        ret[1] = mse(errorValues).toString();
        ret[2] = rmse(errorValues).toString();
        ret[3] = mae(errorValues).toString();
        ret[4] = mdae(errorValues).toString();
        ret[5] = "eval";

        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;
    }

}