package presenter.algorithms.naiv;

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

import java.util.ArrayList;
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 NaivTheilSenEstimator implements Algorithm {


    private LinkedList<Line> lines;
    private double slope;
    private double yInterception;

    /**
     * Konstruktor
     * @param lines Liste der Geraden
     */
    public NaivTheilSenEstimator(LinkedList<Line> lines) {
        this.lines = lines;
        this.slope = 0d;
        this.yInterception = 0d;
    }


    @Override
    public void run() {
        System.out.println("=== S T A R T - naiv T S ===");
        long start;
        long end;
        start = System.currentTimeMillis();
        ArrayList<Double> slopesList = new ArrayList<>();
        int cnt = 0;
        for (int i = 0; i < lines.size(); i++) {
            double x = lines.get(i).getM();
            double y = lines.get(i).getB();

            for (int j = i + 1; j < lines.size(); j++) {
                if (x != lines.get(j).getM()) { // x must be different, otherwise slope becomes infinite
                    Double slope = (lines.get(j).getB() - y) / (lines.get(j).getM() - x);
                    slopesList.add(slope);
                    ++cnt;
                }
            }
        }


        ArrayList<Double> list1 = new ArrayList<>();
        ArrayList<Double> list2 = new ArrayList<>();
        for (int i = 0; i < lines.size(); i++) {
            list1.add(lines.get(i).getM());
            list2.add(lines.get(i).getB());
        }
        double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
        double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
        slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
        yInterception = median2 - slope * median1;
        end = System.currentTimeMillis();
        System.out.println("Zeit: "+ ((end-start)/1000));
    }

    @Override
    public void pepareResult() {

    }

    /**
     * @return Steigung
     */
    public double getM() {
        return slope * -1;
    }

    /**
     * @return y-Achsenabschnitt
     */
    public double getB() {
        return yInterception * -1;
    }
}