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

package de.uniluebeck.mi.projmi6.controller;

/**
 * Created by Johannes on 12.11.15.
 */

import de.uniluebeck.mi.projmi6.db.DBHandler;
import de.uniluebeck.mi.projmi6.model.Patient;
import de.uniluebeck.mi.projmi6.model.Station;
import de.uniluebeck.mi.projmi6.model.StationsUebersichtsItem;
import de.uniluebeck.mi.projmi6.view.SelectKeyComboBoxListener;
import javafx.beans.binding.Bindings;
import javafx.beans.binding.ObjectBinding;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.collections.transformation.FilteredList;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.image.Image;
import javafx.stage.Modality;
import javafx.stage.Stage;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;

/**
 * Controller class.
 */
public class PatientTablesController {

    @FXML
    Button btnStatRefresh;
    private MainController mainController;
    @FXML
    private Label lblTablePatientEmpty;
    @FXML
    private Label lblTableStationEmpty;
    @FXML
    private Button btnPatCreate;
    @FXML
    private Button btnPatEdit;
    @FXML
    private TableView<Patient> tblPatientOverview;
    @FXML
    private TableColumn<Patient, String> colPatPatId;
    @FXML
    private TableColumn<Patient, String> colPatGeburtsname;
    @FXML
    private TableColumn<Patient, String> colPatNachname;
    @FXML
    private TableColumn<Patient, String> colPatVorname;
    @FXML
    private TableColumn<Patient, LocalDate> colPatGebDatum;
    @FXML
    private TableColumn<Patient, String> colPatStrasse;
    @FXML
    private TableColumn<Patient, String> colPatPlz;
    @FXML
    private TableColumn<Patient, String> colPatOrt;
    @FXML
    private TableColumn<Patient, String> colPatCave;
    @FXML
    private ToggleButton btnEntlassenePatientenZeigen;
    @FXML
    private ComboBox<Station> cmbStationenFilter;
    @FXML
    private TableView<StationsUebersichtsItem> tblStationOverview;
    @FXML
    private TableColumn<StationsUebersichtsItem, Integer> colStatPatId;
    @FXML
    private TableColumn<StationsUebersichtsItem, String> colStatFullName;
    @FXML
    private TableColumn<StationsUebersichtsItem, LocalDate> colStatGebDatum;
    @FXML
    private TableColumn<StationsUebersichtsItem, Integer> colStatAlter;
    @FXML
    private TableColumn<StationsUebersichtsItem, LocalDate> colStatAufnahmedatum;
    @FXML
    private TableColumn<StationsUebersichtsItem, LocalDate> colStatEntlassungsdatum;
    @FXML
    private Tab stationOverviewTab;
    @FXML
    private Tab patientOverviewTab;

    @FXML
    private TabPane patientOverviewTabPane;
    private ObservableList<StationsUebersichtsItem> stationsUebersicht = FXCollections.observableArrayList();
    private FilteredList<StationsUebersichtsItem> stationsUebersichtsItemFilteredList = new FilteredList<StationsUebersichtsItem>(stationsUebersicht,
            item -> item.getStationEntlassung() == null || !item.getStationEntlassung().isAfter(LocalDate.now()));
    private Task loadStationsHistorieTask = null;
    private Task loadPatientTask = null;
    @FXML
    private Button btnPatRefresh;
    private ObjectBinding<Patient> patientObjectBinding = null;

    public PatientTablesController(MainController mainController) {
        this.mainController = mainController;
    }

    public TabPane getPatientOverviewTabPane() {
        return patientOverviewTabPane;
    }

