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.ExportData;
import de.wwwu.awolf.model.communication.ImportData;
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.evaluation.EvaluateAlgorithms;
import de.wwwu.awolf.presenter.evaluation.PictureProcessor;
import de.wwwu.awolf.presenter.generator.DatasetGenerator;
import de.wwwu.awolf.presenter.io.DataExporter;
import de.wwwu.awolf.presenter.io.DataImporter;
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 handleExport(Data data) {
        ExportData exportData = (ExportData) data;
        Logging.logInfo(exportData.getMessage());
        Logging.logInfo("Export der Daten als CSV");
        Logging.logInfo("Export war Erfolgreich");
    }

    @Override
    protected void handleImport(Data data) {
        ImportData importData = (ImportData) data;
        double max = importData.getNumberOfLines();
        double current = importData.getCurrent();
        Integer progress = (int) (100 * (current / max));
        //100% erreicht
        Logging.logInfo("Import war erfolgreich!");
        SwingUtilities.invokeLater(() -> getView().showImportProgress(progress));
    }

    @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());
        Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
    }

    @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());
        Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
    }

    @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());
        Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
    }

    @Override
    protected void visualizeMultipleData(Data data) {
        //Result:
        //0:
        SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
    }

    @Override
    protected void visualizeResults(Data data) {
        SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
    }

    @Override
    protected void evaluatedTypes(Data data) {
        SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), true));
    }

    @Override
    protected void evaluatedDatas(Data data) {
        SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
    }

    @Override
    protected void evaluatedData(Data data) {
        SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
    }


    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().execute(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().execute(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().execute(ts);
        }
    }

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

    /**
     * Startet den Import des Datensatzes.
     *
     * @param file importierender Datensatz
     */
    public void startImport(File file) {

        DataImporter importer = new DataImporter(file, this);
        //Presenter soll die Klasse überwachen

        getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                List<Line> importedLines = importer.run();
                if (importedLines != null) {
                    //Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
                    getModel().setLines(importedLines);
                    computeIntersections();
                }
            }
        });
    }

    /**
     * Startet den Import eines Bildes.
     *
     * @param file importierendes Bild
     */
    public void startPictureDataImport(File file) {
        PictureProcessor pictureProcessor = new PictureProcessor(this, file);
        //Presenter soll die Klasse überwachen

        getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                pictureProcessor.run();
                //Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
                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) {
        DataExporter exporter = new DataExporter(getModel().getLines(), file, this);
        //Presenter soll die Klasse überwachen

        getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                exporter.export();
            }
        });
    }

    /**
     * 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) {
        DataExporter exporter = new DataExporter(getEval().getData(), file, this);
        //Presenter soll die Klasse überwachen

        getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                exporter.export();
            }
        });
    }

    /**
     * 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, int type) {
        DatasetGenerator generator = new DatasetGenerator(this);
        getExecutor().execute(() -> {
            switch (type) {
                case 1:
                    getModel().setLines(generator.generateDataLines(n));
                    break;
                case 2:
                    getModel().setLines(generator.generateCircle(n));
                    break;
                default:
                    getModel().setLines(generator.generateDataCloud(n));
                    break;
            }
            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, String datasettyp) {
        setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp, this));

        getExecutor().submit(() -> {
            getEval().run();
        });
    }

    /**
     * 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) {

        EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
        if (evaluateAlgorithms.getData().size() > 0) {
            setEval(evaluateAlgorithms);

        }
        getExecutor().submit(() -> {
            getEval().run();
        }).isDone();
    }
}