package Presenter;

import Model.Arrangement;
import Model.Line;
import Model.Point;
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
import Presenter.Algorithms.RepeatedMedianEstimator;
import Presenter.Import.DataImporter;
import View.MainFrame;
import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;


/**
 * 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;

  private LeastMedianOfSquaresEstimator lms;

  private Double max;
  private Double min;

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

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

    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();
        } else {
          SwingUtilities.invokeLater(() -> {
          getView().showImportProgress(progress);
        });
        }

    }



  }


  public void visualizeDualLines() {
    view.createArrangement();
  }
  /***************************************************************************************************************************
   *                                          Ausführung der Algorithmen
   ***************************************************************************************************************************/
  public void calculateLMS(String[] input) {
    Double constant = Double.parseDouble(input[0]);
    Double error = Double.parseDouble(input[1]);
    lms = new LeastMedianOfSquaresEstimator(model.getLines(), model.getNodes(), this);
    lms.setConstant(constant);
    lms.setQuantileError(error);
    lms.addObserver(this);
    lms.run();
  }

  public void calculateRM(String input){
    RepeatedMedianEstimator rm =  new RepeatedMedianEstimator(this.getLines(), this);
    rm.setBeta(Double.parseDouble(input));
    rm.addObserver(this);
    rm.run();
  }

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

    for (int j = 0; j < getModel().getLines().size(); j++) {
      Line p = getModel().getLines().get(j);
      p.setId(j+"");
      getView().log("f(x) = " + p.getM() + "x + " + p.getB());
    }
    calcArrangementNodes();

    //Darstellung der Schnittpunkte in einer Tabelle
    //    List<String> heading = new LinkedList<>();
    //    List<List<String>> rows = new LinkedList<>();
    //    heading.add("X - Koordinate");
    //    heading.add("Y - Koordinate");
    //    for (Point p : getModel().getNodes()) {
    //      LinkedList<String> rowEntry = new LinkedList<>();
    //      rowEntry.add(p.getX().toString());
    //      rowEntry.add(p.getY().toString());
    //      rows.add(rowEntry);
    //    }
    //    getView().logHeading("Schnittpunkte der Dualen Geraden:");
    //    getView().createTable(heading, rows);
  }

  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(() -> {
        for (int i = 0; i < getLines().size(); i++) {
          for (int j = i; j < getLines().size(); j++) {
            if (i != j) {
              model.addNode(calcIntersection(getLines().get(j), getLines().get(i)));
            }
          }
        }
      });
      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, getModel());
    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);
  }

  public Double getMax() {
    return max;
  }

  public void setMax(Double max) {
    this.max = max;
  }

  public Double getMin() {
    return min;
  }

  public void setMin(Double min) {
    this.min = min;
  }
}