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.scene.paint.Color;
import javafx.scene.text.Text;
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 LogController logController;

    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 if (clazz.equals(LogController.class)){
            return logController;
        } 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);
        logController = new LogController(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;


    public void refreshCasesFromDb(Patient patient) {
        lvFall.setItems(null); //clear list

        if (patient == 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(patient.getPatID());

            }

            @Override
            protected void succeeded() {
                super.succeeded();
                if (isCancelled()) {
                    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()
                .and(fallController.stateProperty().isNotEqualTo(FallController.State.CREATE)));

        //Load the cases async if patient changes
        patientTablesController.selectedPatientProperty().addListener((observableValue, oldValue, newValue) -> {
            refreshCasesFromDb(newValue);
        });


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

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


        lvFall.getSelectionModel().selectedItemProperty().addListener((observableValue, oldValue, newValue) -> {
            refreshCaseData(newValue);
        });

        lvFall.setCellFactory(lv -> {
            return new ListCell<Fall>() {
                @Override
                protected void updateItem(Fall item, boolean empty) {
                    super.updateItem(item, empty);
                    if (item == null || empty) {
                        this.setText(null);
                        this.setGraphic(null);
                        return;
                    }
                    setText(item.toString());
                    if (item.getStorniert()) {
                        Text text = new Text("<storniert> ");
                        text.setFill(Color.RED);
                        setGraphic(text);
                        setTextFill(Color.GRAY); //TODO
                    } else {
                        setTextFill(Color.BLACK);
                        setGraphic(null);
                    }
                }
            };
        });

    }


    private Task<Void> loadCaseData = null;




    private void refreshCaseData(Fall fall){
        if (loadCaseData != null && loadCaseData.isRunning()) {
            loadCaseData.cancel();
        }

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

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

        if (fall == 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(fall);
                diagnoseList = DBHandler.getDiagnosenByFall(fall);
                stationsHistorieList = DBHandler.getStationsHistorieByFall(fall);
                return null;
            }

            @Override
            protected void succeeded() {
                super.succeeded();
                if (isCancelled()) {
                    System.out.println("Task wurde gecancelt");
                    return;
                }
                ObservableList<Diagnose> diagnoses = FXCollections.observableArrayList(diagnoseList);

                untersuchungenController.setUntersuchungen(FXCollections.observableArrayList(untersuchungList));
                diagnoseController.setDiagnosen(diagnoses);
                stationsHistorieController.setStationsHistorie(FXCollections.observableArrayList(stationsHistorieList));
                fallController.setDiagnosen(diagnoses);

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


    public void refreshCaseData(){
        refreshCaseData(lvFall.getSelectionModel().getSelectedItem());
    }

    @FXML
    private void clickedCreateFall() {
//        tabFallDiagnose.setDisable(true);
//        tabFallUntersuchungen.setDisable(true);
//        tabFallStationsHistorie.setDisable(true);
//        tabPaneFall.getSelectionModel().select(tabFallOverview);
//        patientTablesController.getPatientOverviewTabPane().setDisable(true);
//
//
        fallController.createNewFall();
        lockForEdit(TabName.OVERVIEW);
    }


    public Fall getFall(){
        return lvFall.getSelectionModel().getSelectedItem();
    }

    public ReadOnlyObjectProperty<Fall> fallProperty(){
        return  lvFall.getSelectionModel().selectedItemProperty();
    }


public enum TabName {
    OVERVIEW, DIAGNOSE, UNTERSUCHUNG, STATIONSHISTORIE;
}

    public void lockForEdit(TabName exclude) {
        tabFallDiagnose.setDisable(true);
        tabFallUntersuchungen.setDisable(true);
        tabFallStationsHistorie.setDisable(true);
        tabFallOverview.setDisable(true);
        lvFall.setDisable(true);
        btnFallCreate.setDisable(true);

        patientTablesController.getPatientOverviewTabPane().setDisable(true);

        switch (exclude) {
            case OVERVIEW:
                tabFallOverview.setDisable(false);
                break;
            case DIAGNOSE:
                tabFallDiagnose.setDisable(false);
                break;
            case UNTERSUCHUNG:
                tabFallUntersuchungen.setDisable(false);
                break;
            case STATIONSHISTORIE:
                tabFallStationsHistorie.setDisable(false);
            default:
                break;
        }


    }

    public void unlockFromEdit() {
        tabFallDiagnose.setDisable(false);
        tabFallUntersuchungen.setDisable(false);
        tabFallStationsHistorie.setDisable(false);

        tabFallOverview.setDisable(false);
        patientTablesController.getPatientOverviewTabPane().setDisable(false);
        lvFall.setDisable(false);
        btnFallCreate.setDisable(false);

    }

    public Mitarbeiter getCurrentMitarbeiter() {
        return cmbUserChoose==null?null:cmbUserChoose.getValue();
    }

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

}