/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.jexl2;
  
  import java.util.regex.Pattern;
  import org.apache.commons.jexl2.parser.ASTAdditiveNode;
  import org.apache.commons.jexl2.parser.ASTAdditiveOperator;
  import org.apache.commons.jexl2.parser.ASTAmbiguous;
  import org.apache.commons.jexl2.parser.ASTAndNode;
  import org.apache.commons.jexl2.parser.ASTArrayAccess;
  import org.apache.commons.jexl2.parser.ASTArrayLiteral;
  import org.apache.commons.jexl2.parser.ASTAssignment;
  import org.apache.commons.jexl2.parser.ASTBitwiseAndNode;
  import org.apache.commons.jexl2.parser.ASTBitwiseComplNode;
  import org.apache.commons.jexl2.parser.ASTBitwiseOrNode;
  import org.apache.commons.jexl2.parser.ASTBitwiseXorNode;
  import org.apache.commons.jexl2.parser.ASTBlock;
  import org.apache.commons.jexl2.parser.ASTConstructorNode;
  import org.apache.commons.jexl2.parser.ASTDivNode;
  import org.apache.commons.jexl2.parser.ASTEQNode;
  import org.apache.commons.jexl2.parser.ASTERNode;
  import org.apache.commons.jexl2.parser.ASTEmptyFunction;
  import org.apache.commons.jexl2.parser.ASTFalseNode;
  import org.apache.commons.jexl2.parser.ASTForeachStatement;
  import org.apache.commons.jexl2.parser.ASTFunctionNode;
  import org.apache.commons.jexl2.parser.ASTGENode;
  import org.apache.commons.jexl2.parser.ASTGTNode;
  import org.apache.commons.jexl2.parser.ASTIdentifier;
  import org.apache.commons.jexl2.parser.ASTIfStatement;
  import org.apache.commons.jexl2.parser.ASTJexlScript;
  import org.apache.commons.jexl2.parser.ASTLENode;
  import org.apache.commons.jexl2.parser.ASTLTNode;
  import org.apache.commons.jexl2.parser.ASTMapEntry;
  import org.apache.commons.jexl2.parser.ASTMapLiteral;
  import org.apache.commons.jexl2.parser.ASTMethodNode;
  import org.apache.commons.jexl2.parser.ASTModNode;
  import org.apache.commons.jexl2.parser.ASTMulNode;
  import org.apache.commons.jexl2.parser.ASTNENode;
  import org.apache.commons.jexl2.parser.ASTNRNode;
  import org.apache.commons.jexl2.parser.ASTNotNode;
  import org.apache.commons.jexl2.parser.ASTNullLiteral;
  import org.apache.commons.jexl2.parser.ASTNumberLiteral;
  import org.apache.commons.jexl2.parser.ASTOrNode;
  import org.apache.commons.jexl2.parser.ASTReference;
  import org.apache.commons.jexl2.parser.ASTReferenceExpression;
  import org.apache.commons.jexl2.parser.ASTReturnStatement;
  import org.apache.commons.jexl2.parser.ASTSizeFunction;
  import org.apache.commons.jexl2.parser.ASTSizeMethod;
  import org.apache.commons.jexl2.parser.ASTStringLiteral;
  import org.apache.commons.jexl2.parser.ASTTernaryNode;
  import org.apache.commons.jexl2.parser.ASTTrueNode;
  import org.apache.commons.jexl2.parser.ASTUnaryMinusNode;
  import org.apache.commons.jexl2.parser.ASTVar;
  import org.apache.commons.jexl2.parser.ASTWhileStatement;
  import org.apache.commons.jexl2.parser.JexlNode;
  
  import org.apache.commons.jexl2.parser.ParserVisitor;
  import org.apache.commons.jexl2.parser.SimpleNode;
  
  /**
   * Helps pinpoint the cause of problems in expressions that fail during evaluation.
   * <p>
   * It rebuilds an expression string from the tree and the start/end offsets of the cause
   * in that string.
   * </p>
   * This implies that exceptions during evaluation do allways carry the node that's causing
   * the error.
   * @since 2.0
   */
  final class Debugger implements ParserVisitor {
      /** The builder to compose messages. */
      private final StringBuilder builder;
      /** The cause of the issue to debug. */
      private JexlNode cause;
      /** The starting character location offset of the cause in the builder. */
      private int start;
      /** The ending character location offset of the cause in the builder. */
      private int end;
  
      /**
       * Creates a Debugger.
       */
      Debugger() {
          builder = new StringBuilder();
          cause = null;
         start = 0;
         end = 0;
     }
 
     /**
      * Seeks the location of an error cause (a node) in an expression.
      * @param node the node to debug
      * @return true if the cause was located, false otherwise
      */
     public boolean debug(JexlNode node) {
         start = 0;
         end = 0;
         if (node != null) {
             builder.setLength(0);
             this.cause = node;
             // make arg cause become the root cause
             JexlNode root = node;
             while (root.jjtGetParent() != null) {
                 root = root.jjtGetParent();
             }
             root.jjtAccept(this, null);
         }
         return end > 0;
     }
 
     /**
      * @return The rebuilt expression
      */
     public String data() {
         return builder.toString();
     }
     
     
     /**
      * Rebuilds an expression from a Jexl node.
      * @param node the node to rebuilt from
      * @return the rebuilt expression
      * @since 2.1
      */
     public String data(JexlNode node) {
         start = 0;
         end = 0;
         if (node != null) {
             builder.setLength(0);
             this.cause = node;
             node.jjtAccept(this, null);
         }
         return builder.toString();
     }
 
     /**
      * @return The starting offset location of the cause in the expression
      */
     public int start() {
         return start;
     }
 
     /**
      * @return The end offset location of the cause in the expression
      */
     public int end() {
         return end;
     }
 
     /**
      * Checks if a child node is the cause to debug &amp; adds its representation
      * to the rebuilt expression.
      * @param node the child node
      * @param data visitor pattern argument
      * @return visitor pattern value
      */
     private Object accept(JexlNode node, Object data) {
         if (node == cause) {
             start = builder.length();
         }
         Object value = node.jjtAccept(this, data);
         if (node == cause) {
             end = builder.length();
         }
         return value;
     }
 
     /**
      * Adds a statement node to the rebuilt expression.
      * @param child the child node
      * @param data visitor pattern argument
      * @return visitor pattern value
      */
     private Object acceptStatement(JexlNode child, Object data) {
         Object value = accept(child, data);
         // blocks, if, for & while dont need a ';' at end
         if (child instanceof ASTBlock
                 || child instanceof ASTIfStatement
                 || child instanceof ASTForeachStatement
                 || child instanceof ASTWhileStatement) {
             return value;
         }
         builder.append(";");
         return value;
     }
 
     /**
      * Checks if a terminal node is the the cause to debug &amp; adds its
      * representation to the rebuilt expression.
      * @param node the child node
      * @param image the child node token image (may be null)
      * @param data visitor pattern argument
      * @return visitor pattern value
      */
     private Object check(JexlNode node, String image, Object data) {
         if (node == cause) {
             start = builder.length();
         }
         if (image != null) {
             builder.append(image);
         } else {
             builder.append(node.toString());
         }
         if (node == cause) {
             end = builder.length();
         }
         return data;
     }
 
     /**
      * Checks if the children of a node using infix notation is the cause to debug,
      * adds their representation to the rebuilt expression.
      * @param node the child node
      * @param infix the child node token
      * @param paren whether the child should be parenthesized
      * @param data visitor pattern argument
      * @return visitor pattern value
      */
     private Object infixChildren(JexlNode node, String infix, boolean paren, Object data) {
         int num = node.jjtGetNumChildren(); //child.jjtGetNumChildren() > 1;
         if (paren) {
             builder.append("(");
         }
         for (int i = 0; i < num; ++i) {
             if (i > 0) {
                 builder.append(infix);
             }
             accept(node.jjtGetChild(i), data);
         }
         if (paren) {
             builder.append(")");
         }
         return data;
     }
 
     /**
      * Checks if the child of a node using prefix notation is the cause to debug,
      * adds their representation to the rebuilt expression.
      * @param node the node
      * @param prefix the node token
      * @param data visitor pattern argument
      * @return visitor pattern value
      */
     private Object prefixChild(JexlNode node, String prefix, Object data) {
         boolean paren = node.jjtGetChild(0).jjtGetNumChildren() > 1;
         builder.append(prefix);
         if (paren) {
             builder.append("(");
         }
         accept(node.jjtGetChild(0), data);
         if (paren) {
             builder.append(")");
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTAdditiveNode node, Object data) {
         // need parenthesis if not in operator precedence order
         boolean paren = node.jjtGetParent() instanceof ASTMulNode
                 || node.jjtGetParent() instanceof ASTDivNode
                 || node.jjtGetParent() instanceof ASTModNode;
         int num = node.jjtGetNumChildren(); //child.jjtGetNumChildren() > 1;
         if (paren) {
             builder.append("(");
         }
         accept(node.jjtGetChild(0), data);
         for (int i = 1; i < num; ++i) {
             accept(node.jjtGetChild(i), data);
         }
         if (paren) {
             builder.append(")");
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTAdditiveOperator node, Object data) {
         builder.append(' ');
         builder.append(node.image);
         builder.append(' ');
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTAndNode node, Object data) {
         return infixChildren(node, " && ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTArrayAccess node, Object data) {
         accept(node.jjtGetChild(0), data);
         int num = node.jjtGetNumChildren();
         for (int i = 1; i < num; ++i) {
             builder.append("[");
             accept(node.jjtGetChild(i), data);
             builder.append("]");
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTArrayLiteral node, Object data) {
         int num = node.jjtGetNumChildren();
         builder.append("[ ");
         if (num > 0) {
             accept(node.jjtGetChild(0), data);
             for (int i = 1; i < num; ++i) {
                 builder.append(", ");
                 accept(node.jjtGetChild(i), data);
             }
         }
         builder.append(" ]");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTAssignment node, Object data) {
         return infixChildren(node, " = ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTBitwiseAndNode node, Object data) {
         return infixChildren(node, " & ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTBitwiseComplNode node, Object data) {
         return prefixChild(node, "~", data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTBitwiseOrNode node, Object data) {
         boolean paren = node.jjtGetParent() instanceof ASTBitwiseAndNode;
         return infixChildren(node, " | ", paren, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTBitwiseXorNode node, Object data) {
         boolean paren = node.jjtGetParent() instanceof ASTBitwiseAndNode;
         return infixChildren(node, " ^ ", paren, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTBlock node, Object data) {
         builder.append("{ ");
         int num = node.jjtGetNumChildren();
         for (int i = 0; i < num; ++i) {
             JexlNode child = node.jjtGetChild(i);
             acceptStatement(child, data);
         }
         builder.append(" }");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTDivNode node, Object data) {
         return infixChildren(node, " / ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTEmptyFunction node, Object data) {
         builder.append("empty(");
         accept(node.jjtGetChild(0), data);
         builder.append(")");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTEQNode node, Object data) {
         return infixChildren(node, " == ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTERNode node, Object data) {
         return infixChildren(node, " =~ ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTFalseNode node, Object data) {
         return check(node, "false", data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTForeachStatement node, Object data) {
         builder.append("for(");
         accept(node.jjtGetChild(0), data);
         builder.append(" : ");
         accept(node.jjtGetChild(1), data);
         builder.append(") ");
         if (node.jjtGetNumChildren() > 2) {
             acceptStatement(node.jjtGetChild(2), data);
         } else {
             builder.append(';');
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTGENode node, Object data) {
         return infixChildren(node, " >= ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTGTNode node, Object data) {
         return infixChildren(node, " > ", false, data);
     }
 
     /** Checks identifiers that contain space, quote, double-quotes or backspace. */
     private static final Pattern QUOTED_IDENTIFIER = Pattern.compile("['\"\\s\\\\]");
     
     /** {@inheritDoc} */
     public Object visit(ASTIdentifier node, Object data) {
         String image = node.image;
         if (QUOTED_IDENTIFIER.matcher(image).find()) {
             // quote it
             image = "'" + node.image.replace("'", "\\'") + "'";
         }
         return check(node, image, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTIfStatement node, Object data) {
         builder.append("if (");
         accept(node.jjtGetChild(0), data);
         builder.append(") ");
         if (node.jjtGetNumChildren() > 1) {
             acceptStatement(node.jjtGetChild(1), data);
             if (node.jjtGetNumChildren() > 2) {
                 builder.append(" else ");
                 acceptStatement(node.jjtGetChild(2), data);
             } else {
                 builder.append(';');
             }
         } else {
             builder.append(';');
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTNumberLiteral node, Object data) {
         return check(node, node.image, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTJexlScript node, Object data) {
         int num = node.jjtGetNumChildren();
         for (int i = 0; i < num; ++i) {
             JexlNode child = node.jjtGetChild(i);
             acceptStatement(child, data);
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTLENode node, Object data) {
         return infixChildren(node, " <= ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTLTNode node, Object data) {
         return infixChildren(node, " < ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTMapEntry node, Object data) {
         accept(node.jjtGetChild(0), data);
         builder.append(" : ");
         accept(node.jjtGetChild(1), data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTMapLiteral node, Object data) {
         int num = node.jjtGetNumChildren();
         builder.append("{ ");
         if (num > 0) {
             accept(node.jjtGetChild(0), data);
             for (int i = 1; i < num; ++i) {
                 builder.append(", ");
                 accept(node.jjtGetChild(i), data);
             }
         } else {
             builder.append(':');
         }
         builder.append(" }");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTConstructorNode node, Object data) {
         int num = node.jjtGetNumChildren();
         builder.append("new ");
         builder.append("(");
         accept(node.jjtGetChild(0), data);
         for (int i = 1; i < num; ++i) {
             builder.append(", ");
             accept(node.jjtGetChild(i), data);
         }
         builder.append(")");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTFunctionNode node, Object data) {
         int num = node.jjtGetNumChildren();
         accept(node.jjtGetChild(0), data);
         builder.append(":");
         accept(node.jjtGetChild(1), data);
         builder.append("(");
         for (int i = 2; i < num; ++i) {
             if (i > 2) {
                 builder.append(", ");
             }
             accept(node.jjtGetChild(i), data);
         }
         builder.append(")");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTMethodNode node, Object data) {
         int num = node.jjtGetNumChildren();
         accept(node.jjtGetChild(0), data);
         builder.append("(");
         for (int i = 1; i < num; ++i) {
             if (i > 1) {
                 builder.append(", ");
             }
             accept(node.jjtGetChild(i), data);
         }
         builder.append(")");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTModNode node, Object data) {
         return infixChildren(node, " % ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTMulNode node, Object data) {
         return infixChildren(node, " * ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTNENode node, Object data) {
         return infixChildren(node, " != ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTNRNode node, Object data) {
         return infixChildren(node, " !~ ", false, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTNotNode node, Object data) {
         builder.append("!");
         accept(node.jjtGetChild(0), data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTNullLiteral node, Object data) {
         check(node, "null", data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTOrNode node, Object data) {
         // need parenthesis if not in operator precedence order
         boolean paren = node.jjtGetParent() instanceof ASTAndNode;
         return infixChildren(node, " || ", paren, data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTReference node, Object data) {
         int num = node.jjtGetNumChildren();
         accept(node.jjtGetChild(0), data);
         for (int i = 1; i < num; ++i) {
             builder.append(".");
             accept(node.jjtGetChild(i), data);
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTReferenceExpression node, Object data) {
         JexlNode first = node.jjtGetChild(0);
         builder.append('(');
         accept(first, data);
         builder.append(')');
         int num = node.jjtGetNumChildren();
         for (int i = 1; i < num; ++i) {
             builder.append("[");
             accept(node.jjtGetChild(i), data);
             builder.append("]");
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTReturnStatement node, Object data) {
         builder.append("return ");
         accept(node.jjtGetChild(0), data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTSizeFunction node, Object data) {
         builder.append("size(");
         accept(node.jjtGetChild(0), data);
         builder.append(")");
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTSizeMethod node, Object data) {
         check(node, "size()", data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTStringLiteral node, Object data) {
         String img = node.image.replace("'", "\\'");
         return check(node, "'" + img + "'", data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTTernaryNode node, Object data) {
         accept(node.jjtGetChild(0), data);
         if (node.jjtGetNumChildren() > 2) {
             builder.append("? ");
             accept(node.jjtGetChild(1), data);
             builder.append(" : ");
             accept(node.jjtGetChild(2), data);
         } else {
             builder.append("?:");
             accept(node.jjtGetChild(1), data);
 
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTTrueNode node, Object data) {
         check(node, "true", data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTUnaryMinusNode node, Object data) {
         return prefixChild(node, "-", data);
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTVar node, Object data) {
         builder.append("var ");
         check(node, node.image, data);
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTWhileStatement node, Object data) {
         builder.append("while (");
         accept(node.jjtGetChild(0), data);
         builder.append(") ");
         if (node.jjtGetNumChildren() > 1) {
             acceptStatement(node.jjtGetChild(1), data);
         } else {
             builder.append(';');
         }
         return data;
     }
 
     /** {@inheritDoc} */
     public Object visit(SimpleNode node, Object data) {
         throw new UnsupportedOperationException("unexpected type of node");
     }
 
     /** {@inheritDoc} */
     public Object visit(ASTAmbiguous node, Object data) {
         throw new UnsupportedOperationException("unexpected type of node");
     }
 }