package gui;

import data.*;
import javafx.application.HostServices;
import javafx.beans.binding.StringBinding;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.scene.control.*;
import javafx.scene.layout.AnchorPane;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.controlsfx.control.CheckComboBox;

import javafx.scene.image.ImageView;
import util.Tasks;

import java.io.File;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Pattern;

import static gui.GUIController.showAlert;

@SuppressWarnings("Duplicates")
public class OneWordAnalysisTab {
    public final static Logger logger = LogManager.getLogger(OneWordAnalysisTab.class);

    @FXML
    private AnchorPane oneWordAnalysisTabPane;

    @FXML
    public TextArea selectedFiltersTextArea;

    @FXML
    public Label solarFilters;

    @FXML
    public Label calculateForL;

    @FXML
    public Label alsoVisualizeL;

    @FXML
    public Label displayTaxonomyL;

    @FXML
    public Label writeMsdAtTheEndL;

    @FXML
    public Label notePunctuationsL;

    @FXML
    public Label dataLimitL;

    @FXML
    public Label msdL;

    @FXML
    public Label taxonomyL;

    @FXML
    public Label minimalOccurrencesL;

    @FXML
    public Label minimalTaxonomyL;

    @FXML
    public Label minimalRelFreL;

    @FXML
    public Label taxonomySetOperationL;

    @FXML
    public ImageView calculateForI;

    @FXML
    public ImageView alsoVisualizeI;

    @FXML
    public ImageView displayTaxonomyI;

    @FXML
    public ImageView writeMsdAtTheEndI;

    @FXML
    public ImageView notePunctuationsI;

    @FXML
    public ImageView msdI;

    @FXML
    public ImageView taxonomyI;

    @FXML
    public ImageView minimalOccurrencesI;

    @FXML
    public ImageView minimalTaxonomyI;

    @FXML
    public ImageView minimalRelFreI;

    @FXML
    public ImageView taxonomySetOperationI;

    @FXML
    private TextField msdTF;
    private ArrayList<Pattern> msd;
    private ArrayList<String> msdStrings;

    @FXML
    private CheckComboBox<String> alsoVisualizeCCB;
    private ArrayList<String> alsoVisualize;

    @FXML
    private CheckComboBox<String> taxonomyCCB;
    private ArrayList<Taxonomy> taxonomy;

    @FXML
    private CheckBox displayTaxonomyChB;
    private boolean displayTaxonomy;

    @FXML
    private CheckBox writeMsdAtTheEndChB;
    private boolean writeMsdAtTheEnd;

    @FXML
    private CheckBox notePunctuationsChB;
    private boolean notePunctuations;

    @FXML
    private ComboBox<String> calculateForCB;
    private CalculateFor calculateFor;

    @FXML
    private TextField minimalOccurrencesTF;
    private Integer minimalOccurrences;

    @FXML
    private TextField minimalTaxonomyTF;
    private Integer minimalTaxonomy;

    @FXML
    private TextField minimalRelFreTF;
    private Integer minimalRelFre;

    @FXML
    private ComboBox<String> taxonomySetOperationCB;
    private String taxonomySetOperation;

    @FXML
    private Button computeNgramsB;

    @FXML
    private Button changeLanguageB;

    @FXML
    private Button cancel;

    @FXML
    public ProgressBar ngramProgressBar;
    @FXML
    public Label progressLabel;
//
//    @FXML
//    private Hyperlink helpH;

    private enum MODE {
        LETTER,
        WORD
    }

    private MODE currentMode;

    private Corpus corpus;
    private HashMap<String, HashSet<String>> solarFiltersMap;
    private Filter filter;
    private boolean useDb;
    private HostServices hostService;
    private ListChangeListener<String> taxonomyListener;
    private ListChangeListener<String> alsoVisualizeListener;
    private ChangeListener<String> calculateForListener;
    private ChangeListener<Boolean> msdListener;
    private ChangeListener<Boolean> minimalOccurrencesListener;
    private ChangeListener<Boolean> minimalTaxonomyListener;
    private ChangeListener<Boolean> minimalRelFreListener;

