/*
    * 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.tools.sparqlParser;
  
  import cz.zcu.mre.sparkle.gui.query.modifiers.GroupGraphPatternPane;
  import cz.zcu.mre.sparkle.gui.query.triplePane.TriplePane;
  import cz.zcu.mre.sparkle.tools.Saveable.LoadException;
  import cz.zcu.mre.sparkle.tools.SparqlParser;
  import org.antlr.v4.runtime.tree.ParseTree;
  import java.util.List;
  import java.util.Stack;
  import static cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserUtils.getTreeChild;
  
  /**
   * Instance of this class walks through where part of query (it's used during
   * query loading from text file).
   *
   * @author Josef Kazak
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class SparqlParserWhereClauseWalker {
  
      private final ParseTree root;
      private final GroupGraphPatternPane basePane;
  
      public SparqlParserWhereClauseWalker(ParseTree root, GroupGraphPatternPane basePane) {
          this.root = root;
          this.basePane = basePane;
      }
  
      /**
       * Walks through where clause of query (it saved in ParseTree). Walking is
       * DFS way.
       *
       * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException on load.
       */
      public void processWhereClauseDFS() throws LoadException {
          Stack<GroupGraphPatternPane> groupGraphStack = new Stack<>(); //stack of query groups
          groupGraphStack.push(this.basePane);
          Stack<SparqlParserNode> nodeStack = new Stack<>(); //current path in parse tree
          nodeStack.push(new SparqlParserNode(this.root));
  
          while (!nodeStack.isEmpty()) {
              SparqlParserNode currentNode = nodeStack.peek();
              ParseTree nodeData = currentNode.getNodeData();
  
              if (nodeData instanceof SparqlParser.TriplesBlockContext) { //triples
                  loadTriplesBlock(nodeStack, nodeData, groupGraphStack.peek());
  
              } else if ((nodeData instanceof SparqlParser.GroupGraphPatternContext
                      && ((SparqlParser.GroupGraphPatternContext) nodeData).subSelect() == null)
                      || (nodeData instanceof SparqlParser.TriplesTemplateContext
                      && nodeData.getParent() instanceof SparqlParser.QuadsNotTriplesContext)) { //groups
  
                  processGroupGraph(nodeData, currentNode, groupGraphStack, nodeStack);
  
              } else if (nodeData instanceof SparqlParser.ExpressionContext) {
                  ParseTree parentNode = nodeData.getParent();
  
                  if (parentNode instanceof SparqlParser.ConstraintContext) { //filters
                      processFilter(nodeData.getText(), groupGraphStack, nodeStack);
  
                  } else if (parentNode instanceof SparqlParser.BuiltInCallContext) {
                      processFilter(parentNode.getText(), groupGraphStack, nodeStack);
  
                  } else {
                      getTreeChild(currentNode, nodeStack);
                  }
  
              } else if (nodeData instanceof SparqlParser.InlineDataContext) {
                  groupGraphStack.peek().addValuesPane().load(nodeData);
                  nodeStack.pop();
  
              } else if (nodeData instanceof SparqlParser.RegexExpressionContext) { //can be more "expression" in a regex => this
                  processFilter(nodeData.getText(), groupGraphStack, nodeStack);
  
              } else if (nodeData instanceof SparqlParser.TriplesSameSubjectContext) { //vars in construct query and in QuadData
                  ParseTree parentNode = nodeData.getParent();
  
                  if (parentNode instanceof SparqlParser.ConstructTriplesContext) {
                      obtainConstructTriples(nodeStack, parentNode, groupGraphStack.peek());
                      nodeStack.pop();
 
                 } else {
                     loadTriplesBlock(nodeStack, nodeData, groupGraphStack.peek());
                 }
             } else if (nodeData instanceof SparqlParser.SubSelectContext
                     && nodeStack.size() > 1) { //root in SUBQUERY is SparqlParserContextHelp.SubSelectContext
 
                 processSubSelect(nodeData, groupGraphStack, nodeStack);
 
             } else if (nodeData instanceof SparqlParser.BindContext) {
                 groupGraphStack.peek().addBind().load(nodeData);
                 nodeStack.pop();
 
             } else { //uninsteresting node -> getting next node
                 getTreeChild(currentNode, nodeStack);
 
             }
         }
     }
 
     /**
      * It decides on treatment of group graph (eg. {?a ?b ?c}) when relevant
      * node was found.
      *
      * @param currentNodeData current ParseTree node of where clause
      * @param currentNode wrapper of currentNodeData
      * @param groupGraphStack contains "group graph deep" of query
      * @param stack shows current position in tree of where clause
      *
      * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException
      */
     private void processGroupGraph(ParseTree currentNodeData, SparqlParserNode currentNode,
             Stack<GroupGraphPatternPane> groupGraphStack, Stack<SparqlParserNode> stack) throws LoadException {
 
         ParseTree parentNode = currentNodeData.getParent();
         if (!(parentNode instanceof SparqlParser.WhereClauseContext)) {
 
             if (parentNode instanceof SparqlParser.GroupOrUnionGraphPatternContext) {
                 stack.pop();
                 SparqlParserNode parentGraphNode = stack.peek();
                 stack.push(currentNode);
 
                 if (parentNode.getChildCount() > 1 && parentGraphNode.notExistsUnvisitedNode()) {
                     processGraphPattern(currentNodeData, currentNode, groupGraphStack, stack);
                 } else {
                     processGraphPattern(null, currentNode, groupGraphStack, stack);
                 }
 
             } else {
                 processGraphPattern(currentNodeData, currentNode, groupGraphStack, stack);
             }
 
         } else {
             getTreeChild(currentNode, stack);
         }
     }
 
     /**
      * It walks through construct clause of query.
      *
      * @param stack shows current position in tree of where clause.
      * @param nodeData current ParseTree node of where clause.
      * @param groupGraphPattern "group graph deep" of query.
      *
      * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException
      */
     private void obtainConstructTriples(Stack<SparqlParserNode> stack, ParseTree nodeData,
             GroupGraphPatternPane groupGraphPattern) throws LoadException {
         Stack<SparqlParserNode> constructNodeStack = new Stack<>(); // More triples in construct
         constructNodeStack.push(new SparqlParserNode(nodeData));
 
         while (!constructNodeStack.isEmpty()) {
             SparqlParserNode constructCurrentNode = constructNodeStack.peek();
             ParseTree constructNodeData = constructCurrentNode.getNodeData();
             if (constructNodeData instanceof SparqlParser.TriplesSameSubjectContext) { // Triples
                 loadTriplesBlock(constructNodeStack, constructNodeData, groupGraphPattern);
             } else { // Uninsteresting node -> getting next node
                 getTreeChild(constructCurrentNode, constructNodeStack);
             }
         }
 
         stack.pop();
     }
 
     /**
      * Method sets obtained filters.
      *
      * @param filterText filter expression
      * @param groupGraphStack contains "group graph deep" of query
      * @param nodeStack shows current position in tree of where clause
      */
     private void processFilter(String filterText, Stack<GroupGraphPatternPane> groupGraphStack,
             Stack<SparqlParserNode> nodeStack) throws LoadException {
 
         groupGraphStack.peek().loadFilter(filterText);
         nodeStack.pop();
     }
 
     /**
      * Method adds new SUBSELECT.
      *
      * @param nodeData SUBSELECT root node
      * @param groupGraphStack contains "group graph deep" of query
      * @param nodeStack shows current position in tree of where clause
      */
     private void processSubSelect(ParseTree nodeData, Stack<GroupGraphPatternPane> groupGraphStack,
             Stack<SparqlParserNode> nodeStack) throws LoadException {
 
         groupGraphStack.peek().loadSubSelect(nodeData);
         nodeStack.pop();
     }
 
     /**
      * It creates new GroupGraphPatternPane (if not exists).
      *
      * @param currentNodeData current ParseTree node of where clause
      * @param node wrapper of currentNodeData
      * @param groupGraphStack contains "group graph deep" of query
      * @param stack shows current position in tree of where clause
      *
      * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException
      */
     private void processGraphPattern(ParseTree currentNodeData, SparqlParserNode node,
             Stack<GroupGraphPatternPane> groupGraphStack, Stack<SparqlParserNode> stack) throws LoadException {
 
         if (node.getVisitedNodeState()) {
             if (node.notExistsUnvisitedNode()) {
                 groupGraphStack.pop();
             }
         } else {
             GroupGraphPatternPane groupGraph = groupGraphStack.peek().addGroupGraphPatternPane();
             groupGraph.load(currentNodeData);
             groupGraphStack.push(groupGraph);
         }
 
         getTreeChild(node, stack);
     }
 
     /**
      * Method loads triples and subtriples.
      *
      * @param stack shows current position in tree of where clause
      * @param nodeData current ParseTree node of where clause
      * @param pane shows triple position in query
      *
      * @throws cz.zcu.mre.sparkle.tools.Saveable.LoadException
      */
     private void loadTriplesBlock(Stack<SparqlParserNode> stack, ParseTree nodeData, GroupGraphPatternPane pane)
             throws LoadException {
 
         SparqlParserTriplesWalker triplesWalker = new SparqlParserTriplesWalker(nodeData);
         triplesWalker.visitBlock();
         List<SparqlParserTriple> tripleList = triplesWalker.getObtainedTriples();
         TriplePane tp = null;
 
         for (SparqlParserTriple triple : tripleList) {
             if (triple.isSubTriple()) {
                 if (tp != null) {
                     tp.addSubTriple(false).load(triple);
                 }
             } else {
                 tp = pane.addTriple(null, false);
                 tp.load(triple);
             }
         }
 
         stack.pop();
     }
 }