/*
    * Copyright 2013-2023 Medical Information Systems Research Group (https://medical.zcu.cz),
    * Department of Computer Science and Engineering, University of West Bohemia.
    * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
    *
    * This file is part of Sparkle project.
    *
    * Sparkle is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License.
   *
   * Sparkle is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Sparkle. If not, see <http://www.gnu.org/licenses/>.
   */
  package cz.zcu.mre.sparkle.gui.query;
  
  import cz.zcu.mre.sparkle.Messages;
  import cz.zcu.mre.sparkle.data.*;
  import cz.zcu.mre.sparkle.data.AbstractTermsStorage.StorageChangeListener;
  import cz.zcu.mre.sparkle.data.resourceStorage.ResourcesStorage;
  import cz.zcu.mre.sparkle.gui.mainForm.MainForm;
  import static cz.zcu.mre.sparkle.gui.query.QueryFormPane.QUERY_PARTS.*;
  import cz.zcu.mre.sparkle.gui.query.autoComplete.AutoCompleteListHandler;
  import cz.zcu.mre.sparkle.gui.query.autoComplete.ExpressionAutoCompleteListHandler;
  import cz.zcu.mre.sparkle.gui.query.autoComplete.VariablesAutoCompleteListHandler;
  import cz.zcu.mre.sparkle.gui.query.helpers.*;
  import cz.zcu.mre.sparkle.gui.query.modifiers.GroupGraphPatternPane;
  import cz.zcu.mre.sparkle.gui.query.modifiers.LimitOffsetClausePane;
  import cz.zcu.mre.sparkle.gui.query.modifiers.OrderByClausePane;
  import cz.zcu.mre.sparkle.gui.query.modifiers.ValuesClausePane;
  import cz.zcu.mre.sparkle.gui.query.modifiers.groupBy.GroupByClausePane;
  import cz.zcu.mre.sparkle.gui.query.modifiers.having.HavingClausePane;
  import cz.zcu.mre.sparkle.gui.query.queryMainParts.FromClausePane;
  import cz.zcu.mre.sparkle.gui.query.queryMainParts.WhereClausePane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.ask.AskQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.construct.ConstructQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.describe.DescribeQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.select.SelectQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.subselect.SubSelectPane;
  import cz.zcu.mre.sparkle.gui.tools.Components;
  import cz.zcu.mre.sparkle.gui.tools.ReferenceKeeper;
  import cz.zcu.mre.sparkle.tools.*;
  import java.io.File;
  import java.io.IOException;
  import java.io.Serializable;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import javafx.beans.InvalidationListener;
  import javafx.beans.property.BooleanProperty;
  import javafx.beans.property.SimpleBooleanProperty;
  import javafx.collections.FXCollections;
  import javafx.collections.MapChangeListener.Change;
  import javafx.collections.ObservableList;
  import javafx.scene.control.ScrollPane;
  import javafx.scene.layout.VBox;
  import javafx.scene.paint.Color;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.TransformerException;
  import org.antlr.v4.runtime.ParserRuleContext;
  import org.antlr.v4.runtime.misc.ParseCancellationException;
  import org.antlr.v4.runtime.tree.ParseTree;
  import org.antlr.v4.runtime.tree.ParseTreeWalker;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  
  /**
   * Abstraktní třída sloužící jako základ pro kontrolery komponent
   * představujících jednotlivé dotazy
   * ({@link AskQueryFormPane}, {@link ConstructQueryFormPane}, {@link DescribeQueryFormPane}
   * a {@link SelectQueryFormPane}).
   *
   * @param <QueryResultType> Typ výsledku dotazu.
   *
   * @author Jan Smucr
   * @author Klara Hlavacova
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public abstract class QueryFormPane<QueryResultType>
          extends VBox
          implements PartialQueryGenerator, PrefixesUser, VariablesGenerator, Changeable, Saveable {
  
      private final Set<InvalidationListener> observers = new HashSet<>();
  
      public static final String XML_ELEMENT_NAME = "Sparkle"; //$NON-NLS-1$
      public static final String XML_QUERY_TYPE = "type"; //$NON-NLS-1$
      public static final String XML_TAB_COLOR = "tabColor"; //$NON-NLS-1$
  
      public enum QUERY_PARTS {
          FIRST_CLAUSE, FROM_CLAUSE, WHERE_CLAUSE, ORDER_BY_CLAUSE, GROUP_BY_CLAUSE, HAVING_CLAUSE,
          LIMIT_OFFSET_CLAUSE, VALUES_CLAUSE
          //FIRST_CLAUSE - ASK, SELECT, CONSTRUCT, DESCRIBE
     }
 
     private final Storage localStorage;
     private final String paneType;
 
     private PrefixesStorage queryPrefixesStorage;
     private FunctionsStorage queryFunctionsStorage;
     private DataTypesStorage queryDataTypesStorage;
     private ResourcesStorage queryResourcesStorage;
 
     private final ObservableList<String> variables = FXCollections.observableArrayList();
     private final ObservableList<String> sortedVariables = variables.sorted(String.CASE_INSENSITIVE_ORDER);
     private final Set<VariablesCollector> variablesCollectors = new HashSet<>();
 
     private final ReferenceKeeper keeper = new ReferenceKeeper();
     private final Set<String> addedLocalPrefixes = new HashSet<>();
 
     private DataAgent dataAgent;
 
     private MainForm mainForm;
     private final BooleanProperty deleteProperty = new SimpleBooleanProperty(false);
     private static Color obtainedColor = null;
 
     private ScrollPane scrollPane;
 
     /**
      * Výchozí handler pro seznam návrhů k poli pro zadávání výrazu.
      */
     public final AutoCompleteListHandler DEFAULT_EXPRESSION_AUTOCOMPLETE_LIST_HANDLER
             = new ExpressionAutoCompleteListHandler(this);
     /**
      * Výchozí handler pro seznam návrhů k poli pro zadávání názvu proměnné.
      */
     public final AutoCompleteListHandler DEFAULT_VARIABLES_AUTOCOMPLETE_LIST_HANDLER
             = new VariablesAutoCompleteListHandler(this);
 
     /**
      * @param mainForm hlavni formular
      * @param dataAgent rozhrani mezi ulozistem a aplikaci
      * @param localStorage prepravka pro lokalni mapovani prefixu; seznam
      * ostatních pojmu;
      * @param paneType typ dotazu
      */
     public QueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
             String paneType) {
         this.localStorage = localStorage;
         this.paneType = paneType;
 
         init(mainForm, dataAgent, localStorage);
         try {
             // Vytvoření nového dotazu
             load(null);
         } catch (final LoadException e) {
             // Toto se nemůže stát
         }
         setupWatches();
     }
 
     /**
      * @param mainForm hlavni formular
      * @param dataAgent rozhrani mezi ulozistem a aplikaci
      * @param localStorage prepravka pro lokalni mapovani prefixu; seznam
      * ostatních pojmu; seznam datovych typu; seznam funkci
      * @param root rodicovksky uzel (element)
      *
      * @param paneType typ dotazu
      * @throws LoadException
      */
     protected QueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
             final Object root, String paneType)
             throws LoadException {
 
         this.localStorage = localStorage;
         this.paneType = paneType;
         init(mainForm, dataAgent, localStorage);
 
         if (root instanceof Element) {
             // Načtení uloženého dotazu
             Element rootNode = (Element) root;
             loadStorages(rootNode);
             load(rootNode);
 
         } else if (root instanceof ParserRuleContext) {
             ParserRuleContext prContext = (ParserRuleContext) root;
             loadPrefixes(prContext);
             load(prContext);
         }
         setupWatches();
     }
 
     /**
      * Inicializace panelu
      *
      * @param mainForm hlavni formular
      * @param dataAgent rozhrani mezi ulozistem a aplikaci
      * @param localStorage prepravka pro lokalni mapovani prefixu; seznam
      * ostatních pojmu; seznam datovych typu; seznam funkci
      */
     private void init(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage) {
 
         Components.load(this);
         this.mainForm = mainForm;
         this.dataAgent = dataAgent;
 
         queryPrefixesStorage = new PrefixesStorage();
         setupPrefixesStorage(localStorage.getPrefixesStorage());
 
         queryResourcesStorage = new ResourcesStorage(dataAgent, queryPrefixesStorage);
         setupTermsStorage(localStorage.getResourcesStorage(), queryResourcesStorage);
 
         queryDataTypesStorage = new DataTypesStorage(dataAgent, queryPrefixesStorage);
         setupTermsStorage(localStorage.getDataTypesStorage(), queryDataTypesStorage);
 
         queryFunctionsStorage = new FunctionsStorage(dataAgent, queryPrefixesStorage);
         setupTermsStorage(localStorage.getFunctionsStorage(), queryFunctionsStorage);
 
         addVariablesCollector(new VariablesCollector() {
             @Override
             public final void onVariableRemoved(final String variableName) {
                 variables.remove(variableName);
             }
 
             @Override
             public final void onVariableChanged(final String oldVariableName, final String newVariableName) {
                 variables.set(variables.indexOf(oldVariableName), newVariableName);
             }
 
             @Override
             public final void onVariableAdded(final String variableName) {
                 variables.add(variableName);
             }
         });
 
         scrollPane = new ScrollPane(this);
         scrollPane.setFitToWidth(true);
         scrollPane.setPannable(true);
 
     }
 
     /**
      * Nastaví synchronizaci mezi lokálním seznamem pojmů a seznamem pojmů
      * vázaným na dotaz.
      *
      * @param localStorage Místní seznam pojmů (platný pro app)
      * @param queryStorage Seznam pojmů vázaný na dotaz.
      */
     private <StorageEntryType extends Serializable> void setupTermsStorage(
             final AbstractTermsStorage<StorageEntryType> localStorage,
             final AbstractTermsStorage<StorageEntryType> queryStorage) {
 
         final Set<StorageEntryType> termsToAdd = localStorage.getAllTerms();
         termsToAdd.removeAll(queryStorage.getAllTerms());
 
         queryStorage.addFrom(localStorage);
         //TODO: pridani noveho termu, pokud jiz existuje
 
         localStorage.addListener(keeper.toWeak(new StorageChangeListener<StorageEntryType>() {
             private final Set<StorageEntryType> addedLocalTerms = new HashSet<>(termsToAdd);
 
             @Override
             public final void changed(final StorageEntryType term, final boolean added) {
                 if (added && addedLocalTerms.add(term)) {
                     queryStorage.addTerm(term);
                     return;
                 }
                 if (!added && addedLocalTerms.remove(term)) {
                     queryStorage.removeTerm(term);
                 }
             }
         }));
     }
 
     /**
      * Nastaví synchronizaci mezi lokálním mapováním prefixů a mapováním vázaným
      * na dotaz.
      *
      * @param localPrefixesStorage Místní mapování.
      */
     private void setupPrefixesStorage(final PrefixesStorage localPrefixesStorage) {
         final Set<String> prefixesToAdd = localPrefixesStorage.getPrefixesUsed(false);
         prefixesToAdd.removeAll(queryPrefixesStorage.getPrefixesUsed(false));
         addedLocalPrefixes.addAll(prefixesToAdd);
 
         queryPrefixesStorage.add(localPrefixesStorage);
 
         localPrefixesStorage
                 .getPrefixToIri()
                 .addListener(keeper.toWeak((final Change<? extends String, ? extends String> change) -> {
 
                     final boolean changed = change.wasRemoved() && change.wasAdded();
                     final boolean canChange = addedLocalPrefixes.contains(change.getKey());
 
                     if (change.wasRemoved() && addedLocalPrefixes.remove(change.getKey())
                             && !getPrefixesUsed(false).contains(change.getKey())) {
 
                         queryPrefixesStorage.removeNsPrefix(change.getKey());
                     }
                     if (!changed || canChange) {
                         if (!canChange && queryPrefixesStorage.getPrefixToIri().containsKey(change.getKey())) {
                             return;
                         }
                         if (change.wasAdded() && addedLocalPrefixes.add(change.getKey())) {
                             String altIri = localPrefixesStorage.getIriToAlternativeIri().get(change.getValueAdded());
                             queryPrefixesStorage.setNsPrefix(change.getKey(), change.getValueAdded(), altIri);
                         }
                     }
                 }));
 
         queryPrefixesStorage.getPrefixToIri()
                 .addListener(keeper.toWeak((final Change<? extends String, ? extends String> change) -> {
 
                     if (change.wasRemoved()) {
                         addedLocalPrefixes.remove(change.getKey());
                     }
                 }));
     }
 
     /**
      * Sledování změn v seznamech. Změna v seznamu = změna dotazu.
      */
     private void setupWatches() {
         watch(queryResourcesStorage);
         watch(queryDataTypesStorage);
         watch(queryFunctionsStorage);
         watch(queryPrefixesStorage);
         watch(dataAgent);
     }
 
     /**
      * Tento magicky vypadající kus kódu ve skutečnosti pouze vytváří
      * posluchače, který reaguje na upozornění o manipulaci s proměnnými.
      * Udržuje jednu sadu proměnných a porovnává ji s ostatními. Typickým
      * případem využití je situace, kdy klauzule SELECT ohlásí odstranění
      * proměnné. Posluchač se pak podívá, zda proměnná existuje ještě někde
      * jinde (např. ve WHERE a v ORDER BY) a globálně ohlásí odstranění proměnné
      * až pokud zjistí, že šlo o její poslední výskyt.
      *
      * @param relatedVariablesSet Sada proměnných, ke které se posluchač
      * vztahuje.
      * @param otherVariablesSets Sady proměnných, které je třeba kontrolovat.
      *
      * @return Posluchač.
      */
     @SafeVarargs
     protected final VariablesCollector createCollector(final Set<String> relatedVariablesSet,
             final Set<String>... otherVariablesSets) {
         return new VariablesCollector() {
             @Override
             public void onVariableRemoved(final String variableName) {
                 if (relatedVariablesSet.remove(variableName) && !someSetContains(variableName, otherVariablesSets)) {
                     notifyVariableRemoved(variableName);
                 }
             }
 
             @Override
             public void onVariableChanged(final String oldVariableName, final String newVariableName) {
                 relatedVariablesSet.remove(oldVariableName);
                 final boolean added = relatedVariablesSet.add(newVariableName);
 
                 if (someSetContains(oldVariableName, otherVariablesSets)) {
                     if (added && !someSetContains(newVariableName, otherVariablesSets)) {
                         notifyVariableAdded(newVariableName);
                     }
                 } else if (added && !someSetContains(newVariableName, otherVariablesSets)) {
                     notifyVariableChanged(oldVariableName, newVariableName);
                 } else {
                     notifyVariableRemoved(oldVariableName);
                 }
             }
 
             @Override
             public void onVariableAdded(final String variableName) {
                 if (relatedVariablesSet.add(variableName) && !someSetContains(variableName, otherVariablesSets)) {
                     notifyVariableAdded(variableName);
                 }
             }
         };
     }
 
     /**
      * Hledá výskyt objektu v nějaké z uvedených množin.
      *
      * @param item Objekt.
      * @param sets Množiny.
      *
      * @return <code>true</code>, pokud byl nalezen.
      */
     @SafeVarargs
     private static <E> boolean someSetContains(final E item, final Set<E>... sets) {
         for (final Set<E> set : sets) {
             if (set.contains(item)) {
                 return true;
             }
         }
         return false;
     }
 
     @Override
     public final Set<String> getVariables() {
         final Set<String> vars = new HashSet<>();
         getChildren().stream().filter((node) -> (node instanceof SimpleVariablesGenerator)).forEach((node) -> vars.addAll(((SimpleVariablesGenerator) node).getVariables()));
 
         return vars;
     }
 
     @Override
     public final void addVariablesCollector(final VariablesCollector collector) {
         variablesCollectors.add(collector);
     }
 
     @Override
     public final void removeVariablesCollector(final VariablesCollector collector) {
         variablesCollectors.remove(collector);
     }
 
     @Override
     public final void notifyVariableAdded(final String variableName) {
         variablesCollectors.stream().forEach((collector) -> collector.onVariableAdded(variableName));
     }
 
     @Override
     public final void notifyVariableRemoved(final String variableName) {
         variablesCollectors.stream().forEach((collector) -> collector.onVariableRemoved(variableName));
     }
 
     @Override
     public final void notifyVariableChanged(final String oldVariableName, final String newVariableName) {
         variablesCollectors.stream().forEach((collector) -> collector.onVariableChanged(oldVariableName, newVariableName));
     }
 
     /**
      * Vygeneruje proměnnou, která se v dotazu ještě nevyskytuje.
      *
      * @param prefix Prefix.
      * @param suffix Suffix.
      *
      * @return Unikátní název proměnné.
      */
     public final String generateNewVariableName(String prefix, String suffix) {
         String varName;
         if ((prefix == null) || prefix.trim().isEmpty()) {
             prefix = Messages.getString("AUTO_VARIABLE_PREFIX"); //$NON-NLS-1$
         }
         if ((suffix == null) || suffix.trim().isEmpty()) {
             suffix = ""; //$NON-NLS-1$
         }
 
         int num = 0;
         do {
             num++;
             varName = prefix + num + suffix;
         } while (variables.contains(varName));
 
         return varName;
     }
 
     /**
      * @return Sestavený dotaz v podobě řetězce.
      */
     public final String getQuery() {
         final StringBuilder queryBuilder = new StringBuilder();
 
         getPrefixesUsed(false).stream().forEach((prefix) -> {
             final String iri = queryPrefixesStorage.getPrefixToIri().get(prefix);
             appendPrologue(queryBuilder, prefix, iri);
         });
 
         queryBuilder.append(getQueryPart());
         return queryBuilder.toString();
     }
 
     /**
      * Pripoji k dotazu prologue
      *
      * @param queryBuilder StringBuilder
      * @param prefix prefix
      * @param iri iri
      */
     public static void appendPrologue(StringBuilder queryBuilder, String prefix, String iri) {
         if (iri != null) {
             queryBuilder.append("PREFIX "); //$NON-NLS-1$
             queryBuilder.append(prefix);
             queryBuilder.append(Definitions.PREFIXED_NAME_PREFIX_DELIMITER);
             queryBuilder.append(' ');
             queryBuilder.append(Definitions.IRI_PREFIX);
             queryBuilder.append(iri);
             queryBuilder.append(Definitions.IRI_SUFFIX);
             queryBuilder.append('\n');
         }
     }
 
     /**
      * Uloží dotaz do XML souboru.
      *
      * @param file Výstupní souboru.
      *
      * @throws ParserConfigurationException from DocumentBuilderFactory
      * @throws TransformerException from TransfomerFactory
      */
     public final void save(final File file) throws ParserConfigurationException, TransformerException {
         QueryFormPaneSave.save(file, this);
     }
 
     /**
      * Načte dotaz ze souboru.
      *
      * @param mainForm MainForm of Sparkle instance.
      * @param dataAgent Připojení k úložišti.
      * @param localStorage Lokální mapování prefixů; Lokální seznam ostatních
      * pojmů; Lokální seznam datových typů; Lokální seznam funkcí.
      * @param file Vstupní soubor.
      *
      * @return Instance {@link QueryFormPane}.
      *
      * @throws ParserConfigurationException from DocumentBuilderFactory
      * @throws TransformerException from TransformerFactory
      * @throws Saveable.LoadException on loading
      * @throws java.io.IOException on loading
      */
     public static QueryFormPane<?> load(
             final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
             final File file)
             throws ParserConfigurationException, TransformerException, Saveable.LoadException,
             ParseCancellationException, IOException {
 
         return QueryFormPaneLoad.load(mainForm, dataAgent, localStorage, file);
     }
 
     /**
      * Načte dotaz dany retezcem
      *
      * @param mainForm MainForm of Sparkle instance.
      * @param dataAgent Připojení k úložišti.
      * @param localStorage Lokální mapování prefixů; Lokální seznam ostatních
      * pojmů; Lokální seznam datových typů; Lokální seznam funkcí.
      * @param queryString Retezec s dotazem
      *
      * @return Instance {@link QueryFormPane}.
      *
      * @throws ParserConfigurationException from DocumentBuilderFactory
      * @throws TransformerException from TransformerFactory
      * @throws Saveable.LoadException on loading
      */
     public static QueryFormPane<?> load(
             final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
             final String queryString)
             throws ParserConfigurationException, TransformerException, Saveable.LoadException,
             ParseCancellationException {
 
         return QueryFormPaneLoad.load(mainForm, dataAgent, localStorage, queryString);
     }
 
     /**
      * Obnoví stav libovolného {@link Saveable} z předaného XML elementu.
      *
      * @param root Kořenový element.
      * @param element Obnovovaný objekt.
      *
      * @throws LoadException Chyba při načítání dat z XML souboru.
      */
     protected static void loadElement(final Element root, final Saveable element) throws LoadException {
         final String tagName = element.getXMLElementName();
 
         /*final NodeList nodeList = root.getElementsByTagName(tagName);
         if (nodeList.getLength() > 0) {
             element.load((Element) nodeList.item(0));
         } else {
             throw new LoadException(tagName);
         }*/
         final NodeList nodeList = root.getChildNodes();
         int nodesCount = nodeList.getLength();
         if (nodesCount > 0) {
             for (int nodeIndex = 0; nodeIndex < nodesCount; nodeIndex++) {
 
                 final org.w3c.dom.Node childNode = nodeList.item(nodeIndex);
                 if (childNode instanceof Element) {
                     Element child = (Element) childNode;
                     if (child.getTagName().equalsIgnoreCase(tagName)) {
                         element.load(child);
                     }
                 }
             }
         } else {
             throw new LoadException(tagName);
         }
     }
 
     /**
      * Nahraje casti formulare
      *
      * @param root rodicovsky element
      * @param queryFormParts pole s panely
      *
      * @throws LoadException
      */
     protected void loadQueryPartsElements(Element root, List<Object> queryFormParts) throws LoadException {
         loadElement(root, (FromClausePane) getPane(queryFormParts, FROM_CLAUSE));
         loadElement(root, (WhereClausePane) getPane(queryFormParts, WHERE_CLAUSE));
         loadElement(root, ((OrderByClausePane) getPane(queryFormParts, ORDER_BY_CLAUSE)));
         loadElement(root, ((GroupByClausePane) getPane(queryFormParts, GROUP_BY_CLAUSE)));
         loadElement(root, ((HavingClausePane) getPane(queryFormParts, HAVING_CLAUSE)));
         loadElement(root, ((LimitOffsetClausePane) getPane(queryFormParts, LIMIT_OFFSET_CLAUSE)));
         loadElement(root, ((ValuesClausePane) getPane(queryFormParts, VALUES_CLAUSE)));
     }
 
     void saveStorages(final Element root) {
         Saveable.defaultSave(root, queryPrefixesStorage, queryFunctionsStorage, queryDataTypesStorage, queryResourcesStorage);
     }
 
     private void loadStorages(final Element root) throws LoadException {
         loadElement(root, queryPrefixesStorage);
         loadElement(root, queryFunctionsStorage);
         loadElement(root, queryDataTypesStorage);
         loadElement(root, queryResourcesStorage);
     }
 
     public void loadPrefixes(final ParserRuleContext prContext) {
         ParseTreeWalker.DEFAULT.walk(new SparqlParserBaseListener() {
             @Override
             public void enterPrefixDecl(SparqlParser.PrefixDeclContext ctx) {
                 try {
                     queryPrefixesStorage.load(ctx);
                 } catch (LoadException ex) {
                     Logger.getLogger(QueryFormPane.class.getName()).log(Level.SEVERE, null, ex);
                 }
             }
         }, prContext);
     }
 
     /**
      * Vrati panel ze seznamu casti formulare
      *
      * @param queryFormParts seznam casti formulare
      * @param paneType typ panelu
      *
      * @return panel ze seznamu casti formulare
      */
     protected Object getPane(List<Object> queryFormParts, QUERY_PARTS paneType) {
         return queryFormParts.get(paneType.ordinal());
     }
 
     /**
      * It returns query variables.
      *
      * @return List of variables.
      */
     public ObservableList<String> getNetVariables() {
         return this.sortedVariables;
     }
 
     public BooleanProperty getDeleteProperty() {
         return this.deleteProperty;
     }
 
     public void setDeleteProperty() {
         this.deleteProperty.set(true);
     }
 
     public MainForm getMainForm() {
         return this.mainForm;
     }
 
     public static void setObtainedColor(String colorText) {
         try {
             obtainedColor = Color.web(colorText);
         } catch (Exception e) {
             obtainedColor = null;
         }
     }
 
     public Color getObtainedColor() {
         return obtainedColor;
     }
 
     public final DataAgent getDataAgent() {
         return dataAgent;
     }
 
     public final ResourcesStorage getQueryResourcesStorage() {
         return queryResourcesStorage;
     }
 
     public final DataTypesStorage getQueryDataTypesStorage() {
         return queryDataTypesStorage;
     }
 
     public final FunctionsStorage getQueryFunctionsStorage() {
         return queryFunctionsStorage;
     }
 
     public final PrefixesStorage getQueryPrefixesStorage() {
         return queryPrefixesStorage;
     }
 
     public final void setQueryPrefixesStorage(PrefixesStorage queryPrefixesStorage) {
         this.queryPrefixesStorage = queryPrefixesStorage;
     }
 
     /**
      * It returns a relevant list of variables from whole query.
      *
      * @return Variable list.
      */
     public ObservableList<String> getSortedVariables() {
         return this.getNetVariables();
     }
 
     @Override
     public String getXMLElementName() {
         return XML_ELEMENT_NAME;
     }
 
     protected abstract String getXMLQueryType();
 
     /**
      * Method obtains all {@link SubSelectPane} in query.
      *
      * @return All {@link SubSelectPane} in {@link GroupGraphPatternPane}.
      */
     public abstract List<SubSelectPane> getSubSelectPanes();
 
     /**
      * It loads all query variables to pane by DFS.
      *
      * @param root root node (enter node) of query.
      *
      * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException Error during
      * query loading from file.
      */
     protected abstract void setVariables(ParseTree root) throws LoadException;
 
     public Storage getLocalStorage() {
         return localStorage;
     }
 
     public ScrollPane getScrollPane() {
         return scrollPane;
     }
 
     @Override
     public final Set<InvalidationListener> getObservers() {
         return observers;
     }
 
     public String getPaneType() {
         return paneType;
     }
 }