    private static final String [] N_GRAM_COMPUTE_FOR_WORDS_ARRAY = {"calculateFor.WORD", "calculateFor.LOWERCASE_WORD", "calculateFor.LEMMA", "calculateFor.MORPHOSYNTACTIC_SPECS"};
    private static final ArrayList<String> N_GRAM_COMPUTE_FOR_WORDS = new ArrayList<>(Arrays.asList(N_GRAM_COMPUTE_FOR_WORDS_ARRAY));
    private static final String [] N_GRAM_COMPUTE_FOR_WORDS_ORTH_ARRAY = {"calculateFor.WORD", "calculateFor.LOWERCASE_WORD"};
    private static final ArrayList<String> N_GRAM_COMPUTE_FOR_WORDS_ORTH = new ArrayList<>(Arrays.asList(N_GRAM_COMPUTE_FOR_WORDS_ORTH_ARRAY));
    private static final String [] N_GRAM_COMPUTE_FOR_WORDS_GOS_ARRAY = {"calculateFor.WORD", "calculateFor.LOWERCASE_WORD", "calculateFor.LEMMA", "calculateFor.MORPHOSYNTACTIC_SPECS", "calculateFor.NORMALIZED_WORD"};
    private static final ArrayList<String> N_GRAM_COMPUTE_FOR_WORDS_GOS = new ArrayList<>(Arrays.asList(N_GRAM_COMPUTE_FOR_WORDS_GOS_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_LEMMA_ARRAY = {"calculateFor.WORD_TYPE", "calculateFor.MORPHOSYNTACTIC_SPECS"};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_LEMMA = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_LEMMA_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_WORDS_ARRAY = {"calculateFor.LEMMA", "calculateFor.WORD_TYPE", "calculateFor.MORPHOSYNTACTIC_SPECS"};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_WORDS = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_WORDS_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_WORDS_GOS_ARRAY = {"calculateFor.LEMMA", "calculateFor.WORD_TYPE", "calculateFor.MORPHOSYNTACTIC_SPECS", "calculateFor.NORMALIZED_WORD"};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_WORDS_GOS = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_WORDS_GOS_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_NORMALIZED_WORDS_ARRAY = {"calculateFor.LEMMA", "calculateFor.WORD_TYPE", "calculateFor.MORPHOSYNTACTIC_SPECS"};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_NORMALIZED_WORDS = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_NORMALIZED_WORDS_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_MSD_ARRAY = {"calculateFor.WORD_TYPE"};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_MSD = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_MSD_ARRAY));
    private static final String [] ALSO_VISUALIZE_ITEMS_EMPTY_ARRAY = {};
    private static final ArrayList<String> ALSO_VISUALIZE_ITEMS_EMPTY = new ArrayList<>(Arrays.asList(ALSO_VISUALIZE_ITEMS_EMPTY_ARRAY));

    private static final String [] TAXONOMY_SET_OPERATION_ARRAY = {"taxonomySetOperation.UNION", "taxonomySetOperation.INTERSECTION"};
    private static final ArrayList<String> TAXONOMY_SET_OPERATION = new ArrayList<>(Arrays.asList(TAXONOMY_SET_OPERATION_ARRAY));