    @FXML
    public void initialize() {
        btnPatEdit.disableProperty().bind(tblPatientOverview.getSelectionModel().selectedItemProperty().isNull());
        tblPatientOverview.setRowFactory(tableView -> {
            TableRow<Patient> tableRow = new TableRow<>();
            tableRow.setOnMouseClicked(event -> {
                if (event.getClickCount() == 2 && (!tableRow.isEmpty())) {
                    Patient patient = tableRow.getItem();
                    showEditWindow(patient);
                }
            });
            return tableRow;
        });
        lblTablePatientEmpty.setText("Liste ist leer.");
        tblStationOverview.disableProperty().bind(cmbStationenFilter.valueProperty().isNull());

        cmbStationenFilter.itemsProperty().bind(mainController.getStammdaten().stationenProperty());
        new SelectKeyComboBoxListener(cmbStationenFilter);


        patientObjectBinding = Bindings.<Patient>createObjectBinding(() -> {
                    if (patientOverviewTabPane.getSelectionModel().getSelectedItem().equals(patientOverviewTab)) {
                        return tblPatientOverview.getSelectionModel().getSelectedItem();
                    } else if (tblStationOverview.getSelectionModel().getSelectedItem() == null) {
                        return null;
                    } else {
                        int selectedPatId = tblStationOverview.getSelectionModel().getSelectedItem().getPatId();
                        Patient selectedPatient = tblPatientOverview.getItems().stream().filter(p -> p.getPatID() == selectedPatId).findFirst().orElse(null);
                        return selectedPatient;
                    }
                }, tblPatientOverview.getSelectionModel().selectedItemProperty(),
                tblStationOverview.getSelectionModel().selectedItemProperty(),
                patientOverviewTabPane.getSelectionModel().selectedItemProperty());


        initColumnsPatient();
        initColumnsStation();

        updatePatientsFromDb();
    }

