projmi/src/main/java/de/uniluebeck/mi/projmi6/controller/MainController.java

package de.uniluebeck.mi.projmi6.controller;

import de.uniluebeck.mi.projmi6.db.DBHandler;
import de.uniluebeck.mi.projmi6.model.*;
import javafx.beans.binding.Bindings;
import javafx.beans.property.ReadOnlyObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.value.ChangeListener;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.scene.control.*;
import javafx.util.Callback;

import javax.swing.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ThreadFactory;

public class MainController {

    private FallController fallController;
    private DiagnoseController diagnoseController;
    private PatientTablesController patientTablesController;
    private SettingsController settingsController;
    private StationsHistorieController stationsHistorieController;
    private UntersuchungenController untersuchungenController;





    private int parallelTaskCount = 0;

    @FXML
    private ChoiceBox<Mitarbeiter> cmbUserChoose;

    @FXML
    private ProgressIndicator progressIndicator;

    @FXML
    private Button btnFallCreate;

    @FXML
    private SplitPane fallOverview;

    @FXML
    private ListView<Fall> lvFall;

    @FXML
    private TabPane tabPaneFall;

    @FXML
    private Tab tabFallOverview, tabFallUntersuchungen, tabFallDiagnose, tabFallStationsHistorie ;


    private Stammdaten stammdaten = new Stammdaten();


    private Callback<Class<?>, Object> controllerFactory = clazz -> {
        if(clazz.equals(MainController.class)) {
            return this;
        }else if(clazz.equals(FallController.class)){
            return fallController;
        }else if(clazz.equals(DiagnoseController.class)){
            return diagnoseController;
        }else if(clazz.equals(PatientTablesController.class)){
            return patientTablesController;
        }else if(clazz.equals(SettingsController.class)){
            return  settingsController;
        } else if(clazz.equals(UntersuchungenController.class)) {
            return untersuchungenController;
        }else if(clazz.equals(StationsHistorieController.class)){
            return stationsHistorieController;
        }else {
            System.err.println("Keine Controller-Klasse des Typs "+clazz+" gefunden!!!");
            return null;
        }

    };

    public MainController(){
        fallController = new FallController(this);
        diagnoseController = new DiagnoseController(this);
        patientTablesController = new PatientTablesController(this);
        settingsController = new SettingsController(this);
        untersuchungenController = new UntersuchungenController(this);
        stationsHistorieController = new StationsHistorieController(this);
    }


    public Stammdaten getStammdaten(){
        return  stammdaten;
    }

    public Callback<Class<?>, Object> getControllerFactory(){
        return controllerFactory;
    }




    public FallController getFallController(){
        return fallController;
    }

    public DiagnoseController getDiagnoseController(){
        return diagnoseController;
    }

    public PatientTablesController getPatientTablesController(){
        return  patientTablesController;
    }

    public SettingsController getSettingsController(){
        return settingsController;
    }

    public UntersuchungenController getUntersuchungenController(){
        return  untersuchungenController;
    }

    public void increaseParallelTaskCount(){
        parallelTaskCount++;
        if(parallelTaskCount>0 && progressIndicator!=null){
            progressIndicator.setVisible(true);
        }
    }

    public void decreaseParallelTaskCount(){
        parallelTaskCount--;
        if(parallelTaskCount<=0 && progressIndicator!=null){
            parallelTaskCount = 0;
            progressIndicator.setVisible(false);
        }
    }


    @FXML
    private Label lvFallPlaceholder;



    private Task<List<Fall>> loadFallTask = null;



    private ChangeListener<Patient> onPatientChanged = (observableValue,oldValue,newValue)-> {
        lvFall.setItems(null); //clear list

        if(newValue==null){ // If no patient is selected
            lvFallPlaceholder.setText("Kein Patient ausgew\u00e4hlt!");
            return;
        }

        if(loadFallTask!=null && loadFallTask.isRunning()){
            loadFallTask.cancel();
        }


        loadFallTask = new Task<List<Fall>>() {
            @Override
            protected List<Fall> call() throws Exception {
                return DBHandler.getFaelleByPatID(newValue.getPatID());

            }

            @Override
            protected void succeeded() {
                super.succeeded();
                if(isCancelled()){
                    System.out.println("Task wurde gecancelt");
                    return;
                }
                lvFallPlaceholder.setText("Keine F\u00e4lle vorhanden!");
                lvFall.setItems(FXCollections.observableArrayList(getValue()));
                decreaseParallelTaskCount();
            }

            @Override
            protected void cancelled() {
                super.cancelled();
                decreaseParallelTaskCount();
            }

            @Override
            protected void failed() {
                super.failed();
                lvFallPlaceholder.setText("Laden fehlgeschlagen!");
                lvFall.setItems(null);
                decreaseParallelTaskCount();
            }
        };

        lvFallPlaceholder.setText("Liste wird geladen...");
        increaseParallelTaskCount();
        Thread thread = new Thread(loadFallTask);
        thread.setDaemon(true);
        thread.start();
    };