    // TODO: pass observables for taxonomy based on header scan
    // after header scan
    public void init() {
        // add CSS style
        oneWordAnalysisTabPane.getStylesheets().add("style.css");
        oneWordAnalysisTabPane.getStyleClass().add("root");

        manageTranslations();

        currentMode = MODE.WORD;
        toggleMode(currentMode);

        AtomicBoolean writeMsdAtTheEndEnableCalculateFor = new AtomicBoolean(false);

        if (calculateForListener != null){
            calculateForCB.valueProperty().removeListener(calculateForListener);
        }

        // calculateForCB
        calculateForListener = new ChangeListener<String>() {
            boolean ignoreCode = false;
            @Override
            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
               if (ignoreCode) {
                   return;
               }
               boolean languageChanged = newValue == null;
               ArrayList<Integer> checkedIndices = new ArrayList<>();
               checkedIndices.addAll(alsoVisualizeCCB.getCheckModel().getCheckedIndices());
               if (languageChanged) {
                   ignoreCode = true;
                   if (corpus.getCorpusType() == CorpusType.GOS) {
                       newValue = I18N.getTranslatedValue(oldValue, N_GRAM_COMPUTE_FOR_WORDS_GOS);
                       calculateForCB.getSelectionModel().select(newValue);
                   } else {
                       newValue = I18N.getTranslatedValue(oldValue, N_GRAM_COMPUTE_FOR_WORDS);
                       calculateForCB.getSelectionModel().select(newValue);
                   }

                   // override if orth mode, allow only word
                   if (corpus.isGosOrthMode()) {
                       newValue = I18N.getTranslatedValue(oldValue, N_GRAM_COMPUTE_FOR_WORDS_ORTH);
                       calculateForCB.getSelectionModel().select(newValue);
                   }
                   ignoreCode = false;
               }

               calculateFor = CalculateFor.factory(newValue);

                if (alsoVisualizeListener != null) {
                    alsoVisualizeCCB.getCheckModel().getCheckedItems().removeListener(alsoVisualizeListener);
                }

               alsoVisualizeCCB.getCheckModel().clearChecks();
               alsoVisualizeCCB.getItems().removeAll();
               if (newValue.equals(CalculateFor.LEMMA.toString())) {
                   alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_LEMMA));
               } else if (newValue.equals(CalculateFor.WORD.toString()) || newValue.equals(CalculateFor.LOWERCASE_WORD.toString())) {
                   if (corpus.getCorpusType() == CorpusType.GOS)
                       alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_WORDS_GOS));
                   else
                       alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_WORDS));
               } else if (newValue.equals(CalculateFor.NORMALIZED_WORD.toString())) {
                   alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_NORMALIZED_WORDS));
               } else if (newValue.equals(CalculateFor.MORPHOSYNTACTIC_SPECS.toString())) {
                   writeMsdAtTheEndEnableCalculateFor.set(true);
                   writeMsdAtTheEndChB.setDisable(false);
                   alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_MSD));
               } else {
                   alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_EMPTY));
               }

               if (!newValue.equals(CalculateFor.MORPHOSYNTACTIC_SPECS.toString())) {
                   writeMsdAtTheEnd = false;
                   writeMsdAtTheEndChB.setSelected(false);
                   writeMsdAtTheEndChB.setDisable(true);
                   writeMsdAtTheEndEnableCalculateFor.set(false);
               }


               alsoVisualizeListener = new ListChangeListener<String>() {
                   @Override
                   public void onChanged(Change<? extends String> c) {
                       alsoVisualize = new ArrayList<>();
                       ObservableList<String> checkedItems = alsoVisualizeCCB.getCheckModel().getCheckedItems();
                       alsoVisualize.addAll(checkedItems);
                       if (checkedItems.contains(CalculateFor.MORPHOSYNTACTIC_SPECS.toString()) || writeMsdAtTheEndEnableCalculateFor.get()) {
                           writeMsdAtTheEndChB.setDisable(false);
                       } else {
                           writeMsdAtTheEnd = false;
                           writeMsdAtTheEndChB.setSelected(false);
                           writeMsdAtTheEndChB.setDisable(true);
                       }
                       logger.info(String.format("Selected also visualize items: %s", StringUtils.join(checkedItems, ",")));
                   }
               };

               alsoVisualizeCCB.getCheckModel().getCheckedItems().addListener(alsoVisualizeListener);

               if (languageChanged) {
                   for (int i : checkedIndices) {
                       alsoVisualizeCCB.getCheckModel().check(i);
                   }
               }

               logger.info("calculateForCB:", calculateFor.toString());
            }
        };

        calculateForCB.valueProperty().addListener(calculateForListener);

        calculateForCB.getSelectionModel().select(0);

        taxonomySetOperationCB.setDisable(true);
        taxonomySetOperationCB.valueProperty().addListener((observable, oldValue, newValue) -> {
            if(newValue == null){
                newValue = I18N.getTranslatedValue(oldValue, TAXONOMY_SET_OPERATION);
                taxonomySetOperationCB.getSelectionModel().select(newValue);
            }
            taxonomySetOperation = newValue;
            logger.info("Taxonomy set operation:", taxonomySetOperation);
        });

        taxonomySetOperationCB.getSelectionModel().select(0);

        if (msdListener != null){
            msdTF.focusedProperty().removeListener(msdListener);
        }

        // msd
        msdListener = new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                if (!newValue) {
                    // focus lost
                    String value = msdTF.getText();
                    logger.info("msdTf: ", value);

                    if (!ValidationUtil.isEmpty(value)) {
                        ArrayList<String> msdTmp = new ArrayList<>(Arrays.asList(value.split(" ")));

                        int nOfRequiredMsdTokens = 1;
                        if (msdTmp.size() != nOfRequiredMsdTokens) {
                            String msg = String.format(I18N.get("message.WARNING_MISMATCHED_NGRAM_AND_TOKENS_VALUES"), nOfRequiredMsdTokens, msdTmp.size());
                            logAlert(msg);
                            showAlert(Alert.AlertType.ERROR, msg);
                        }
                        msd = new ArrayList<>();
                        msdStrings = new ArrayList<>();
                        for (String msdToken : msdTmp) {
                            msd.add(Pattern.compile(msdToken));
                            msdStrings.add(msdToken);
                        }
                        logger.info(String.format("msd accepted (%d)", msd.size()));

                    } else if (!ValidationUtil.isEmpty(newValue)) {
                        msd = new ArrayList<>();
                        msdStrings = new ArrayList<>();
                    }
                }
            }
        };

        msdTF.focusedProperty().addListener(msdListener);

        msdTF.setText("");
        msd = new ArrayList<>();

        if (alsoVisualizeListener != null){
            alsoVisualizeCCB.getCheckModel().getCheckedItems().removeListener(alsoVisualizeListener);
        }

        alsoVisualizeListener = new ListChangeListener<String>() {
            @Override
            public void onChanged(Change<? extends String> c) {
                alsoVisualize = new ArrayList<>();
                ObservableList<String> checkedItems = alsoVisualizeCCB.getCheckModel().getCheckedItems();
                alsoVisualize.addAll(checkedItems);
                if (checkedItems.contains(CalculateFor.MORPHOSYNTACTIC_SPECS.toString()) || writeMsdAtTheEndEnableCalculateFor.get()) {
                    writeMsdAtTheEndChB.setDisable(false);
                } else {
                    writeMsdAtTheEnd = false;
                    writeMsdAtTheEndChB.setSelected(false);
                    writeMsdAtTheEndChB.setDisable(true);
                }
                logger.info(String.format("Selected also visualize items: %s", StringUtils.join(checkedItems, ",")));
            }
        };
        alsoVisualizeCCB.getCheckModel().clearChecks();
        alsoVisualizeCCB.getItems().removeAll();
        if (corpus.getCorpusType() != CorpusType.GOS){
            alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_WORDS));
        } else {
            alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_WORDS_GOS));
        }

        alsoVisualizeCCB.getCheckModel().getCheckedItems().addListener(alsoVisualizeListener);

        // taxonomy
        if (Tax.getCorpusTypesWithTaxonomy().contains(corpus.getCorpusType()) && corpus.getObservableListTaxonomy().size() > 0) {
            taxonomyCCB.setDisable(false);
        } else {
            taxonomyCCB.setDisable(true);
        }

        if (taxonomyListener != null){
            taxonomyCCB.getCheckModel().getCheckedItems().removeListener(taxonomyListener);
        }

        taxonomyListener = new ListChangeListener<String>() {
            public boolean changing = true;

            @Override
            public void onChanged(Change<? extends String> c) {
                if (changing) {
                    ObservableList<String> checkedItems = taxonomyCCB.getCheckModel().getCheckedItems();
                    ArrayList<Taxonomy> checkedItemsTaxonomy = Taxonomy.modifyingTaxonomy(taxonomy, checkedItems, corpus);

                    taxonomy = new ArrayList<>();
                    taxonomy.addAll(checkedItemsTaxonomy);

                    taxonomyCCB.getItems().removeAll();
                    taxonomyCCB.getItems().setAll(corpus.getObservableListTaxonomy());

                    changing = false;
                    taxonomyCCB.getCheckModel().clearChecks();
                    for (Taxonomy t : checkedItemsTaxonomy) {
                        taxonomyCCB.getCheckModel().check(t.toLongNameString());
                    }
                    if (taxonomyCCB.getCheckModel().getCheckedItems().size() > 0) {
                        taxonomySetOperationCB.setDisable(false);
                    } else {
                        taxonomySetOperationCB.getSelectionModel().select(0);
                        taxonomySetOperationCB.setDisable(true);
                    }
                    changing = true;
                    logger.info(String.format("Selected taxonomy: %s", StringUtils.join(checkedItems, ",")));
                }
            }
        };

        taxonomyCCB.getCheckModel().clearChecks();

        taxonomyCCB.getItems().removeAll();
        taxonomyCCB.getItems().setAll(corpus.getObservableListTaxonomy());

        taxonomyCCB.getCheckModel().getCheckedItems().addListener(taxonomyListener);

        displayTaxonomy = false;
        displayTaxonomyChB.setSelected(false);
        // set
        if (Tax.getCorpusTypesWithTaxonomy().contains(corpus.getCorpusType()) && corpus.getObservableListTaxonomy().size() > 0) {
            displayTaxonomyChB.setDisable(false);
            displayTaxonomyChB.selectedProperty().addListener((observable, oldValue, newValue) -> {
                displayTaxonomy = newValue;
                if (displayTaxonomy) {
                    minimalTaxonomyTF.setDisable(false);
                } else {
                    minimalTaxonomyTF.setDisable(true);

                    minimalTaxonomyTF.setText("1");
                    minimalTaxonomy = 1;
                }
                logger.info("display taxonomy: ", displayTaxonomy);
            });
            displayTaxonomyChB.setTooltip(new Tooltip(I18N.get("message.TOOLTIP_readDisplayTaxonomyChB")));
        } else {
            displayTaxonomyChB.setDisable(true);
        }

        writeMsdAtTheEnd = false;
        writeMsdAtTheEndChB.setDisable(true);
        // set
        writeMsdAtTheEndChB.selectedProperty().addListener((observable, oldValue, newValue) -> {
            writeMsdAtTheEnd = newValue;
            logger.info("write msd at the end: ", writeMsdAtTheEnd);
        });

        notePunctuations = false;
        // set
        notePunctuationsChB.selectedProperty().addListener((observable, oldValue, newValue) -> {
            notePunctuations = newValue;
            logger.info("note punctuations: ", notePunctuations);
        });
        notePunctuationsChB.setSelected(false);
        notePunctuationsChB.setTooltip(new Tooltip(I18N.get("message.TOOLTIP_readNotePunctuationsChB")));
        notePunctuationsChB.setDisable(false);

        // set default values
        minimalOccurrencesTF.setText("1");
        minimalOccurrences = 1;

        minimalTaxonomyTF.setText("1");
        minimalTaxonomy = 1;

        minimalTaxonomyTF.setDisable(true);

        if (minimalOccurrencesListener != null){
            minimalOccurrencesTF.focusedProperty().removeListener(minimalOccurrencesListener);
        }

        // msd
        minimalOccurrencesListener = new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                if (!newValue) {
                    // focus lost
                    String value = minimalOccurrencesTF.getText();
                    if (!ValidationUtil.isEmpty(value)) {
                        if (!ValidationUtil.isNumber(value)) {
                            logAlert("minimalOccurrencesTF: " + I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                            GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                        } else {
                            minimalOccurrences = Integer.parseInt(value);
                        }
                    } else {
                        minimalOccurrencesTF.setText("1");
                        minimalOccurrences = 1;
                    }
                }
            }
        };
        minimalOccurrencesTF.focusedProperty().addListener(minimalOccurrencesListener);


        if (minimalTaxonomyListener != null){
            minimalTaxonomyTF.focusedProperty().removeListener(minimalTaxonomyListener);
        }

        minimalTaxonomyListener = new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                if (!newValue) {
                    // focus lost
                    String value = minimalTaxonomyTF.getText();
                    if (!ValidationUtil.isEmpty(value)) {
                        if (!ValidationUtil.isNumber(value)) {
                            logAlert("minimalTaxonomyTF: " + I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                            GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                        } else {
                            minimalTaxonomy = Integer.parseInt(value);
                        }
                    } else {
                        minimalTaxonomyTF.setText("1");
                        minimalTaxonomy = 1;
                    }
                }
            }
        };
        minimalTaxonomyTF.focusedProperty().addListener(minimalTaxonomyListener);

        // set default values
        minimalRelFreTF.setText("1");
        minimalRelFre = 1;

        if (minimalRelFreListener != null){
            minimalRelFreTF.focusedProperty().removeListener(minimalRelFreListener);
        }

        minimalRelFreListener = new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                if (!newValue) {
                    // focus lost
                    String value = minimalRelFreTF.getText();
                    if (!ValidationUtil.isEmpty(value)) {
                        if (!ValidationUtil.isNumber(value)) {
                            logAlert("minimalRelFreTF: " + I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                            GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_ONLY_NUMBERS_ALLOWED"));
                        } else {
                            minimalRelFre = Integer.parseInt(value);
                        }
                    } else {
                        minimalRelFreTF.setText("1");
                        minimalRelFre = 1;
                    }
                }
            }
        };
        minimalRelFreTF.focusedProperty().addListener(minimalRelFreListener);


        changeLanguageB.setOnAction(e -> {
            if (I18N.getLocale() == new Locale.Builder().setLanguage("sl").setRegion("SI").build()){
                I18N.setLocale(Locale.ENGLISH);
            } else {
                I18N.setLocale(new Locale.Builder().setLanguage("sl").setRegion("SI").build());
            }
            Messages.reload();
            Messages.updateChooseCorpusL();
            logger.info("change language");
        });

        computeNgramsB.setOnAction(e -> {
            compute();
            logger.info("compute button");
        });
