package com.megatim.fdxconvert.controller;

import com.megatimfx.common.abstracts.AbstractEditDialogController;
import com.megatimfx.common.customdialogs.LoadinIndicatorDialogUtil;
import com.megatimfx.common.dialogs.NotificationDialog;
import com.megatimfx.common.dialogs.NotificationType;
import com.megatimfx.common.enums.ConfirmationType;
import com.megatimfx.common.enums.TypeOperation;
import com.megatim.fdxconvert.App;
import com.megatim.fdxconvert.enums.DataType;
import com.megatim.fdxconvert.forms.MetaAlphaNumeriqueFieldEditFormController;
import com.megatim.fdxconvert.forms.TacheEditFormController;
import com.megatim.fdxconvert.model.AlphaNumeriqueField;
import com.megatim.fdxconvert.pojo.Delimiteur;
import com.megatim.fdxconvert.model.MetaAlphaNumeriqueField;
import com.megatim.fdxconvert.model.Tache;
import com.megatim.fdxconvert.service.MetaAlphaNumeriqueFieldService;
import com.megatim.fdxconvert.service.TacheJobService;
import com.megatim.fdxconvert.service.TacheService;
import java.io.IOException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.event.ActionEvent;
import javafx.fxml.FXMLLoader;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;

/**
 *
 * @author MGT_DEV3
 */
public class TacheEditDialogController extends AbstractEditDialogController<Tache> {

    private TacheEditFormController tacheEditFormController;
    private MetaAlphaNumeriqueFieldEditDialogController metaAlphaNumeriqueFieldEditDialogController;
    private Map<String, AlphaNumeriqueField> newAlphaFields = new HashMap<>();

    @Override
    public void initialize(URL url, ResourceBundle rb) {
        tacheEditFormController = new TacheEditFormController();
        metaAlphaNumeriqueFieldEditDialogController = new MetaAlphaNumeriqueFieldEditDialogController();

        metaAlphaNumeriqueFieldEditDialogController.setAlphaNumeriqueFieldEditFormController(new MetaAlphaNumeriqueFieldEditFormController());

        super.initialize(url, rb);
    }

    @Override
    public String getTitle() {
        return "Editer une tâche";
    }

    @Override
    public Pane getContentFormPane() throws IOException {
        FXMLLoader loader = new FXMLLoader(TacheEditFormController.class.getResource("TacheEditForm.fxml"));
        loader.setControllerFactory(param -> tacheEditFormController);
        Parent parent = loader.load();
        return (Pane) parent;
    }

    @Override
    public Object getContentFormController() {
        return tacheEditFormController;
    }

    @Override
    protected void afterBindCurrentObjectWithFormField(Tache bindObject, Object formController, TypeOperation typeOperation) {

        TacheEditFormController controller = (TacheEditFormController) formController;

        controller.getMetaAlphaNumeriqueFieldAbstractTable().setController(metaAlphaNumeriqueFieldEditDialogController);
    }

    @Override
    protected void afterBindFormFieldWithCurrentObject(Tache bindObject, Object formController, TypeOperation typeOperation) {

        if (formController instanceof TacheEditFormController) {

            TacheEditFormController controller = (TacheEditFormController) formController;

            controller.getMetaAlphaNumeriqueFieldAbstractTable().setController(metaAlphaNumeriqueFieldEditDialogController);

            //metaAlphaNumeriqueFieldEditDialogController.setSelectedMetaAlphaNumeriqueFields(controller.getMetaAlphaNumeriqueFieldAbstractTable().getElementObservableList());
            switch (typeOperation) {

                case ADD:

                    controller.getTypeFichierAbstractSelectItem().selectedElementProperty().addListener((observable, oldValue, newValue) -> {

                        if (newValue != null) {
                            metaAlphaNumeriqueFieldEditDialogController.getAlphaNumeriqueFieldEditFormController().setTypeFichier(newValue);
                            controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(false);
                        }

                    });

                    controller.getSaisieAlphaNumeriqueFieldChecBox().selectedProperty().addListener(listener -> {

                        if (controller.getSaisieAlphaNumeriqueFieldChecBox().isSelected()) {
                            controller.getMetaAlphaNumeriqueFieldAbstractTable().setDisable(false);
                        }
                    });
                    break;

                case UPDATE:

                    metaAlphaNumeriqueFieldEditDialogController.getAlphaNumeriqueFieldEditFormController()
                            .setTypeFichier(controller.getTypeFichierAbstractSelectItem().getSelectedElement());

                    controller.getSaisieAlphaNumeriqueFieldChecBox().setSelected(true);
                    controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(true);

                    break;

                default:

                    controller.getSaisieAlphaNumeriqueFieldChecBox().setSelected(true);
                    controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(true);

                    break;
            }
        }
    }