    private void initColumnsPatient() {
        colPatPatId.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().patIDProperty().asString());
        colPatGeburtsname.setCellValueFactory(new PropertyValueFactory<>("geburtsname"));
        colPatNachname.setCellValueFactory(new PropertyValueFactory<>("nachname"));
        colPatVorname.setCellValueFactory(new PropertyValueFactory<>("vorname"));
        colPatGebDatum.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().geburtsdatumProperty());
        colPatStrasse.setCellValueFactory(cellDataFeatures -> {
            Patient patient = cellDataFeatures.getValue();
            return Bindings.concat(patient.strasseProperty(), " ", patient.hausnummerProperty());
        });
        colPatPlz.setCellValueFactory(new PropertyValueFactory<>("plz"));
        colPatOrt.setCellValueFactory(new PropertyValueFactory<>("ort"));
        colPatCave.setCellValueFactory(new PropertyValueFactory<>("cave"));
    }

    private void initColumnsStation() {
        colStatPatId.setCellValueFactory(new PropertyValueFactory<StationsUebersichtsItem, Integer>("patId"));
        colStatFullName.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().patNameProperty());
        colStatGebDatum.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().patBirthdateProperty());
        colStatAlter.setCellValueFactory(new PropertyValueFactory<StationsUebersichtsItem, Integer>("patAge"));
        colStatAufnahmedatum.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().stationAufnahmeProperty());
        colStatEntlassungsdatum.setCellValueFactory(cellDataFeatures -> cellDataFeatures.getValue().stationEntlassungProperty());


        cmbStationenFilter.valueProperty().addListener((observableValue, oldValue, newValue) -> {
            updateStationsHistorieFromDb();
        });
        tblStationOverview.itemsProperty().bind(Bindings.createObjectBinding(() -> {
            if (btnEntlassenePatientenZeigen.isSelected()) {
                return stationsUebersicht;
            } else {
                return stationsUebersichtsItemFilteredList;
            }
        }, btnEntlassenePatientenZeigen.selectedProperty()));
    }

    @FXML
    private void clickedCreatePatient() {
        showEditWindow(null);
    }

    @FXML
    private void clickedEditPatient() {
        showEditWindow(tblPatientOverview.getSelectionModel().getSelectedItem());
    }

    private void showEditWindow(Patient patient) {
        FXMLLoader fxmlLoader = new FXMLLoader();
        fxmlLoader.setLocation(getClass().getClassLoader().getResource("patient_edit.fxml"));
        PatientEditorController patientEditorController = new PatientEditorController(mainController);
        fxmlLoader.setControllerFactory(clazz -> patientEditorController);

        Parent root = null;
        try {
            root = fxmlLoader.load();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        Stage stage = new Stage();

        stage.setTitle(patient == null ? "Neuen Patienten erstellen" : "Patient bearbeiten");
        stage.setScene(new Scene(root, 600, 600));

        stage.getIcons().add(new Image("icon.png"));

        stage.initModality(Modality.WINDOW_MODAL);
        stage.initOwner(btnPatEdit.getScene().getWindow());
        patientEditorController.setPatient(patient);
        stage.show();
    }

    public void updatePatientsFromDb() {
        if (this.loadPatientTask != null && this.loadPatientTask.isRunning()) {
            System.out.println("Patienten werden bereits geladen.");
            return;
        }

        btnPatRefresh.setDisable(true);

        tblPatientOverview.setItems(null);

        mainController.increaseParallelTaskCount();

        lblTablePatientEmpty.setText("Liste wird geladen...");

        Task<List<Patient>> loadPatientsTask = new Task<List<Patient>>() {

            @Override
            protected List<Patient> call() throws Exception {
                return FXCollections.<Patient>observableArrayList(DBHandler.getAllPatients());
            }

            @Override
            protected void succeeded() {
                super.succeeded();
                btnPatRefresh.setDisable(false);
                lblTablePatientEmpty.setText("Liste ist leer.");
                tblPatientOverview.setItems(FXCollections.observableArrayList(this.getValue()));
                mainController.decreaseParallelTaskCount();
            }

            @Override
            protected void failed() {
                super.failed();
                btnPatRefresh.setDisable(false);
                lblTablePatientEmpty.setText("Laden fehlgeschlagen!");
                mainController.decreaseParallelTaskCount();
                tblPatientOverview.setItems(null);
                if (getException() != null) {
                    getException().printStackTrace();
                }
            }
        };
        this.loadPatientTask = loadPatientsTask;

        Thread thread = new Thread(loadPatientsTask);
        thread.setDaemon(true);
        thread.start();
    }

    @FXML
    private void clickedRefreshStation() {
        updateStationsHistorieFromDb();
    }

    public void updateStationsHistorieFromDb() {
        if (this.loadStationsHistorieTask != null) {
            loadStationsHistorieTask.cancel();
        }
        lblTableStationEmpty.setText("Liste wird geladen...");

        btnStatRefresh.setDisable(true);

        stationsUebersicht.clear();

        mainController.increaseParallelTaskCount();


        Task<List<StationsUebersichtsItem>> loadStatHist = new Task<List<StationsUebersichtsItem>>() {

            @Override
            protected List<StationsUebersichtsItem> call() throws Exception {
                return FXCollections.<StationsUebersichtsItem>observableArrayList(
                        DBHandler.getStationsUebersichtsItems(cmbStationenFilter.getValue().getStation()));
            }

            @Override
            protected void succeeded() {
                super.succeeded();
                if (!isCancelled()) {
                    lblTableStationEmpty.setText("Liste ist leer.");
                    stationsUebersicht.setAll(this.getValue());
                    btnStatRefresh.setDisable(false);
                    mainController.decreaseParallelTaskCount();
                }
            }

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

            @Override
            protected void failed() {
                super.failed();
                if (!isCancelled()) {
                    lblTableStationEmpty.setText("Laden fehlgeschlagen!");
                    getException().printStackTrace();
                    btnStatRefresh.setDisable(false);
                    mainController.decreaseParallelTaskCount();
                }
            }
        };
        this.loadStationsHistorieTask = loadStatHist;

        Thread thread = new Thread(loadStationsHistorieTask);
        thread.setDaemon(true);
        thread.start();
    }

    @FXML
    private void clickedRefreshPatient() {
        updatePatientsFromDb();
    }

    public ObjectBinding<Patient> selectedPatientProperty() {
        return patientObjectBinding;
    }

    public Patient getSelectedPatient() {
        return selectedPatientProperty().get();
    }



}