    @FXML
    private void initialize(){
        //Init user data.
        cmbUserChoose.itemsProperty().bind(this.getStammdaten().mitarbeiterProperty());
        cmbUserChoose.getSelectionModel().select(0); // TODO: Bessere Loesung finden.


        //Disable the right side if no case is selected.
        fallOverview.disableProperty().bind(patientTablesController.selectedPatientProperty().isNull());

        //Load the cases async if patient changes
        patientTablesController.selectedPatientProperty().addListener(onPatientChanged);


        lvFall.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);

        fallController.fallPropertyProperty().bind(lvFall.getSelectionModel().selectedItemProperty());




        lvFall.getSelectionModel().selectedItemProperty().addListener(onCaseChanged);
    }



    private Task<Void> loadCaseData = null;


    private ChangeListener<Fall> onCaseChanged = (observable, oldValue, newValue) -> {

        if(loadCaseData!=null && loadCaseData.isRunning()){
            loadCaseData.cancel();
        }

        tabPaneFall.setDisable(false);
        tabFallDiagnose.setDisable(true);
        tabFallStationsHistorie.setDisable(true);
        tabFallUntersuchungen.setDisable(true);

        if(newValue==null) {
            tabPaneFall.setDisable(true);
            System.out.println("TODO: Clear tables cuz fall = null!");
            //fallController.c
            return;
        }

        if(newValue==null){ // If no patient is selected
            //lvFallPlaceholder.setText("Kein Patient ausgew\u00e4hlt!");
            return;
        }




        loadCaseData = new Task<Void>() {
            List<Untersuchung> untersuchungList;
            List<Diagnose> diagnoseList;
            List<StationsHistorie> stationsHistorieList;
            @Override
            protected Void call() throws Exception {
                untersuchungList = DBHandler.getUntersuchungByFall(newValue);
                diagnoseList = DBHandler.getDiagnosenByFall(newValue);
                stationsHistorieList = DBHandler.getStationsHistorieByFall(newValue);
                return null;
            }

            @Override
            protected void succeeded() {
                super.succeeded();
                if(isCancelled()){
                    System.out.println("Task wurde gecancelt");
                    return;
                }
                untersuchungenController.setUntersuchungen(FXCollections.observableArrayList(untersuchungList));
                diagnoseController.setDiagnosen(FXCollections.observableArrayList(diagnoseList));
                stationsHistorieController.setStationsHistorie(FXCollections.observableArrayList(stationsHistorieList));


                tabPaneFall.setDisable(false);
                tabFallDiagnose.setDisable(false);
                tabFallStationsHistorie.setDisable(false);
                tabFallUntersuchungen.setDisable(false);

                decreaseParallelTaskCount();
            }

            @Override
            protected void cancelled() {
                super.cancelled();
                decreaseParallelTaskCount();
            }

            @Override
            protected void failed() {
                super.failed();
                //lvFallPlaceholder.setText("Laden fehlgeschlagen!");
                getException().printStackTrace();
                decreaseParallelTaskCount();
            }
        };
        Thread thread = new Thread(loadCaseData);
        thread.setDaemon(true);
        thread.start();
        increaseParallelTaskCount();
    };


    @FXML
    private void clickedCreateFall(){
        tabFallDiagnose.setDisable(true);
        tabFallUntersuchungen.setDisable(true);
        tabFallStationsHistorie.setDisable(true);
        tabPaneFall.getSelectionModel().select(tabFallOverview);
        patientTablesController.getPatientOverviewTabPane().setDisable(true);


        fallController.createNewFall();
    }

    public void fallCreationComplete(){
        tabFallDiagnose.setDisable(false);
        tabFallUntersuchungen.setDisable(false);
        tabFallStationsHistorie.setDisable(false);
        patientTablesController.getPatientOverviewTabPane().setDisable(false);
    }

    public Mitarbeiter getCurrentMitarbeiter(){
        return cmbUserChoose.getValue();
    }

    public ReadOnlyObjectProperty<Mitarbeiter> currentMitarbeiterProperty(){
        return cmbUserChoose.valueProperty();
    }

}