package de.wwwu.awolf.presenter;

import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.communication.AlgorithmData;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.EvaluationData;
import de.wwwu.awolf.presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.RepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.TheilSenEstimator;
import de.wwwu.awolf.presenter.data.DataProvider;
import de.wwwu.awolf.presenter.evaluation.EvaluateAlgorithms;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.view.MainFrame;

import javax.swing.*;
import java.io.File;
import java.util.List;


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


    public Presenter(LineModel model, MainFrame view) {
        super(model, view);
    }

    @Override
    protected void visualizeTsAlgorithm(Data data) {
        AlgorithmData algorithmData = (AlgorithmData) data;
        SwingUtilities.invokeLater(() -> getView().visualizeTS(algorithmData.getLineData()));
        Logging.logInfo("Theil-Sen Estimator");
        Logging.logInfo(algorithmData.getLineData().toString());
    }

    @Override
    protected void visualizeRmAlgorithm(Data data) {
        AlgorithmData algorithmData = (AlgorithmData) data;
        SwingUtilities.invokeLater(() -> getView().visualizeRM(algorithmData.getLineData()));
        Logging.logInfo("Repeated Median Estimator");
        Logging.logInfo(algorithmData.getLineData().toString());
    }

    @Override
    protected void visualizeLmsAlgorithm(Data data) {
        AlgorithmData algorithmData = (AlgorithmData) data;
        SwingUtilities.invokeLater(() -> getView().visualizeLMS(algorithmData.getLineData()));
        Logging.logInfo("Least Median of Squares");
        Logging.logInfo(algorithmData.getLineData().toString());
    }

    @Override
    protected void evaluatedDatas(Data data) {
        EvaluationData evaluationData = (EvaluationData) data;
        SwingUtilities.invokeLater(() -> getView().appendEvalResults(evaluationData.getMultipleColumnResult()));
    }


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

    /***************************************************************************************************************************
     *                                          Ausführung der Algorithmen
     ***************************************************************************************************************************/

    /**
     * Die Berechnung durch des Algorithmus zum LMS-Schätzer wird gestartet.
     *
     * @param input Parameter für den Algorithmus
     */
    public void calculateLMS(String[] input) {
        if (input[0] != null && input[1] != null) {
            //Parameter für den Algortihmus
            Double constant = Double.parseDouble(input[0]);
            double error = Double.parseDouble(input[1]);
            LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
            //setzen der Parameter
            lms.setConstant(constant);
            lms.setQuantileError(error);
            //Presenter soll die Klasse überwachen
            getExecutor().submit(lms);
        }

    }

    /**
     * Die Berechnung durch des Algorithmus zum RM-Schätzer wird gestartet.
     *
     * @param input Parameter für den Algorithmus
     */
    public void calculateRM(String input) {
        if (input != null) {
            RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this);
            Double parameter = Double.parseDouble(input);
            rm.setBeta(parameter);
            //Presenter soll die Klasse überwachen
            getExecutor().submit(rm);

        }
    }

    /**
     * Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet.
     *
     * @param input Parameter für den Algorithmus
     */
    public void calculateTS(String input) {
        if (input != null) {
            TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this);
            //Presenter soll die Klasse überwachen
            getExecutor().submit(ts);
        }
    }

    /***************************************************************************************************************************
     *                                          Hilfsmethoden
     ***************************************************************************************************************************/

    /**
     * Startet den Import des Datensatzes.
     *
     * @param file importierender Datensatz
     */
    public void startImport(File file) {
        List<Line> data = getDataProvider().getData(file);
        if (data != null) {
            //Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
            getModel().setLines(data);
            computeIntersections();
        }

    }

    /**
     * Startet den Export des akteullen Datensatzes (nur der Geraden)
     *
     * @param file Datei in der die Informationen gespeichert werden sollen
     */
    public void startExport(File file) {
        getDataProvider().exportData(file, getModel().getLines());
    }

    /**
     * Startet den Export des akteullen Datensatzes im Rahmen der Evaluation (nur der Geraden)
     *
     * @param file Datei in der die Informationen gespeichert werden sollen
     */
    public void startDatasetExportEvaluation(File file) {
        getDataProvider().exportData(file, getEval().getData());
    }

    /**
     * Startet das generieren der Datensätze der Größe <code>n</code>
     *
     * @param n    Größe des Datensatzes
     * @param type Art der Datensatzes
     */
    public void generateDataset(int n, DataProvider.DataType type) {
        List<Line> data = getDataProvider().getData(type, n);
        getModel().setLines(data);
        computeIntersections();
        getView().enableFunctionality();
    }

    /**
     * Startet die Evaluation zu einen gegegbenen Typ mit den Informationen zu den Datensatz.
     * Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
     * auf einem gegebenen Datensatz.
     *
     * @param typ        Typ der Evaluation
     * @param n          Größe des Datensatzes
     * @param alg        code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
     * @param datasetTyp Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
     */
    public void startEvaluation(int typ, int n, int alg, DataProvider.DataType datasetTyp) {
        getExecutor().submit(new EvaluateAlgorithms(typ, n, alg, datasetTyp, this));
    }

    /**
     * Startet die Evaluation zu einen gegegbenen Datensatz, der importiert wird.
     * Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
     * auf einem gegebenen Datensatz.
     *
     * @param typ  Typ der Evaluation
     * @param alg  code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
     * @param file Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
     */
    public void startEvaluation(int typ, int alg, File file) {
        getExecutor().submit(new EvaluateAlgorithms(typ, alg, file, this));
    }
}