package presenter;

import model.Line;
import model.LineModel;
import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import presenter.algorithms.advanced.RepeatedMedianEstimator;
import presenter.algorithms.advanced.TheilSenEstimator;
import presenter.evaluation.EvaluateAlgorithms;
import presenter.evaluation.PictureProcessor;
import presenter.generator.DatasetGenerator;
import presenter.io.DataExporter;
import presenter.io.DataImporter;
import presenter.io.EvalResultLatexExport;
import view.MainFrame;

import javax.swing.table.DefaultTableModel;
import java.io.File;
import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


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


    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
            lms.addObserver(this);
            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
            rm.addObserver(this);

            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
            ts.addObserver(this);

            getExecutor().execute(ts);
        }
    }

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

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

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

        getExecutor().execute(new Runnable() {
            @Override
            public void run() {
                LinkedList<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
        pictureProcessor.addObserver(this);

        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);
        //Presenter soll die Klasse überwachen
        exporter.addObserver(this);

        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);
        //Presenter soll die Klasse überwachen
        exporter.addObserver(this);

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

    /**
     * Startet den Export der Ergebnisse der Evaluation in Form einer LaTeX Datei
     *
     * @param model TableModel das die Berechnenten Ergebnisse enthält
     * @param file  Datei in die exportiert werden soll
     */
    public void startResultExport(DefaultTableModel model, File file) {
        getExecutor().execute(() -> {
            EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
            exporter.writeFile();
        });
    }

    /**
     * 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();
        generator.addObserver(this);
        getExecutor().execute(() -> {
            switch (type) {
                case 0:
                    getModel().setLines(generator.generateDataCloud(n));
                    break;
                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));
        getEval().addObserver(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);
            getEval().addObserver(this);

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