package Presenter;

import Model.Arrangement;
import Model.Interval;
import Model.Line;
import Model.Point;
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
import Presenter.Algorithms.RepeatedMedianEstimator;
import Presenter.Algorithms.TheilSenEstimator;
import Presenter.Import.DataImporter;
import View.MainFrame;

import java.util.List;
import javax.swing.*;
import java.io.File;
import java.util.LinkedList;
import java.util.Observable;
import java.util.Observer;


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

  private Arrangement model;
  private MainFrame view;

  public Presenter(Arrangement model, MainFrame view) {
    this.model = model;
    this.view = view;
    /*  Double[] x = {1d, 2d, 3d, 4d, 10d, 12d, 18d};
        Double[] y = {9d, 15d, 19d, 20d, 45d, 55d, 78d};
        Double[] x = {18d, 24d, 30d, 34d, 38d};
        Double[] y = {18d, 26d, 30d, 40d, 70d};
        Double[] x = {1d,3d,4d,5d,8d};
        Double[] y = {4d,2d,1d,0d,0d};
        view.logHeading("Duale Darstellung der Punkte als Geraden:");
        for (int j = 0; j < x.length; j++) {
          Line p = new Line(x[j], y[j]);
          p.setId(j+"");
          view.log("f(x) = " + p.getM() + "x + " + p.getB());
          this.model.addLine(p);
        }

        calcArrangementNodes();
        //print
        List<String> heading = new LinkedList<>();
        List<List<String>> rows = new LinkedList<>();
        heading.add("X - Koordinate");
        heading.add("Y - Koordinate");
        for (Point p : model.getNodes()) {
          LinkedList<String> rowEntry = new LinkedList<>();
          rowEntry.add(p.getX().toString());
          rowEntry.add(p.getY().toString());
          rows.add(rowEntry);
        }
        view.logHeading("Schnittpunkte der Dualen Geraden:");
        view.createTable(heading, rows); */
  }


  @Override
  public void update(Observable o, Object arg) {
    String[] result = ((String[]) arg);
    if (result[0] == "lms"){
      SwingUtilities.invokeLater(() -> {
        getView().visualizeLMS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
        //getView().setLmsIsComplete(true);
        getView().logHeading("Least Median of Squares");
        getView().log("<b>m:</b> " + result[1]);
        getView().log("<b>b:</b> " + result[2]);
        getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
      });
    }

    if (result[0] == "rm"){
      SwingUtilities.invokeLater(() -> {
        getView().visualizeRM(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
        getView().logHeading("Repeated Median Estimator");
        getView().log("<b>m:</b> " + result[1]);
        getView().log("<b>b:</b> " + result[2]);
        getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
      });
    }

    if (result[0] == "ts"){
      SwingUtilities.invokeLater(() -> {
        getView().visualizeTS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
        getView().logHeading("Theil-Sen Estimator");
        getView().log("<b>m:</b> " + result[1]);
        getView().log("<b>b:</b> " + result[2]);
        getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
      });
    }

    if (result[0] == "import"){
        Double max = Double.parseDouble(result[1]);
        Double current = Double.parseDouble(result[2]);
        Integer progress = (int) (100 * (current/max));
        //100% erreicht
        if (progress == 100){
          SwingUtilities.invokeLater(() -> {
                getView().showImportProgress(progress);
                getView().enableFunctionality();
                getView().getProgressDialog().dispose();
              });
          setup();
          Thread t = new Thread(() -> {
            calcArrangementNodes();
          });
          t.start();
          try {
            t.join();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        } else {
          SwingUtilities.invokeLater(() -> {
          getView().showImportProgress(progress);
        });
        }

    }
  }

  public void visualizeDualLines() {
    view.createArrangement();
  }

  /***************************************************************************************************************************
   *                                          Ausführung der Algorithmen
   ***************************************************************************************************************************/
  public void calculateLMS(String[] input) {
    if (input[0] != null && input[1] != null){
      Double constant = Double.parseDouble(input[0]);
      Double error = Double.parseDouble(input[1]);
      LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
      lms.setConstant(constant);
      lms.setQuantileError(error);
      lms.addObserver(this);
      lms.run();
      lms.getResult();
    }
  }

  public void calculateRM(String input){
    if (input != null){
      RepeatedMedianEstimator rm =  new RepeatedMedianEstimator(getModel().getLines(), this);
      Double parameter = Double.parseDouble(input);
      rm.setBeta(parameter);
      rm.addObserver(this);
      rm.run();
      rm.getResult();
    }
  }


  public void calculateTS(String input){
    if (input != null){
      TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(),this);
      ts.addObserver(this);
      ts.run();
      ts.getResult();
    }
  }

  /***************************************************************************************************************************
   *                                          Hilfsmethoden
   ***************************************************************************************************************************/
  public void setup(){
    getView().logHeading("Duale Darstellung der Punkte als Geraden:");

    //Darstellung der Schnittpunkte in einer Tabelle
        List<String> heading = new LinkedList<>();
        List<List<String>> rows = new LinkedList<>();
        heading.add("Geraden");
        for (int j = 0; j < getModel().getLines().size()-2; j++) {
          LinkedList<String> rowEntry = new LinkedList<>();
          Line p1 = getModel().getLines().get(j);
          rowEntry.add("f(x) = " + p1.getM() + "x + " + p1.getB());

          if (j+1 < getModel().getLines().size()){
            Line p2 = getModel().getLines().get(j+1);
            rowEntry.add("f(x) = " + p2.getM() + "x + " + p2.getB());
          }

          if (j+2 < getModel().getLines().size()){
            Line p3 = getModel().getLines().get(j+2);
            rowEntry.add("f(x) = " + p3.getM() + "x + " + p3.getB());
          }
          rows.add(rowEntry);
        }
        getView().logHeading("Schnittpunkte der Dualen Geraden:");
        getView().createTable(heading, rows);

    getView().log("<hr>");
  }

  //  public Point calcIntersection(Line a, Line b) {
  //    Line p1 = a;
  //    Line p2 = b;
  //
  //    Double x = (p1.getB() - p2.getB()) / (p2.getM() - p1.getM());
  //    Double y = ((p1.getM() * p2.getB()) - (p2.getM() * p1.getB())) / (p1.getM() - p2.getM());
  //
  //    return new Point(x, y);
  //  }

  public void calcArrangementNodes() {
    try {
      Thread thread = new Thread(() -> {
        /*Double xMinimum = Double.MAX_VALUE;
        Double xMaximum = Double.MIN_VALUE;
        Double yMinimum = Double.MAX_VALUE;
        Double yMaximum = Double.MIN_VALUE;

        for (int i = 0; i < getLines().size(); i++) {
          for (int j = i; j < getLines().size(); j++) {
            if (i != j) {
              Point intersection = calcIntersection(getLines().get(j), getLines().get(i));

              if (intersection.getX() != Double.POSITIVE_INFINITY && intersection.getX() != Double.NEGATIVE_INFINITY &&
                  intersection.getY() != Double.POSITIVE_INFINITY && intersection.getY() != Double.NEGATIVE_INFINITY ){
                xMinimum = xMinimum > intersection.getX() ? intersection.getX() : xMinimum;
                xMaximum = xMaximum < intersection.getX() ? intersection.getX() : xMaximum;
                yMinimum = yMinimum > intersection.getY() ? intersection.getY() : yMinimum;
                yMaximum = yMaximum < intersection.getY() ? intersection.getY() : yMaximum;

                model.addNode(intersection);
              }
            }
          }
        }
        model.setxMinimum(xMinimum);
        model.setxMaximum(xMaximum);
        model.setyMaximum(yMaximum);
        model.setyMinimum(yMinimum);*/
        IntersectionCounter counter = new IntersectionCounter();
        counter.run(getLines(), new Interval(-99999,99999));
        counter.calculateIntersectionAbscissas(getModel());
        getModel().setXbounds();
        getModel().setYbounds();

      });
      thread.start();
      thread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  public LinkedList<Line> calcArrangementLines() {
    LinkedList<Line> lineCoordinates = new LinkedList<>();
    double x1 = -1000;
    double x2 = 1000;

    for (Line point : model.getLines()) {
      double y1 = (point.getM() * x1 + point.getB());
      double y2 = (point.getM() * x2 + point.getB());
      Line line =  new Line(x1, x2, y1, y2);
      line.setId(point.getId());
      lineCoordinates.add(line);
    }

    return lineCoordinates;
  }

  public void startImport(File file){
    DataImporter importer = new DataImporter(file, this);
    importer.addObserver(this);
    importer.run();
  }

  /***************************************************************************************************************************
   *                                          Getter und Setter Methoden
   ***************************************************************************************************************************/


  public Arrangement getModel() {
    return model;
  }

  public void setModel(Arrangement model) {
    this.model = model;
  }

  public MainFrame getView() {
    return view;
  }

  public void setView(MainFrame view) {
    this.view = view;
  }

  public LinkedList<Line> getLines() {
    return this.model.getLines();
  }

  public void setLines(LinkedList<Line> lines) {
    this.model.setLines(lines);
  }

}