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.image.ImageView;
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 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 WordLevelTab {
	public final static Logger logger = LogManager.getLogger(OneWordAnalysisTab.class);

	@FXML
	public AnchorPane wordLevelAnalysisTabPane;

	@FXML
	public TextArea selectedFiltersTextArea;

	@FXML
	public Label solarFilters;

	@FXML
	public Label calculateForL;

	@FXML
	public Label alsoVisualizeL;

	@FXML
	public Label displayTaxonomyL;

	@FXML
	public Label lengthSearchL;

	@FXML
	public Label prefixLengthL;

	@FXML
	public Label suffixLengthL;

	@FXML
	public Label listSearchL;

	@FXML
	public Label prefixListL;

	@FXML
	public Label suffixListL;

	@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 prefixLengthI;

	@FXML
	public ImageView suffixLengthI;

	@FXML
	public ImageView prefixListI;

	@FXML
	public ImageView suffixListI;

	@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 ComboBox<String> prefixLengthCB;
	private Integer prefixLength;

	@FXML
	private ComboBox<String> suffixLengthCB;
	private Integer suffixLength;

	@FXML
	private TextField prefixListTF;
	private ArrayList<String> prefixList;

	@FXML
	private TextField suffixListTF;
	private ArrayList<String> suffixList;

	@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 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"};
	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.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 [] TAXONOMY_SET_OPERATION_ARRAY = {"taxonomySetOperation.UNION", "taxonomySetOperation.INTERSECTION"};
	private static final ArrayList<String> TAXONOMY_SET_OPERATION = new ArrayList<>(Arrays.asList(TAXONOMY_SET_OPERATION_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));

	// TODO: pass observables for taxonomy based on header scan
	// after header scan
	public void init() {
		// add CSS style
		wordLevelAnalysisTabPane.getStylesheets().add("style.css");
		wordLevelAnalysisTabPane.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())) {
					alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_MSD));
				} else {

					alsoVisualizeCCB.getItems().setAll(I18N.translatedObservableList(ALSO_VISUALIZE_ITEMS_EMPTY));
				}

				alsoVisualizeListener = new ListChangeListener<String>() {
					@Override
					public void onChanged(Change<? extends String> c) {
						alsoVisualize = new ArrayList<>();
						ObservableList<String> checkedItems = alsoVisualizeCCB.getCheckModel().getCheckedItems();
						alsoVisualize.addAll(checkedItems);
						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);


		prefixLengthCB.getSelectionModel().select(0);
		prefixLength = 0;

        prefixLengthCB.valueProperty().addListener((observable, oldValue, newValue) -> {
            prefixLength = Integer.valueOf(newValue);
            if(prefixLength > 0){
                prefixListTF.setDisable(true);
                suffixListTF.setDisable(true);
            } else if(prefixLength == 0 && suffixLength == 0){
                prefixListTF.setDisable(false);
                suffixListTF.setDisable(false);
            }

            if(prefixLength > 0 || suffixLength > 0 || prefixList.size() > 0 || suffixList.size() > 0) {
                computeNgramsB.setDisable(false);
            } else {
                computeNgramsB.setDisable(true);
            }
            logger.info("Prefix length " + prefixLength);
        });

        suffixLengthCB.getSelectionModel().select(0);
        suffixLength = 0;


        suffixLengthCB.valueProperty().addListener((observable, oldValue, newValue) -> {
            suffixLength = Integer.valueOf(newValue);
            if(suffixLength > 0){
                prefixListTF.setDisable(true);
                suffixListTF.setDisable(true);
            } else if(prefixLength == 0 && suffixLength == 0){
                prefixListTF.setDisable(false);
                suffixListTF.setDisable(false);
            }

            if(prefixLength > 0 || suffixLength > 0 || prefixList.size() > 0 || suffixList.size() > 0) {
                computeNgramsB.setDisable(false);
            } else {
                computeNgramsB.setDisable(true);
            }
            logger.info("Prefix length " + suffixLength);
        });

		prefixListTF.setText("");
        prefixList = new ArrayList<>();

        prefixListTF.textProperty().addListener((observable, oldValue, newValue) -> {
            String value = prefixListTF.getText();
            prefixList = new ArrayList<>();
            if (!ValidationUtil.isEmpty(value)) {
                for (String w : value.split(";")){
                    w = w.replaceAll("\\s+","");
                    if (!w.equals("")){
                        prefixList.add(w);
                    }
                }
            }

            System.out.println(prefixList);

            if(prefixList.size() > 0){
                prefixLengthCB.setDisable(true);
                suffixLengthCB.setDisable(true);
            } else if(suffixList.size() == 0){
                prefixLengthCB.setDisable(false);
                suffixLengthCB.setDisable(false);
            }

            if(prefixLength > 0 || suffixLength > 0 || prefixList.size() > 0 || suffixList.size() > 0) {
                computeNgramsB.setDisable(false);
            } else {
                computeNgramsB.setDisable(true);
            }
        });

		suffixListTF.setText("");
        suffixList = new ArrayList<>();

        suffixListTF.textProperty().addListener((observable, oldValue, newValue) -> {
            String value = suffixListTF.getText();
            suffixList = new ArrayList<>();
            if (!ValidationUtil.isEmpty(value)) {
                for (String w : value.split(";")){
                    w = w.replaceAll("\\s+","");
                    if (!w.equals("")){
                        suffixList.add(w);
                    }
                }
            }
            System.out.println(suffixList);
            if(suffixList.size() > 0){
                prefixLengthCB.setDisable(true);
                suffixLengthCB.setDisable(true);
            } else if(prefixList.size() == 0){
                prefixLengthCB.setDisable(false);
                suffixLengthCB.setDisable(false);
            }

            if(prefixLength > 0 || suffixLength > 0 || prefixList.size() > 0 || suffixList.size() > 0) {
                computeNgramsB.setDisable(false);
            } else {
                computeNgramsB.setDisable(true);
            }
        });

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

				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>() {
			boolean changing = true;

			@Override
			public void onChanged(ListChangeListener.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);
		}

		// 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.setDisable(true);

		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"));

		lengthSearchL.textProperty().bind(I18N.createStringBinding("label.lengthSearch"));
		prefixLengthL.textProperty().bind(I18N.createStringBinding("label.prefixLength"));
		suffixLengthL.textProperty().bind(I18N.createStringBinding("label.suffixLength"));
 		listSearchL.textProperty().bind(I18N.createStringBinding("label.listSearch"));
		prefixListL.textProperty().bind(I18N.createStringBinding("label.prefixList"));
		suffixListL.textProperty().bind(I18N.createStringBinding("label.suffixList"));

		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.wordPart.calculateForH"));
		addTooltipToImage(alsoVisualizeI, I18N.createStringBinding("label.wordPart.alsoVisualizeH"));
		addTooltipToImage(displayTaxonomyI, I18N.createStringBinding("label.wordPart.displayTaxonomyH"));

		addTooltipToImage(prefixLengthI, I18N.createStringBinding("label.wordPart.prefixLengthH"));
		addTooltipToImage(suffixLengthI, I18N.createStringBinding("label.wordPart.suffixLengthH"));
		addTooltipToImage(prefixListI, I18N.createStringBinding("label.wordPart.prefixListH"));
		addTooltipToImage(suffixListI, I18N.createStringBinding("label.wordPart.suffixListH"));

		addTooltipToImage(msdI, I18N.createStringBinding("label.wordPart.msdH"));
		addTooltipToImage(taxonomyI, I18N.createStringBinding("label.wordPart.taxonomyH"));
		addTooltipToImage(minimalOccurrencesI, I18N.createStringBinding("label.wordPart.minimalOccurrencesH"));
		addTooltipToImage(minimalTaxonomyI, I18N.createStringBinding("label.wordPart.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);

		// setMsd must be behind alsoVisualize
		filter.setMsd(msd);
		filter.setMinimalOccurrences(minimalOccurrences);
		filter.setMinimalTaxonomy(minimalTaxonomy);
		filter.setMinimalRelFre(minimalRelFre);
		filter.setPrefixLength(prefixLength);
		filter.setSuffixLength(suffixLength);
		filter.setPrefixList(prefixList);
		filter.setSuffixList(suffixList);
		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;
	}
}