//        helpH.setOnAction(e -> openHelpWebsite());

        cancel.setVisible(false);
    }

    private void addTooltipToImage(ImageView image, StringBinding stringBinding){
        Tooltip tooltip = new Tooltip();
        tooltip.textProperty().bind(stringBinding);
        Tooltip.install(image, tooltip);
    }

    private void manageTranslations(){
//        helpH.textProperty().bind(I18N.createStringBinding("hyperlink.help"));
        changeLanguageB.textProperty().bind(I18N.createStringBinding("button.language"));
        computeNgramsB.textProperty().bind(I18N.createStringBinding("button.computeNgrams"));
        cancel.textProperty().bind(I18N.createStringBinding("button.cancel"));

        calculateForL.textProperty().bind(I18N.createStringBinding("label.calculateFor"));
        alsoVisualizeL.textProperty().bind(I18N.createStringBinding("label.alsoVisualize"));
        displayTaxonomyL.textProperty().bind(I18N.createStringBinding("label.displayTaxonomy"));
        writeMsdAtTheEndL.textProperty().bind(I18N.createStringBinding("label.writeMsdAtTheEnd"));
        notePunctuationsL.textProperty().bind(I18N.createStringBinding("label.notePunctuations"));

        dataLimitL.textProperty().bind(I18N.createStringBinding("label.dataLimit"));
        msdL.textProperty().bind(I18N.createStringBinding("label.msd"));
        taxonomyL.textProperty().bind(I18N.createStringBinding("label.taxonomy"));
        minimalOccurrencesL.textProperty().bind(I18N.createStringBinding("label.minimalOccurrences"));
        minimalTaxonomyL.textProperty().bind(I18N.createStringBinding("label.minimalTaxonomy"));
        minimalRelFreL.textProperty().bind(I18N.createStringBinding("label.minimalRelFre"));
        solarFilters.textProperty().bind(I18N.createStringBinding("label.solarFilters"));
        taxonomySetOperationL.textProperty().bind(I18N.createStringBinding("label.taxonomySetOperation"));

        addTooltipToImage(calculateForI, I18N.createStringBinding("label.word.calculateForH"));
        addTooltipToImage(alsoVisualizeI, I18N.createStringBinding("label.word.alsoVisualizeH"));
        addTooltipToImage(displayTaxonomyI, I18N.createStringBinding("label.word.displayTaxonomyH"));
        addTooltipToImage(writeMsdAtTheEndI, I18N.createStringBinding("label.word.writeMsdAtTheEndH"));
        addTooltipToImage(notePunctuationsI, I18N.createStringBinding("label.wordSet.notePunctuationsH"));

        addTooltipToImage(msdI, I18N.createStringBinding("label.word.msdH"));
        addTooltipToImage(taxonomyI, I18N.createStringBinding("label.word.taxonomyH"));
        addTooltipToImage(minimalOccurrencesI, I18N.createStringBinding("label.word.minimalOccurrencesH"));
        addTooltipToImage(minimalTaxonomyI, I18N.createStringBinding("label.word.minimalTaxonomyH"));
        addTooltipToImage(minimalRelFreI, I18N.createStringBinding("label.wordPart.minimalRelFreH"));
        addTooltipToImage(taxonomySetOperationI, I18N.createStringBinding("label.letter.taxonomySetOperationH"));

        taxonomySetOperationCB.itemsProperty().bind(I18N.createObjectBinding(TAXONOMY_SET_OPERATION));
    }

    /**
     * Toggles visibility for panes which hold fields for skipgram value (not applicable when calculating for letters) etc.,
     * sets combobox values to what is applicable ...
     *
     * @param mode
     */
    public void toggleMode(MODE mode) {
        if (mode == null) {
            mode = currentMode;
        }

        logger.info("mode: ", mode.toString());

        if (mode == MODE.WORD) {
            if (corpus.getCorpusType() == CorpusType.GOS) {
                calculateForCB.itemsProperty().unbind();
                calculateForCB.itemsProperty().bind(I18N.createObjectBinding(N_GRAM_COMPUTE_FOR_WORDS_GOS));
            } else {
                calculateForCB.itemsProperty().unbind();
                calculateForCB.itemsProperty().bind(I18N.createObjectBinding(N_GRAM_COMPUTE_FOR_WORDS));
            }
        }
        // override if orth mode, allow only word
        if (corpus.isGosOrthMode()) {
            calculateForCB.itemsProperty().unbind();
            calculateForCB.itemsProperty().bind(I18N.createObjectBinding(N_GRAM_COMPUTE_FOR_WORDS_ORTH));
            msdTF.setDisable(true);
        } else {
            msdTF.setDisable(false);
        }
        calculateFor = CalculateFor.factory(calculateForCB.getItems().get(0));
    }

    private void compute() {
        Filter filter = new Filter();
        filter.setNgramValue(1);
        filter.setCalculateFor(calculateFor);
        filter.setTaxonomy(taxonomy);
        filter.setDisplayTaxonomy(displayTaxonomy);
        filter.setAl(AnalysisLevel.STRING_LEVEL);
        filter.setSkipValue(0);
        filter.setIsCvv(false);
        filter.setSolarFilters(solarFiltersMap);
        filter.setStringLength(1);
        filter.setMultipleKeys(alsoVisualize);
        filter.setNotePunctuations(notePunctuations);

        // setMsd must be behind alsoVisualize
        filter.setMsd(msd);
        filter.setMinimalOccurrences(minimalOccurrences);
        filter.setMinimalTaxonomy(minimalTaxonomy);
        filter.setMinimalRelFre(minimalRelFre);
        filter.setWriteMsdAtTheEnd(writeMsdAtTheEnd);
        filter.setTaxonomySetOperation(taxonomySetOperation);

        String message = Validation.validateForStringLevel(filter);
        if (message == null) {
            // no errors
            logger.info("Executing: ", filter.toString());
            StatisticsNew statistic = new StatisticsNew(corpus, filter, useDb);
            execute(statistic);
        } else {
            logAlert(message);
            showAlert(Alert.AlertType.ERROR, "Prosim izpolnite polja:", message);
        }
    }

    private void logAlert(String alert) {
        logger.info("alert: " + alert);
    }

    private void openHelpWebsite(){
        hostService.showDocument(Messages.HELP_URL);
    }

    public Corpus getCorpus() {
        return corpus;
    }

    public void setCorpus(Corpus corpus) {
        this.corpus = corpus;

        if (corpus.getCorpusType() != CorpusType.SOLAR) {
            setSelectedFiltersLabel(null);
        } else {
            setSelectedFiltersLabel("/");
        }
    }

    public void setSelectedFiltersLabel(String content) {
        if (content != null) {
            solarFilters.setVisible(true);
            selectedFiltersTextArea.setVisible(true);
            selectedFiltersTextArea.setText(content);
        } else {
            solarFilters.setVisible(false);
            selectedFiltersTextArea.setVisible(false);
        }
    }

    private void execute(StatisticsNew statistic) {
        logger.info("Started execution: ", statistic.getFilter());

        Tasks t = new Tasks(corpus, useDb, cancel, ngramProgressBar, progressLabel);
        if (statistic.getFilter().getMinimalRelFre() > 1){
            final Task<Void> mainTask = t.prepareTaskForMinRelFre(statistic);
            final Thread thread = new Thread(mainTask, "task");
            thread.setDaemon(true);
            thread.start();
        } else {
            final Task<Void> mainTask = t.prepareMainTask(statistic);
            final Thread thread = new Thread(mainTask, "task");
            thread.setDaemon(true);
            thread.start();
        }
    }

    public void setSolarFiltersMap(HashMap<String, HashSet<String>> solarFiltersMap) {
        this.solarFiltersMap = solarFiltersMap;
    }
    public void setHostServices(HostServices hostServices){
        this.hostService = hostServices;
    }

}
