package com.randomnoun.common.jexl.eval;
   
   /* (c) 2013 randomnoun. All Rights Reserved. This work is licensed under a
    * BSD Simplified License. (http://www.randomnoun.com/bsd-simplified.html)
    */
   
   import java.math.BigDecimal;
   import java.text.*; // for SimpleDateFormat & friends
   import java.util.*;
  
  
  
  import org.apache.log4j.Logger;
  
  import com.randomnoun.common.Text;
  import com.randomnoun.common.jexl.ast.*;
  import com.randomnoun.common.jexl.visitor.*;
  
  
  /**
   * This class traverses (and evaluates) an expression AST graph. It
   * traverses the AST in depth-first order (by extending the ObjectDepthFirst
   * visitor class generated by jtb). This class implements the
   * 'Visitor' design pattern.
   *
   * <p>Each visit() method in this class takes two parameters, the
   * first being the node being visited, and the second contains
   * an EvalContext object containing the variables and functions which can
   * be referenced within the expression. The visitor (i.e. this class) is then
   * passed to it's children nodes using the nodes' accept() method (generated
   * by jtb).
   *
   * <p>Variables can be any wrappered primitive type (e.g. Long, Integer, ...),
   * although mathematical evaluation (+, -, /, etc) are currently only
   * implemented for Doubles and Longs.
   *
   * <p>This class can be considered thread-safe, since it holds no instance-wide state.
   * (All methods that require access to a EvalContext have it passed in through a
   * method parameter). i.e. many threads may use the same Evaluator instance to
   * evaluate different expressions.
   *
   * <p>NB: In the javadocs below, "lhs" refers to the left-hand-side value of any binary
   * operation, and "rhs" refers to the right-hand-side value; e.g. in "3 + 4",
   * the lhs is "3", the rhs is "4" and the op is "+".
   * 
   * @author knoxg
   */
  public class Evaluator
      extends GJDepthFirst<Object, EvalContext> {
  
      // We used to create a variable with this name before executing any function calls 
  	// containing the Evaluator instance that is being used to evaluate the function. Not entirely sure why any more, so have commented it out.
      // public static final String VAR_EVALUATOR = ".evaluator";
  
  
      /** Logger instance for this class */
      Logger logger = Logger.getLogger(Evaluator.class);
  
      // could probably use generics these days
      // and I'm pretty sure these are in java.util.functions as well
      
      /** Binary operation interface; takes two parameters, returns a result. */
      interface BinaryOp {
          Object op(Object a, Object b);
      }
  
      /** A binary operation on two parameters whose types are guaranteed to be Long. */
      abstract class LongOp implements BinaryOp {
          public Object op(Object a, Object b) {
              long longA = ((Long) a).longValue();
              long longB = (b == null ? 0 : ((Long) b).longValue());
              return Long.valueOf(longOp(longA, longB));
          }
          abstract long longOp(long a, long b);
      }
  
      /** A binary operation on two parameters whose types are guaranteed to be Double. */
      abstract class DoubleOp implements BinaryOp {
          public Object op(Object a, Object b) {
              double doubleA = ((Double) a).doubleValue();
              double doubleB = (b == null ? 0 : ((Double) b).doubleValue());
              return Double.valueOf(doubleOp(doubleA, doubleB));
          }
          abstract double doubleOp(double a, double b);
      }
  
      /** Coerce parameter 'b' into a compatible type of parameter 'a', to be used in a
       *  binary math op. If 'b' can't be coerced into 'a', then throw an EvalException.
       *
       * @param a First binary op parameter (the type of which we are casting to)
       * @param b Second binary op parameter (the value we are casting)
       * @return The value of 'b', coerced to be the same type of value 'a'
       */
      public Object coerceType(Object a, Object b) {
      	// don't coerce nulls
      	if (a == null) { return null; }
  
          Class<? extends Object> clazz = a.getClass();
          if (b == null || clazz.isInstance(b)) { return b; }
 
         if (a instanceof Date) {
             if (b instanceof String) {
                 // convert string to date
                 DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
                 try {
                     return sdf.parse((String) b);
                 } catch (java.text.ParseException pe) {
                     throw new EvalException("Could not parse date '" + b + "': " + pe.getMessage());
                 }
             }
         }
 
         if (a instanceof Double) {
             if (b instanceof Number) {
                 return Double.valueOf(((Number) b).doubleValue());
             }
         }
 
         if (a instanceof Long) {
             if (b instanceof Number) {
                 return Long.valueOf(((Number) b).longValue());
             }
         }
 
 		if (a instanceof BigDecimal) {
 			if (b instanceof Number) {
 				// not sure if this keeps enough precision, but good enough for testing 
 				return new BigDecimal(((Number) b).toString());  
 			}
 		}
 
         throw new EvalException("cannot coerce " + b.getClass().getName() + " to " + clazz.getName());
     }
 
     /** Binary math operation. Takes two parameters, the name of the op (only used in
      * exception text), and BinaryOp classes for all supported types. (We only
      * support math operations on Longs and Doubles at the moment, should be easy to
      * add new types if required). If we were aiming for completeness, I'd implement
      * Short, Int, Byte, Char, BigInteger and BigDecimal.
      *
      * <p>The rhs of the expression is coerced into the type of the lhs.
      *
      * @param a lhs parameter
      * @param b rhs parameter
      * @param op name of op
      * @param longOp operation to perform if lhs is Long
      * @param doubleOp operation to perform if lhs in Double
      * @return the evaluated result of the op
      */
     public Object mathOp(Object a, Object b, String op, BinaryOp longOp, BinaryOp doubleOp) {
         b = coerceType(a, b);
 
         if (a instanceof Long) {
             return longOp.op(a, b);
         } else if (a instanceof Double) {
             return doubleOp.op(a, b);
         }
 
         throw new EvalException("'" + op + "' can only operator on numeric types (found '" + a + "' of type " + a.getClass().getName() + ")");
     }
 
     /** Evaluate a TopLevelExpression node. The PRE text in this javadoc corresponds to
      * the javacc expansion of this node; e.g. in expression.jj, the rule for TopLevelExpression
      * is
      *
      * <pre>
      * void TopLevelExpression():
      * {}
      * {
      *   Expression() <EOF>
      * }
      * </pre>
      *
      * <p>jtb then creates two fields in the TopLevelExpression object, "expression" (containing
      * the Expression() node) and "nodeToken" (containing the EOF token). This is documented
      * in the form below (this is included for all jtb-generated visit methods):
      *
      * <PRE>
      * expression -> Expression()
      * nodeToken -> &lt;EOF&gt;
      * </PRE>
      */
     public Object visit(TopLevelExpression n, EvalContext context) {
         return n.expression.accept(this, context);
     }
 
     /** Evaluate an Expression node.
      *
      * <PRE>
      * conditionalAndExpression -> ConditionalAndExpression()
      * nodeListOptional -> ( "||" ConditionalAndExpression() )*
      * </PRE>
      */
     public Object visit(Expression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
 
         lhs = n.conditionalAndExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
 
             if (!(lhs instanceof Boolean)) {
                 throw new EvalException("lhs must be boolean");
             }
 
             if (!(rhs instanceof Boolean)) {
                 throw new EvalException("rhs must be boolean");
             }
 
             // NB: performs short-cut evaluation 
             boolean result = ((Boolean) lhs).booleanValue() || ((Boolean) rhs).booleanValue();
 
             lhs = Boolean.valueOf(result);
         }
 
         return lhs;
     }
 
     /** Evaluate a ConditionalAndExpression node.
      *
      * <PRE>
      * equalityExpression -> EqualityExpression()
      * nodeListOptional -> ( "&&" EqualityExpression() )*
      * </PRE>
      */
     public Object visit(ConditionalAndExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
 
         lhs = n.equalityExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
             rhs = coerceType(lhs, rhs);
 
             if (!(lhs instanceof Boolean)) {
                 throw new EvalException("lhs must be boolean");
             }
 
             if (!(rhs instanceof Boolean)) {
                 throw new EvalException("rhs must be boolean");
             }
 
             // NB: performs short-cut evaluation 
             boolean result = ((Boolean) lhs).booleanValue() && ((Boolean) rhs).booleanValue();
 
             lhs = Boolean.valueOf(result);
         }
 
         return lhs;
     }
 
     /** Evaluate a EqualityExpression node.
      *
      * <PRE>
      * relationalExpression -> RelationalExpression()
      * nodeListOptional -> ( ( "==" | "!=" ) RelationalExpression() )*
      * </PRE>
      */
     @SuppressWarnings("unchecked")
 	public Object visit(EqualityExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
         // String[] ops = { "==", "!=" };
 
         lhs = n.relationalExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
             rhs = coerceType(lhs, rhs);
 
             if (!(lhs==null || lhs instanceof Comparable)) {
                 throw new EvalException("Cannot compare lhs");
             }
 
             if (!(rhs==null || rhs instanceof Comparable)) {
                 // this may not be required (only lhs needs to be comparable to run .compareTo)
                 throw new EvalException("Cannot compare rhs");
             }
 
             int which = ((NodeChoice) seq.elementAt(0)).which;
             
             // this may throw an IllegalStateException if they're not comparable after all
             int result = -1;
             try {
             	// perform null checks first (allow nulls in either lhs or rhs of equality check)
             	if (lhs==null) {
             		return (which==0) ? Boolean.valueOf(rhs==null) : Boolean.valueOf(rhs!=null);
             	} else if (rhs==null) {
 					return (which==0) ? Boolean.valueOf(lhs==null) : Boolean.valueOf(lhs!=null);
             	}
                 result = ((Comparable<Object>) lhs).compareTo(rhs);
             } catch (IllegalStateException ise) {
                 throw (EvalException) new EvalException("Cannot perform evaluation").initCause(ise);
             }
 
             // logger.debug("Running op '" + ops[which] + "' on lhs:" + lhs + ", rhs:" + rhs);
             switch (which) {
                 case 0: lhs = Boolean.valueOf(result == 0); break;
                 case 1: lhs = Boolean.valueOf(result != 0); break;
                 default:
                     throw new EvalException("Internal error - unexpected relational operation");
             }
         }
 
         return lhs;
     }
 
     /** Evaluate a RelationalExpression node.
      *
      * <PRE>
      * additiveExpression -> AdditiveExpression()
      * nodeListOptional -> ( ( "&lt;" | "&gt;" | "&lt;=" | "&gt;=" ) AdditiveExpression() )*
      * </PRE>
      */
     @SuppressWarnings("unchecked")
 	public Object visit(RelationalExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
         // String[] ops = { "<", ">", "<=", ">=" };
 
         lhs = n.additiveExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
             rhs = coerceType(lhs, rhs);
 
             if (!(lhs instanceof Comparable)) {
                 throw new EvalException("Cannot compare lhs (found type '" + lhs.getClass().getName() + "')");
             }
 
             if (!(rhs instanceof Comparable)) {
                 // this may not be required (only lhs needs to be comparable to run .compareTo)
                 throw new EvalException("Cannot compare rhs");
             }
 
             int which = ((NodeChoice) seq.elementAt(0)).which;
             int result = -1;
             try {
                 result = ((Comparable<Object>) lhs).compareTo(rhs);
             } catch (IllegalStateException ise) {
                 throw (EvalException) new EvalException("Cannot perform evaluation").initCause(ise);
             }
 
             // logger.debug("Running op '" + ops[which] + "' on lhs:" + lhs + ", rhs:" + rhs);
             switch (which) {
                 case 0: lhs = Boolean.valueOf(result < 0); break;
                 case 1: lhs = Boolean.valueOf(result > 0); break;
                 case 2: lhs = Boolean.valueOf(result <= 0); break;
                 case 3: lhs = Boolean.valueOf(result >= 0); break;
                 default:
                     throw new EvalException("Internal error - unexpected relational operation");
             }
         }
 
         return lhs;
     }
 
     /** Evaluate a AdditiveExpression node.
      *
      * <PRE>
      * multiplicativeExpression -> MultiplicativeExpression()
      * nodeListOptional -> ( ( "+" | "-" ) MultiplicativeExpression() )*
      * </PRE>
      */
     public Object visit(AdditiveExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
         // String[] ops = { "+", "-" };
 
         lhs = n.multiplicativeExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
 
             int which = ((NodeChoice) seq.elementAt(0)).which;
 
             // logger.debug("Running op '" + ops[which] + "' on lhs:" + lhs + ", rhs:" + rhs);
             switch (which) {
                 case 0:
                     if (lhs instanceof String) {
                         // String addition
                         lhs = ((String) lhs) + rhs.toString();
                     } else {
                         // Numeric addition
                         lhs = mathOp(lhs, rhs, "+", 
                           new LongOp() { public long longOp(long a, long b) { return a + b; } }, 
                           new DoubleOp() { public double doubleOp(double a, double b) { return a + b; } });
                     }
                     break;
                 case 1:
                     lhs = mathOp(lhs, rhs, "-", 
                       new LongOp() { public long longOp(long a, long b) { return a - b; } }, 
                       new DoubleOp() { public double doubleOp(double a, double b) { return a - b; } });
                     break;
                 default:
                     throw new EvalException("Internal error - unexpected additive operation");
             }
         }
 
         return lhs;
     }
 
     /** Evaluate a MultiplicativeExpression node.
      *
      * <PRE>
      * unaryExpression -> UnaryExpression()
      * nodeListOptional -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
      * </PRE>
      */
     public Object visit(MultiplicativeExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
         Object rhs;
         // String[] ops = { "*", "/", "%" };
 
         lhs = n.unaryExpression.accept(this, context);
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             rhs = seq.elementAt(1).accept(this, context);
 
             int which = ((NodeChoice) seq.elementAt(0)).which;
 
             // logger.debug("Running op '" + ops[which] + "' on lhs:" + lhs + ", rhs:" + rhs);
             switch (which) {
                 case 0:
                     lhs = mathOp(lhs, rhs, "*", 
                       new LongOp() { public long longOp(long a, long b) { return a * b; } }, 
                       new DoubleOp() { public double doubleOp(double a, double b) { return a * b; } });
                     break;
                 case 1:
                     lhs = mathOp(lhs, rhs, "/", 
                       new LongOp() { public long longOp(long a, long b) { return a / b; } }, 
                       new DoubleOp() { public double doubleOp(double a, double b) { return a / b; } });
                     break;
                 case 2:
                     lhs = mathOp(lhs, rhs, "%", 
                       new LongOp() { public long longOp(long a, long b) { return a % b; } }, 
                       new DoubleOp() { public double doubleOp(double a, double b) { return a % b; } });
                     break;
                 default:
                     throw new EvalException("Internal error - unexpected additive operation");
             }
         }
 
         return lhs;
     }
 
     /** Evaluate a UnaryExpression node.
      *
      * <PRE>
      * nodeChoice -> ( "~" | "!" | "-" ) UnaryExpression()
      *       | PrimaryExpression()
      * </PRE>
      */
     public Object visit(UnaryExpression n, EvalContext context) {
         NodeSequence seq;
         Object lhs;
 
         if (n.nodeChoice.which == 0) {
             seq = (NodeSequence) n.nodeChoice.choice;
 
             int which = ((NodeChoice) seq.elementAt(0)).which;
 
             // String op = ((NodeToken) ((NodeChoice) nl.nodes.get(0)).choice).tokenImage;
             switch (which) {
                 case 0:
                     // long rhs =  makeNumeric ( ((Node) nl.nodes.get(0)).accept(this, context) ); 
                     // return Long.valueOf(~rhs); 
                     throw new EvalException("~ not supported");
                 case 1:
                     lhs = seq.elementAt(1).accept(this, context);
                     if (!(lhs instanceof Boolean)) {
                         throw new EvalException("boolean type expected");
                     }
                     return Boolean.valueOf(!((Boolean) lhs).booleanValue());
                 case 2:
                     lhs = seq.elementAt(1).accept(this, context);
                     if (!(lhs instanceof Number)) {
                         throw new EvalException("numeric type expected");
                     }
                     return mathOp(lhs, null, "-", new 
                       LongOp() { public long longOp(long a, long b) { return -a; } }, 
                       new DoubleOp() { public double doubleOp(double a, double b) { return -a; } } );
                 default:
                     throw new EvalException("Internal error - unexpected unary operation");
             }
         } else {
             return n.nodeChoice.choice.accept(this, context);
         }
     }
 
     /** Evaluate a PrimaryExpression node.
      *
      * <PRE>
      * nodeChoice -> FunctionCall()
      *       | Name()
      *       | Literal()
      *       | "(" Expression() ")"
      * </PRE>
      */
     public Object visit(PrimaryExpression n, EvalContext context) {
         NodeSequence seq;
         int which = n.nodeChoice.which;
 
         switch (which) {
             case 0:
             case 1:
             case 2:
                 return n.nodeChoice.choice.accept(this, context);
             case 3:
                 seq = (NodeSequence) n.nodeChoice.choice;
                 Object obj = seq.elementAt(1).accept(this, context);
 
                 ;
 
                 return obj;
             default:
                 throw new EvalException("Internal parser error (PrimaryExpression)");
         }
     }
 
     /** Evaluate a Name node.
      *
      * <PRE>
      * nodeToken -> &lt;IDENTIFIER&gt;
      * nodeListOptional -> ( "." &lt;IDENTIFIER&gt; )*
      * </PRE>
      */
     public Object visit(Name n, EvalContext context) {
         EvalContext evalContext = (EvalContext) context;
         String varComponentName;
         String varBaseName = n.nodeToken.tokenImage;
 
         // logger.debug("Fetching var '" + varBaseName + "'");
         if (evalContext == null) {
             throw new EvalException("Cannot retrieve variable '" + varBaseName + "' with a null evalContext");
         }
 
         if (!evalContext.hasVariable(varBaseName)) {
             throw new EvalException("Unknown variable '" + varBaseName + "'");
         }
 
         Object value = evalContext.getVariable(varBaseName);
         NodeSequence seq;
 
         /*
            if (value == null) {
                logger.debug(" = null");
            } else {
                logger.debug(" = " + value.getClass().getName() + " with value '" + value + "'");
            }
          */
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             varComponentName = ((NodeToken) seq.elementAt(1)).tokenImage;
 
             //logger.debug("Fetching component '" + varComponentName + "' from var '" + varBaseName + "'");
             if (!evalContext.hasVariableComponent(value, varBaseName, varComponentName)) {
                 throw new EvalException("Unknown variable component '" + varComponentName + "' in variable '" + varBaseName + "'");
             }
 
             value = evalContext.getVariableComponent(value, varBaseName, varComponentName);
             varBaseName = varBaseName + "." + varComponentName;
         }
 
         return value;
     }
 
     /** Evaluate a FunctionCall node.
      *
      * <PRE>
      * nodeToken -> &lt;IDENTIFIER&gt;
      * arguments -> Arguments()
      * </PRE>
      */
     public Object visit(FunctionCall n, EvalContext context) {
         @SuppressWarnings("unchecked")
 		List<Object> argumentList = (List<Object>) n.arguments.accept(this, context);
         String functionName = n.nodeToken.tokenImage;
         EvalContext evalContext = (EvalContext) context;
         EvalFunction function = (EvalFunction) evalContext.getFunction(functionName);
         if (function == null) {
             throw new EvalException("Unknown function '" + functionName + "'");
         }
         /*
         if (evalContext.getVariable(VAR_EVALUATOR) != null) {
             evalContext.setVariable(VAR_EVALUATOR, this);
         }
         */
         return function.evaluate(functionName, evalContext, argumentList);
     }
 
     /** Evaluates an Arguments node
      *
      * <PRE>
      * nodeToken -> "("
      * nodeOptional -> [ ArgumentList() ]
      * nodeToken1 -> ")"
      * </PRE>
      */
     public Object visit(Arguments n, EvalContext context) {
         if (n.nodeOptional.present()) {
             return n.nodeOptional.accept(this, context);
         } else {
             return new ArrayList<Object>(0);
         }
     }
 
     /** Evaluate a ArgumentList node.
      *
      * <PRE>
      * expression -> Expression()
      * nodeListOptional -> ( "," Expression() )*
      * </PRE>
      */
     public Object visit(ArgumentList n, EvalContext context) {
         NodeSequence seq;
         List<Object> arguments = new ArrayList<Object>();
 
         arguments.add(n.expression.accept(this, context));
 
         for (Enumeration<Node> e = n.nodeListOptional.elements(); e.hasMoreElements();) {
             seq = (NodeSequence) e.nextElement();
             arguments.add(seq.elementAt(1).accept(this, context));
         }
 
         return arguments;
     }
 
     /** Evaluate a Literal node.
      *
      * <PRE>
      * nodeChoice -> &lt;INTEGER_LITERAL&gt;
      *       | &lt;FLOATING_POINT_LITERAL&gt;
      *       | &lt;CHARACTER_LITERAL&gt;
      *       | &lt;STRING_LITERAL&gt;
      *       | BooleanLiteral()
      *       | NullLiteral()
      * </PRE>
      *
      */
     public Object visit(Literal n, EvalContext context) {
         String token = null;
 
         if (n.nodeChoice.choice instanceof NodeToken) {
             token = ((NodeToken) n.nodeChoice.choice).tokenImage;
         }
 
         switch (n.nodeChoice.which) {
             case 0:
                 return Long.valueOf(token);
             case 1:
                 return Double.valueOf(token);
             case 2:
                 return Character.valueOf(token.charAt(1));
             case 3:
                 return Text.unescapeJava(token.substring(1, token.length() - 1));
         }
 
         // must be 'true', 'false', or 'null'
         return n.nodeChoice.accept(this, context);
     }
 
     /** Evaluate a BooleanLiteral node.
      *
      * <PRE>
      * nodeChoice -> "true"
      *       | "false"
      * </PRE>
      */
     public Object visit(BooleanLiteral n, EvalContext context) {
         if (n.nodeChoice.which == 0) {
             return Boolean.valueOf(true);
         } else {
             return Boolean.valueOf(false);
         }
     }
 
     /** Evaluate a NullLiteral node.
      *
      * <PRE>
      * nodeToken -> "null"
      * </PRE>
      */
     public Object visit(NullLiteral n, EvalContext context) {
         return null;
     }
 
     /** This is never executed (we do not evaluate tokens) */
     public Object visit(NodeToken n, EvalContext context) {
         return n.tokenImage;
     }
 }