package presenter.algorithms.naiv;

import model.Line;
import model.Point;
import presenter.algorithms.Algorithm;
import presenter.util.FastElementSelector;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;

/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 15.09.2017.
 */
public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
    private ArrayList<Point> set = new ArrayList<>();

    private int n;
    private double ds, b, m;

    /**
     * Konstruktor
     * @param lines Liste des Geraden
     */
    public NaivLeastMedianOfSquaresEstimator(LinkedList<Line> lines) {
        for (Line l : lines) {
            set.add(new Point(l.getM(), l.getB()));
        }
    }

    /**
     * Crude Algorithmus zum berechnen des LSM-Schätzers.
     */
    private void crudeAlg() {
        ds = Double.MAX_VALUE;
        b = 0d;
        m = 0d;
        ArrayList<Point> triple = new ArrayList<>();
        double beta;
        double alpha;
        double dijk;
        System.out.println("=== S T A R T - naiv L M S ===");
        long start;
        long end;
        start = System.currentTimeMillis();
        for (Point i : set) {
            for (Point j : set) {
                for (Point k : set) {
                    triple.add(i);
                    triple.add(j);
                    triple.add(k);
                    Collections.sort(triple);
                    beta = (triple.get(0).getY() - triple.get(2).getY()) / (triple.get(0).getX() - triple.get(2).getX());
                    alpha = (triple.get(1).getY() + triple.get(2).getY() - (beta * (triple.get(1).getX() + triple.get(2).getX()))) / 2f;
                    dijk = f(alpha, beta);
                    if (dijk < ds) {
                        ds = dijk;
                        b = alpha;
                        m = beta;
                    }
                    triple.clear();
                }
            }
        }
        end = System.currentTimeMillis();
        System.out.println("Zeit: "+ ((end-start)/1000));
    }

    /**
     * Berechnet die Gerade mit dem medianen Fehler
     * @param a y-Achsenabschnitt
     * @param b Steigung
     * @return medianer Fehler
     */
    private Double f(double a, double b) {
        ArrayList<Double> res = new ArrayList<>();
        for (Point p : set) {
            res.add(Math.abs(p.getY() - (a + b * p.getX())));
        }
        return FastElementSelector.randomizedSelect(res, res.size() / 2);
    }

    @Override
    public void run() {
        crudeAlg();
    }

    @Override
    public void pepareResult() {

    }

    /**
     * @return y-Achsenabschnitt
     */
    public Double getB() {
        return b * -1;
    }

    /**
     * @return Steigung
     */
    public Double getM() {
        return m * -1;
    }
}