package control;

import imp.*;
import graph.*;
import algorithmen.*;

import javafx.fxml.*;
import javafx.scene.control.*;
import javafx.event.*;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.*;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.text.*;
import javafx.geometry.Pos;
import javafx.scene.image.Image;
import javafx.stage.*;          // Dateiöffnen / Speichern-Dialog
import java.io.File;  
import java.net.URI;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.file.*;
import java.util.Collections;
import java.util.stream.Stream;
import java.util.Iterator;



import java.util.ArrayList;
import java.util.regex.Pattern;

import javafx.collections.ObservableList;

/**
 * Die Klasse SimulationTabMitController stellt einen Tab inclusive ihres Controllers
 * zur Simulation eines Algorithmus dar. Der Algorithmus kann ausgewählt und schrittweise 
 * durchgeführt werden.
 *
 * @author Thomas Schaller
 * @version v6.7 (9.12.2020)
 */
public class SimulationTabMitController extends TabMitController {

    @FXML
    private ComboBox<String> cbAlgorithmen;

    @FXML
    private Slider sSpeed;

    @FXML
    private Button bStep;

    @FXML
    private Button bStart;

    @FXML
    private Button bBreak;

    @FXML
    private Button bReset;

    private GraphAlgo aktAlgo = null;
    private ArrayList<String> algoNamen;
    private Hilfefenster hilfe;

    public SimulationTabMitController(Graph graph, GraphOptions options) {
        this.graph = graph;
        this.options = options;
        this.setOnClosed((ev)->afterClosing());
    }

