package Presenter;

import Model.LineModel;
import Model.Interval;
import Model.Line;
import Presenter.Algorithms.IntersectionCounter;
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
import Presenter.Algorithms.RepeatedMedianEstimator;
import Presenter.Algorithms.TheilSenEstimator;
import Presenter.Evaluation.EvaluateAlgorithms;
import Presenter.Generator.DatasetGenerator;
import Presenter.ImportExport.DataExporter;
import Presenter.ImportExport.DataImporter;
import View.MainFrame;

import javax.swing.*;
import java.io.File;
import java.util.LinkedList;
import java.util.List;
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 LineModel model;
  private MainFrame view;
  private EvaluateAlgorithms eval;

  /* Threads */
  private Thread tsThread;
  private Thread rmThread;
  private Thread lmsThread;
  private Thread importThread;
  private Thread exportThread;
  private Thread generatorThread;
  private Thread evalThread;

  public Presenter(LineModel model, MainFrame view) {
    this.model = model;
    this.view = view;
  }


  @Override
  public void update(Observable o, Object arg) {
    String[] result = ((String[]) arg);

    if (result[0] == "eval-dataset-generated"){
      SwingUtilities.invokeLater(() -> getView().addEvalDataset(eval.getData()));
    }

    if (result[0] == "eval"){
      SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
    }

    if (result[0] == "lines-res"){
      SwingUtilities.invokeLater(() -> getView().drawLineResult(result));
    }

    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(() -> {
            calculateIntersections();
          });
          t.start();
          try {
            t.join();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        } else {
          SwingUtilities.invokeLater(() -> {
          getView().showImportProgress(progress);
        });
        }
    }
    if (result[0] == "export"){
      SwingUtilities.invokeLater(() -> {
        getView().logSuccess("Export Erfolgreich");
        getView().log(result[1]+"<hr>");
      });
    }

    if (result[0] == "generator"){
      SwingUtilities.invokeLater(() -> {
        getView().logSuccess("Generierung Erfolgreich");
        getView().log(result[1]);
        getView().log(result[2]);
        getView().log(result[3] + "<hr>");
      });
    }
  }

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

  /***************************************************************************************************************************
   *                                          Ausführung der Algorithmen
   ***************************************************************************************************************************/
  public void calculateLMS(String[] input) {
    if (input[0] != null && input[1] != null){
      if (lmsThread == null || !lmsThread.isAlive()){
        lmsThread = new Thread(() -> {
          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();
        });
        lmsThread.start();
        try {
          lmsThread.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public void calculateRM(String input){
    if (input != null){
      if (rmThread == null || !rmThread.isAlive()){
        rmThread = new Thread(() -> {
          RepeatedMedianEstimator rm =  new RepeatedMedianEstimator(getModel().getLines(), this);
          Double parameter = Double.parseDouble(input);
          rm.setBeta(parameter);
          rm.addObserver(this);
          rm.run();
          rm.getResult();
        });
        rmThread.start();
        try {
          rmThread.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public void calculateTS(String input){
    if (input != null){
      if (tsThread == null || !tsThread.isAlive()){
        tsThread = new Thread(() ->{
          TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(),this);
          ts.addObserver(this);
          ts.run();
          ts.getResult();
        });
        tsThread.start();
        try {
          tsThread.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  /***************************************************************************************************************************
   *                                          Hilfsmethoden
   ***************************************************************************************************************************/
  public void setup(){
    //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 void calculateIntersections() {
    try {
      Thread thread = new Thread(() -> {
        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 void startImport(File file){
    if (importThread == null || !importThread.isAlive()){
      importThread = new Thread(()->{
        DataImporter importer = new DataImporter(file, this);
        importer.addObserver(this);
        importer.run();
      });
      importThread.start();
      try {
        importThread.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public void startExport(File file){
    if (exportThread == null || !exportThread.isAlive()){
      exportThread = new Thread(()->{
        DataExporter exporter = new DataExporter(getModel(), file);
        exporter.addObserver(this);
        exporter.export();
      });
      exportThread.start();
      try {
        exportThread.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public void generateDataset(){
    if (generatorThread == null || !generatorThread.isAlive()){
      generatorThread = new Thread(() -> {
        DatasetGenerator generator = new DatasetGenerator();
        generator.addObserver(this);
        getModel().setLines(generator.generateDataset());
        calculateIntersections();
        getView().enableFunctionality();
      });
      generatorThread.start();
      try {
        generatorThread.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public void startEvaluation(){

    if (evalThread == null || !evalThread.isAlive()){
      evalThread = new Thread(() ->{
        try {
          eval = new EvaluateAlgorithms();
          eval.addObserver(this);
          eval.run();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      });
      evalThread.start();
    }
  }
  /***************************************************************************************************************************
   *                                          Getter und Setter Methoden
   ***************************************************************************************************************************/


  public LineModel getModel() {
    return model;
  }

  public void setModel(LineModel 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);
  }

}