    @Override
    protected void beforeBindFormFieldWithCurrentObject(Tache bindObject, Object formController, TypeOperation typeOperation) {
        if (formController instanceof TacheEditFormController) {

            TacheEditFormController controller = (TacheEditFormController) formController;
            if (typeOperation.equals(TypeOperation.VIEW) || typeOperation.equals(TypeOperation.UPDATE)) {

                if (bindObject.getColDeliminter() != null) {
                    bindObject.setDelimiteurColonne(App.DELIMITEURS_COLONNE.get(bindObject.getColDeliminter()));
                }

                if (bindObject.getRowDeliminter() != null) {
                    bindObject.setDelimiteurLigne(App.DELIMITEURS_LIGNE.get(bindObject.getRowDeliminter()));
                }

            }

            if (typeOperation.equals(TypeOperation.ADD) || typeOperation.equals(TypeOperation.UPDATE)) {

                controller.getDelimiteurColonne().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNull()
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.XLS))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.XLSX))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON))
                );

                controller.getDelimiteurLigne().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNull()
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.XLS))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.XLSX))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON))
                );

                controller.getStrictValidationCheckbox().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNull()
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNotEqualTo(DataType.XLS))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNotEqualTo(DataType.XLSX))
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON))
                );

                controller.getWithHeader().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isNull()
                        .or(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON))
                );
                
                controller.getUseExistingConversionModelCheckBox().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON));
                controller.getWithHeader().disableProperty().bind(controller.getDataTypeComboBox().getSelectionModel().selectedItemProperty().isEqualTo(DataType.JSON));

                if (controller.getDataTypeComboBox().getSelectionModel().getSelectedItem() != null
                        && controller.getDataTypeComboBox().getSelectionModel().getSelectedItem().equals(DataType.JSON)) {
                    controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(true);
                }

            }

            switch (typeOperation) {

                case ADD:
                    controller.getMetaAlphaNumeriqueFieldAbstractTable().setDisable(true);
                    break;

                case UPDATE:
                    controller.getMetaAlphaNumeriqueFieldAbstractTable().setDisable(false);
                    break;

                default:

            }
        }
    }

    @Override
    public boolean beforeSave(ActionEvent event) {

        getCurrentObject().getMetaAlphaNumeriqueFields().forEach(m -> {

            if (m.getTache() == null) {
                m.setTache(getCurrentObject());
            }
            newAlphaFields.put(m.getAlphaNumeriqueField().getCodeColonne(), m.getAlphaNumeriqueField());
        });

        boolean proceed = super.beforeSave(event);
        StringBuilder message = new StringBuilder();

        if (proceed) {

            TacheService tacheService = TacheService.getInstance();

            //Tester l'unicité du type de fichier par tâche
            Tache tache = tacheService.findByTypefichier(getCurrentObject().getTypeFichier());

            proceed = (getTypeOperation().equals(TypeOperation.ADD) && tache == null)
                    || (getTypeOperation().equals(TypeOperation.UPDATE) && (tache == null || tache.getLibelle().equals(getCurrentObject().getLibelle())));

            if (proceed) {

                //Tester l'unicité du type du répertoire source
                tache = tacheService.findByRepertoireSource(getCurrentObject().getRepertoireSource());

                proceed = (getTypeOperation().equals(TypeOperation.ADD) && tache == null)
                        || (getTypeOperation().equals(TypeOperation.UPDATE) && (tache == null || tache.getLibelle().equals(getCurrentObject().getLibelle())));

                if (proceed) {

                    //Tester l'unicité du type du répertoire d'erreur
                    tache = tacheService.findByRepertoireErreur(getCurrentObject().getRepertoireErreur());

                    proceed = (getTypeOperation().equals(TypeOperation.ADD) && tache == null)
                            || (getTypeOperation().equals(TypeOperation.UPDATE) && (tache == null || tache.getLibelle().equals(getCurrentObject().getLibelle())));

                    if (proceed) {

                        //Verifier que les repertoires source et d'erreur sont différents
                        proceed = !getCurrentObject().getRepertoireErreur().equals(getCurrentObject().getRepertoireSource());

                        if (!proceed) {

                            message.append("Les répertoires source et d'erreur ne doivent pas être identiques\n");
                        } else {
                            //Tester l'unicité du type du répertoire de destination
                            tache = tacheService.findByRepertoireDestination(getCurrentObject().getRepertoireDestination());

                            proceed = (getTypeOperation().equals(TypeOperation.ADD) && tache == null)
                                    || (getTypeOperation().equals(TypeOperation.UPDATE) && (tache == null || tache.getLibelle().equals(getCurrentObject().getLibelle())));

                            if (proceed) {

                                //Verifier que les repertoires source et destination sont différents
                                boolean proceed1 = !getCurrentObject().getRepertoireDestination().equals(getCurrentObject().getRepertoireSource());

                                //Verifier que les repertoires destination et d'erreur sont différents
                                boolean proceed2 = !getCurrentObject().getRepertoireDestination().equals(getCurrentObject().getRepertoireErreur());
                                proceed = proceed1 && proceed2;

                                if (!proceed1) {
                                    message.append("Les répertoires source et destination ne doivent pas être identiques\n");
                                }
                                if (!proceed2) {
                                    message.append("Les répertoires d'erreur et destination ne doivent pas être identiques");
                                }

                            } else { //Alert problème de répertoire de destination
                                message.append("Le répertoire de destination est déjà utilisé\n");
                            }
                        }
                    } else {//Alert problème de répertoire d'erreur
                        message.append("Le répertoire d'erreur est déjà utilisé\n");
                    }

                } else { //Alert problème de répertoire source
                    message.append("Le repertoire source est déjà utilisé\n");
                }

            } else { //Alert problème de type fichier

                message.append("Le type de fichier est déjà utilisé\n");
            }

        }

        Delimiteur delimiteurColonne = getCurrentObject().getDelimiteurColonne();
        Delimiteur delimiteurLigne = getCurrentObject().getDelimiteurLigne();

        if (delimiteurColonne != null) {
            getCurrentObject().setColDeliminter(delimiteurColonne.getCode());
        }

        if (delimiteurLigne != null) {
            getCurrentObject().setRowDeliminter(delimiteurLigne.getCode());
        }

        boolean proceedIntervalleTache = getCurrentObject().isWithoutInterval() ? getCurrentObject().isWithoutInterval() : getCurrentObject().getIntervalleTache() > 0;
        proceed = proceed && proceedIntervalleTache;

        if (!proceedIntervalleTache) {
            message.append("L'intervalle de répétition doit être supérieure à 0");
        }

        if (!proceed && !message.toString().isEmpty()) {
            LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
            Node source = (Node) event.getSource();
            Stage parentStage = (Stage) source.getScene().getWindow();
            NotificationDialog notificationDialog = new NotificationDialog(
                    message.toString(),
                    NotificationType.ERROR,
                    parentStage
            );
            notificationDialog.showNotification();
        }
        return proceed;
    }

    @Override
    public void afterSave(ActionEvent event) {

        try {
            Tache currentObject = getCurrentObject();
            Set<MetaAlphaNumeriqueField> newSetMeta = currentObject.getMetaAlphaNumeriqueFields();

            newSetMeta.forEach(m -> {
                if (!newAlphaFields.containsKey(m.getAlphaNumeriqueField().getCodeColonne())) {
                    try {
                        MetaAlphaNumeriqueFieldService.getInstance().delete(m);
                    } catch (Exception ex) {
                        Logger.getLogger(TacheEditDialogController.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            });

        } catch (Exception ex) {
            Logger.getLogger(TacheEditDialogController.class.getName()).log(Level.SEVERE, null, ex);
        }

        Thread th = new Thread(() -> {
            TacheJobService.getInstance().restartJob();
        });

        th.setDaemon(true);
        th.start();

    }

    @Override
    public String getConfirmationMessage() {
        return "La tâche a été enregistrée avec succès";
    }

    @Override
    protected ConfirmationType getConfirmationType() {
        return ConfirmationType.CONFIRMATION;
    }
}