    public void initialize() {
        this.algoNamen = new ArrayList<String>();
        try     {
            File verzeichnis = new File("algorithmen");
            if(verzeichnis != null) {
                String[] entries = verzeichnis.list();
                for (String name : entries) {
                    if (name.startsWith("GraphAlgo_") && name.endsWith(".class")){
                        Class c = Class.forName("algorithmen."+name.split(Pattern.quote("."))[0]);
                        GraphAlgo a = ((GraphAlgo)(c).getDeclaredConstructor().newInstance());       
                        int i = 0;
                        while(i < cbAlgorithmen.getItems().size() && cbAlgorithmen.getItems().get(i).compareTo(a.getBezeichnung())<0)
                            i++;
                        //System.out.println("Algorithmus: "+a.getBezeichnung()+" geladen.");     
                        cbAlgorithmen.getItems().add(i, a.getBezeichnung());

                        algoNamen.add(i, "algorithmen."+name.split(Pattern.quote("."))[0]);
                    }
                } // end of for
            }
            verzeichnis = new File( "eigeneAlgorithmen" );
            if(verzeichnis != null) {
                String[] entries = verzeichnis.list();
                for (String name : entries) {
                    if (name.startsWith("GraphAlgo_") && name.endsWith(".class")){
                        Class c = Class.forName("eigeneAlgorithmen."+name.split(Pattern.quote("."))[0]);
                        GraphAlgo a = ((GraphAlgo)(c).getDeclaredConstructor().newInstance());       
                        int i = 0;
                        while(i < cbAlgorithmen.getItems().size() && cbAlgorithmen.getItems().get(i).compareTo(a.getBezeichnung())<0)
                            i++;
                        //System.out.println("Algorithmus: "+a.getBezeichnung()+" geladen.");     
                        cbAlgorithmen.getItems().add(i, a.getBezeichnung());

                        algoNamen.add(i, "eigeneAlgorithmen."+name.split(Pattern.quote("."))[0]);
                    }
                } // end of for
            }
        } catch(Exception e)   
        {
            System.out.println("Exception " + e);
        } 

        viewer.setGraph(graph,options);
        this.hilfe = null;
        this.aktAlgo = null;
        super.initialize();

        sSpeed.valueProperty().addListener(e -> { if (aktAlgo != null) aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));});
        bStart.managedProperty().bind(bStart.visibleProperty());
        bBreak.managedProperty().bind(bBreak.visibleProperty());
        bBreak.setVisible(false);
    }

    private void afterClosing() {
        if (hilfe != null) hilfe.close();
    }

    private void hilfefensterErzeugen() {
        try {  // try-catch ist notwendig, um Fehler durch fehlende Dateien abzufangen.
            if(hilfe != null) hilfe.close();

            hilfe = new Hilfefenster();
            FXMLLoader loader = new FXMLLoader(getClass().getResource("/view/hilfefenster.fxml"));
            loader.setController(hilfe);
            Scene scene = new Scene((VBox) loader.load());
            Image icon = new Image("/view/icon.png");
            hilfe.getIcons().add(icon);
            hilfe.setTitle("Hilfefenster");
            hilfe.setScene(scene);
            hilfe.setX(0);
            hilfe.setY(0);
        } 
        catch(Exception e)    {
            System.out.println(e);
        }   
    }

    public void showHilfe(boolean b) {
        if(b) {
            hilfefensterErzeugen();
            hilfe.show();
            if(aktAlgo != null && aktAlgo.isAlive()) {
                aktAlgo.setGUIElemente(viewer,hilfe); 
                hilfe.append("Unvollständiger Ablauf");
            }
        }
        else {
            if (hilfe != null) hilfe.close();
            hilfe = null;
        }
    }

    public void setGraph(Graph graph, GraphOptions options) {
        super.setGraph(graph,options);
        mReset(null);
    }

    @FXML
    void mReset(ActionEvent event) {
        if(aktAlgo != null && aktAlgo.isAlive()) aktAlgo.stop();  
        graph.initialisiereAlleKnoten();
        graph.initialisiereAlleKanten();
        update();
        //gp.setInfoText(gp.getGraph().toString());
        bStep.setDisable(false);
        bStart.setDisable(false);
        bStart.setVisible(true);
        bBreak.setVisible(false);
        if (hilfe != null) hilfe.loescheAlles();
        this.aktAlgo = null;
    }

    @FXML 
    void mStep(ActionEvent event) {

        if (aktAlgo == null ) {
            if(cbAlgorithmen.getSelectionModel().getSelectedIndex() >= 0) {
                try{
                  ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
                  MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
                  Class c = classLoader.loadClass(algoNamen.get(cbAlgorithmen.getSelectionModel().getSelectedIndex()));

                    aktAlgo = ((GraphAlgo)(c).getDeclaredConstructor().newInstance()); 
                    aktAlgo.setStartKnoten(viewer.getSelectedKnoten());
                    aktAlgo.setGUIElemente(viewer, hilfe);
                    aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
                } catch( Exception e) {
                    System.out.println(e);
                }
                aktAlgo.start();
            }
        } else {
            if(aktAlgo.isAlive()) {
                aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
                aktAlgo.setWaitforclick(false);
                //gp.setInfoText(aktAlgo.getInfo());

            } else {
                //gp.setInfoText("Algorithmus ist beendet. "+aktAlgo.getInfo());
                bStep.setDisable(true);
                bStart.setDisable(true);
                bBreak.setDisable(true);
            } // end of if-else
        } // end of if-else
        try{
            Thread.sleep(100);
        } catch(Exception e) {}

        if (!aktAlgo.isAlive()) {
            //gp.setInfoText("Algorithmus ist beendet"+aktAlgo.getInfo());
            bStep.setDisable(true);
            bStart.setDisable(true);
            bBreak.setDisable(true);
        }
    }

    @FXML
    void mStart(ActionEvent event) {

        if (aktAlgo == null ) {
            if(cbAlgorithmen.getSelectionModel().getSelectedIndex() >= 0) {
                try{
                    ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
                  MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
                  Class c = classLoader.loadClass(algoNamen.get(cbAlgorithmen.getSelectionModel().getSelectedIndex()));

                    aktAlgo = ((GraphAlgo)(c).getDeclaredConstructor().newInstance()); 
                    
                    aktAlgo.setStartKnoten(viewer.getSelectedKnoten());
                    aktAlgo.setGUIElemente(viewer,hilfe);
                    aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));

                } catch( Exception e) {
                    System.out.println(e);
                }

                aktAlgo.setStepping(false);
                aktAlgo.start();
            }
        } else {
            if(aktAlgo.isAlive()) {
                aktAlgo.setSpeed(910-(int) (sSpeed.getValue()));
                aktAlgo.setStepping(false);
                aktAlgo.setWaitforclick(false);
                //gp.setInfoText(aktAlgo.getInfo());

            } else {
                //gp.setInfoText("Algorithmus ist beendet. "+aktAlgo.getInfo());

            } // end of if-else
        } // end of if-else

        // gp.setInfoText(aktAlgo.getInfo());
        bStep.setDisable(true);
        bStart.setVisible(false);
        bBreak.setVisible(true);
        bBreak.setDisable(false);

    }

    public void mBreak(ActionEvent event) {
        if(aktAlgo != null && aktAlgo.isAlive()) {
            aktAlgo.setStepping(true);
            bStart.setVisible(true);
            bBreak.setVisible(false);
            bStep.setDisable(false);
        }
    }
}