/*
    * 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.delete;
  
  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.GroupGraphPatternPane;
  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.collections.FXCollections;
  import javafx.collections.ObservableList;
  import javafx.collections.ObservableSet;
  import javafx.scene.Node;
  import org.antlr.v4.runtime.tree.ParseTree;
  import org.w3c.dom.Element;
  import java.util.*;
  import static cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserUtils.getTreeChild;
  
  /**
   * The panel controller for a DELETE query.
   *
   * @author Josef Kazak
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public final class DeleteQueryFormPane
          extends QueryFormPane<Boolean> {
  
      public static final String XML_QUERY_TYPE_VALUE = "delete"; //$NON-NLS-1$
  
      private GroupGraphPatternPane deleteClausePane;
  
      public DeleteQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
              String paneType) {
  
          super(mainForm, dataAgent, localStorage, paneType);
      }
  
      public DeleteQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
              final Object root, String paneType)
              throws Saveable.LoadException {
  
          super(mainForm, dataAgent, localStorage, root, paneType);
      }
  
      @Override
      public final void load(final Object root) throws Saveable.LoadException {
          ObservableSet<String> deleteClauseVariables = FXCollections.observableSet();
  
          deleteClausePane = new DeleteClausePane(this);
          deleteClausePane.addVariablesCollector(createCollector(deleteClauseVariables));
  
          final ObservableList<Node> children = getChildren();
          children.add(new CustomTitledPane(Messages.getString("DELETE_QUERY_FRAGMENT"), deleteClausePane)); //$NON-NLS-1$
  
          if (root != null) {
              if (root instanceof Element) {
                  // Loading of a saved query
                  Element rootNode = (Element) root;
                  loadElement(rootNode, deleteClausePane);
              } else if (root instanceof ParseTree) {
                  setVariables((ParseTree) root);
              }
          }
  
          watch(deleteClausePane);
      }
  
      @Override
      protected void setVariables(ParseTree root) throws Saveable.LoadException {
          Stack<SparqlParserNode> nodeStack = new Stack<>(); //current path in parse tree
          nodeStack.push(new SparqlParserNode(root));
  
          while (!nodeStack.isEmpty()) {
              SparqlParserNode currentNode = nodeStack.pop();
              ParseTree nodeData = currentNode.getNodeData();
 
             if (nodeData instanceof SparqlParser.QuadDataContext) { //where clause
                 new SparqlParserWhereClauseWalker(nodeData, deleteClausePane)
                         .processWhereClauseDFS();
             } else { //uninsteresting node -> get next node
                 nodeStack.push(currentNode);
                 getTreeChild(currentNode, nodeStack);
             }
         }
     }
 
     @Override
     public final String getQueryPart() {
         final StringBuilder sb = new StringBuilder();
         String deleteClausePaneValue = deleteClausePane.getQueryPart();
         sb.append("DELETE DATA "); //$NON-NLS-1$
 
         if (!deleteClausePaneValue.startsWith("{")) { //$NON-NLS-1$
             sb.append("{ "); //$NON-NLS-1$
         }
         sb.append(deleteClausePaneValue);
         if (!deleteClausePaneValue.startsWith("{")) { //$NON-NLS-1$
             sb.append("}"); //$NON-NLS-1$
         }
         return sb.toString();
     }
 
     @Override
     public final List<SubSelectPane> getSubSelectPanes() {
         return Collections.emptyList();
     }
 
     @Override
     public final Set<String> getPrefixesUsed(final boolean appendDelimiter) {
         return deleteClausePane.getPrefixesUsed(appendDelimiter);
     }
 
     @Override
     public final void save(final Element root) {
         Saveable.defaultSave(root, deleteClausePane);
     }
 
     @Override
     protected final String getXMLQueryType() {
         return XML_QUERY_TYPE_VALUE;
     }
 
 }