/*
    * 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.queryTypes.select;
  
  import cz.zcu.mre.sparkle.Messages;
  import cz.zcu.mre.sparkle.data.DataAgent;
  import cz.zcu.mre.sparkle.data.Storage;
  import cz.zcu.mre.sparkle.gui.mainForm.MainForm;
  import cz.zcu.mre.sparkle.gui.query.CustomTitledPane;
  import cz.zcu.mre.sparkle.gui.query.QueryFormPane;
  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.subselect.SubSelectPane;
  import cz.zcu.mre.sparkle.tools.Saveable;
  import cz.zcu.mre.sparkle.tools.SparqlParser;
  import cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserNode;
  import cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserWhereClauseWalker;
  import javafx.application.Platform;
  import javafx.collections.FXCollections;
  import javafx.collections.ListChangeListener;
  import javafx.collections.ObservableList;
  import javafx.collections.ObservableSet;
  import javafx.scene.Node;
  import org.antlr.v4.runtime.tree.ParseTree;
  import org.apache.jena.query.QuerySolution;
  import org.w3c.dom.Element;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  import java.util.Stack;
  import static cz.zcu.mre.sparkle.gui.query.QueryFormPane.QUERY_PARTS.*;
  import static cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserUtils.getTreeChild;
  
  /**
   * Kontroler panelu s dotazem typu SELECT.
   *
   * @author Jan Smucr
   * @author Klara Hlavacova
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public final class SelectQueryFormPane
          extends QueryFormPane<QuerySolution> {
  
      public static final String XML_QUERY_TYPE_VALUE = "select"; //$NON-NLS-1$
  
      private List<Object> queryFormParts;
  
      private ObservableSet<String> selectClauseVariables;
      private ObservableSet<String> whereClauseVariables;
      private ObservableSet<String> orderByClauseVariables;
      private ObservableSet<String> groupByClauseVariables;
      private ObservableSet<String> valuesClauseVariables;
  
      public SelectQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
              String paneType) {
          super(mainForm, dataAgent, localStorage, paneType);
      }
  
      //query loading from file (.sqf|.txt)
      public SelectQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
              final Object root, String paneType) throws LoadException {
  
          super(mainForm, dataAgent, localStorage, root, paneType);
      }
  
      @Override
      public final void load(final Object root) throws LoadException {
          selectClauseVariables = FXCollections.observableSet();
          whereClauseVariables = FXCollections.observableSet();
          orderByClauseVariables = FXCollections.observableSet();
          groupByClauseVariables = FXCollections.observableSet();
          valuesClauseVariables = FXCollections.observableSet();
  
          initializeQueryFormParts();
          addVariablesCollectors();
          addPartsTitles();
  
         loadForm(root);
 
         // Sledování změn v jednotlivých klauzulích
         watch((((SelectClauseBasePane) getPane(FIRST_CLAUSE))));
         addWatches();
 
         // Listener checks not actual selected variables in {@link SelectVarPane}. It starts after loading of all.
         Platform.runLater(() -> getNetVariables().addListener((ListChangeListener.Change<? extends String> c) -> ((SelectClauseBasePane) getPane(FIRST_CLAUSE)).removeVariableLabels()));
     }
 
     /**
      * Nacte formular.
      *
      * @param root rodicovsky element
      * @throws LoadException
      */
     private void loadForm(Object root) throws LoadException {
         if (root == null) {
             // Výchozí stav nového dotazu
             ((WhereClausePane) getPane(WHERE_CLAUSE)).addTriple(null, true);
 
         } else if (root instanceof Element) {
             Element rootNode = (Element) root;
 
             // Načtení uloženého dotazu
             loadElement(rootNode, (((SelectClauseBasePane) getPane(FIRST_CLAUSE))));
             loadQueryPartsElements((Element) root, queryFormParts);
 
         } else if (root instanceof ParseTree) {
             setVariables((ParseTree) root);//TODO:3
         }
     }
 
     /**
      * Inicializace pole casti.
      */
     private void initializeQueryFormParts() {
         queryFormParts = new ArrayList<>();
 
         queryFormParts.add(new SelectClauseBasePane(this));
 
         queryFormParts.add(new FromClausePane(this));
         queryFormParts.add(new WhereClausePane(this));
         queryFormParts.add(new OrderByClausePane(this));
         queryFormParts.add(new GroupByClausePane(this));
         queryFormParts.add(new HavingClausePane(this));
         queryFormParts.add(new LimitOffsetClausePane());
         queryFormParts.add(new ValuesClausePane(this));
     }
 
     /**
      * Nastavi kolektory promennych.
      */
     private void addVariablesCollectors() {
         ((SelectClauseBasePane) getPane(FIRST_CLAUSE)).addVariablesCollector(
                 createCollector(selectClauseVariables, whereClauseVariables, groupByClauseVariables,
                         orderByClauseVariables, valuesClauseVariables));
 
         ((WhereClausePane) getPane(WHERE_CLAUSE)).addVariablesCollector(
                 createCollector(whereClauseVariables, groupByClauseVariables, orderByClauseVariables,
                         valuesClauseVariables));
 
         ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).addVariablesCollector(
                 createCollector(orderByClauseVariables, whereClauseVariables, groupByClauseVariables,
                         valuesClauseVariables));
 
         ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).addVariablesCollector(
                 createCollector(groupByClauseVariables, whereClauseVariables, orderByClauseVariables,
                         valuesClauseVariables));
 
         ((ValuesClausePane) getPane(VALUES_CLAUSE)).addVariablesCollector(
                 createCollector(valuesClauseVariables, whereClauseVariables, groupByClauseVariables,
                         orderByClauseVariables));
     }
 
     /**
      * Vrati panel ze seznamu casti formulare.
      *
      * @param paneType typ panelu
      *
      * @return panel ze seznamu casti formulare
      */
     private Object getPane(QUERY_PARTS paneType) {
         return getPane(queryFormParts, paneType);
     }
 
     /**
      * Titulky panelu.
      */
     private void addPartsTitles() {
         final ObservableList<Node> children = getChildren();
         addChild(children, "SELECT_QUERY_FRAGMENT", (SelectClauseBasePane) getPane(FIRST_CLAUSE));
         addTitlesPanes(children);
     }
 
     private void addTitlesPanes(ObservableList<Node> children) {
         addChild(children, "FROM_QUERY_FRAGMENT", (FromClausePane) getPane(FROM_CLAUSE));
         addChild(children, "WHERE_QUERY_FRAGMENT", (WhereClausePane) getPane(WHERE_CLAUSE));
         addChild(children, "GROUP_BY_QUERY_FRAGMENT", (GroupByClausePane) getPane(GROUP_BY_CLAUSE));
         addChild(children, "HAVING_QUERY_FRAGMENT", (HavingClausePane) getPane(HAVING_CLAUSE));
         addChild(children, "ORDER_BY_QUERY_FRAGMENT", (OrderByClausePane) getPane(ORDER_BY_CLAUSE));
         addChild(children, "MODIFIERS_QUERY_FRAGMENT", (LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE));
         addChild(children, "VALUES_QUERY_FRAGMENT", (ValuesClausePane) getPane(VALUES_CLAUSE));
     }
 
     /**
      * Vlozi {@code CustomTitledPane} do seznamu uzlu.
      *
      * @param children seznam uzlu
      * @param title titulek
      * @param content obsah (panel)
      */
     private void addChild(ObservableList<Node> children, final String title, final Node... content) {
         children.add(new CustomTitledPane(Messages.getString(title), content));
     }
 
     /**
      * Nastavení hlídání změn.
      */
     private void addWatches() {
         watch((FromClausePane) getPane(FROM_CLAUSE));
         watch((WhereClausePane) getPane(WHERE_CLAUSE));
         watch(((OrderByClausePane) getPane(ORDER_BY_CLAUSE)));
         watch(((GroupByClausePane) getPane(GROUP_BY_CLAUSE)));
         watch(((HavingClausePane) getPane(HAVING_CLAUSE)));
         watch(((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)));
         watch(((ValuesClausePane) getPane(VALUES_CLAUSE)));
     }
 
     @Override
     protected void setVariables(ParseTree root) throws LoadException {
         Stack<SparqlParserNode> nodeStack = new Stack<>(); // Current path in parse tree
         nodeStack.push(new SparqlParserNode(root));
         //TODO: 4
         while (!nodeStack.isEmpty()) {
             SparqlParserNode currentNode = nodeStack.pop();
             ParseTree nodeData = currentNode.getNodeData();
             if (nodeData instanceof SparqlParser.SelectClauseContext) { // Variables
                 ((SelectClauseBasePane) getPane(FIRST_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.DatasetClauseContext) { // From clause
                 ((FromClausePane) getPane(FROM_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.LimitClauseContext) { // Limit clause
                 ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.OffsetClauseContext) { // Offset clause
                 ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.OrderConditionContext) { // Order clause
                 ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.HavingConditionContext) { // Having clause
                 ((HavingClausePane) getPane(HAVING_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.GroupConditionContext) { // Group by clause
                 ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).load(nodeData);
 
             } else if (nodeData instanceof SparqlParser.WhereClauseContext) { // Where clause
                 new SparqlParserWhereClauseWalker(nodeData, ((WhereClausePane) getPane(WHERE_CLAUSE)))
                         .processWhereClauseDFS();
 
             } else if (nodeData instanceof SparqlParser.ValuesClauseContext) { // Values clause
                 ((ValuesClausePane) getPane(VALUES_CLAUSE)).load(nodeData);
 
             } else { // Uninsteresting node -> get next node
                 nodeStack.push(currentNode);
                 getTreeChild(currentNode, nodeStack);
             }
         }
     }
 
     @Override
     public final List<SubSelectPane> getSubSelectPanes() {
         return ((WhereClausePane) getPane(WHERE_CLAUSE)).getSubSelectPanes();
     }
 
     @Override
     public final ObservableList<String> getSortedVariables() {
 
         ObservableSet<String> variables = FXCollections.observableSet();
         variables.addAll(this.getNetVariables());
         ((WhereClausePane) getPane(WHERE_CLAUSE)).getSubSelectPanes().forEach((subSelectPane) -> variables.addAll(subSelectPane.getSubSelectQueryPane().getSelectedVariables()));
         return FXCollections.observableArrayList(variables).sorted(String.CASE_INSENSITIVE_ORDER);
     }
 
     @Override
     public final String getQueryPart() {
         return ((SelectClauseBasePane) getPane(FIRST_CLAUSE)).getQueryPart()
                 + ((FromClausePane) getPane(FROM_CLAUSE)).getQueryPart() + "WHERE " //$NON-NLS-1$
                 + ((WhereClausePane) getPane(WHERE_CLAUSE)).getQueryPart()
                 + ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).getQueryPart()
                 + ((HavingClausePane) getPane(HAVING_CLAUSE)).getQueryPart()
                 + ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).getQueryPart()
                 + ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).getQueryPart()
                 + ((ValuesClausePane) getPane(VALUES_CLAUSE)).getQueryPart() + " "; //$NON-NLS-1$
     }
 
     @Override
     public final Set<String> getPrefixesUsed(final boolean appendDelimiter) {
         final Set<String> result = ((WhereClausePane) getPane(WHERE_CLAUSE)).getPrefixesUsed(appendDelimiter);
         result.addAll(((FromClausePane) getPane(FROM_CLAUSE)).getPrefixesUsed(appendDelimiter));
         result.addAll(((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).getPrefixesUsed(appendDelimiter));
         result.addAll(((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).getPrefixesUsed(appendDelimiter));
         result.addAll(((HavingClausePane) getPane(HAVING_CLAUSE)).getPrefixesUsed(appendDelimiter));
         result.addAll(((ValuesClausePane) getPane(VALUES_CLAUSE)).getPrefixesUsed(appendDelimiter));
         return result;
     }
 
     @Override
     public final void save(final Element root) {
         Saveable.defaultSave(root, ((SelectClauseBasePane) getPane(FIRST_CLAUSE)),
                 ((FromClausePane) getPane(FROM_CLAUSE)), ((WhereClausePane) getPane(WHERE_CLAUSE)),
                 ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)),
                 ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)),
                 ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)),
                 ((HavingClausePane) getPane(HAVING_CLAUSE)), ((ValuesClausePane) getPane(VALUES_CLAUSE)));
     }
 
     @Override
     protected final String getXMLQueryType() {
         return XML_QUERY_TYPE_VALUE;
     }
 
 }