/*
   Copyright (C) 2004 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.beanfilter;
  
  import java.util.ArrayList;
  import java.util.BitSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.regex.PatternSyntaxException;
  
  /**
   * Comparison operation.
   *
   * @author Rodrigo Ruiz
   * @author Xmas
   * @version 1.0
   */
  public class CompareNode extends EvalNode implements FilterParserConstants {
  
    /**
     * The set of comparator operations.
     */
    private static final BitSet COMPARATORS = new BitSet();
  
    /**
     * Classes of Primitive Numbers.
     */
    private static final Set<Class<?>> PRIMITIVE_NUMBER_CLASSES = new HashSet<Class<?>>();
  
    /**
     * Allowed Operations.
     */
    private static final Map<Class<?>, Operation[]> LEFTRIGHTOPERANDS;
  
    static {
      COMPARATORS.set(EQ);
      COMPARATORS.set(NE);
      COMPARATORS.set(LT);
      COMPARATORS.set(LE);
      COMPARATORS.set(GT);
      COMPARATORS.set(GE);
      COMPARATORS.set(MATCHES);
      COMPARATORS.set(LIKE);
  
      LEFTRIGHTOPERANDS = new HashMap<Class<?>, Operation[]>();
  
      LEFTRIGHTOPERANDS.put(HashSet.class, new Operation[]{
        new Operation(HashSet.class, EQ, NE, CONTAINS, IN)
      });
      LEFTRIGHTOPERANDS.put(String.class, new Operation[] {
        new Operation(String.class, EQ, NE, GT, LT, GE, LE, MATCHES, LIKE),
        new Operation(List.class, IN)
      });
      LEFTRIGHTOPERANDS.put(HashSet.class, new Operation[]{
        new Operation(HashSet.class, EQ, NE, CONTAINS, IN)
      });
      LEFTRIGHTOPERANDS.put(Number.class, new Operation[] {
        new Operation(Number.class, EQ, NE, GT, LT, GE, LE),
        new Operation(List.class, IN)
      });
      LEFTRIGHTOPERANDS.put(Boolean.class, new Operation[] {
        new Operation(Boolean.class, EQ, NE),
        new Operation(boolean.class, EQ, NE),
        new Operation(List.class, IN)
      });
      LEFTRIGHTOPERANDS.put(boolean.class, new Operation[] {
        new Operation(Boolean.class, EQ, NE),
        new Operation(boolean.class, EQ, NE),
        new Operation(List.class, IN)
      });
  
      PRIMITIVE_NUMBER_CLASSES.add(int.class);
      PRIMITIVE_NUMBER_CLASSES.add(long.class);
      PRIMITIVE_NUMBER_CLASSES.add(float.class);
      PRIMITIVE_NUMBER_CLASSES.add(double.class);
      PRIMITIVE_NUMBER_CLASSES.add(short.class);
      PRIMITIVE_NUMBER_CLASSES.add(byte.class);
    }
  
    /**
     * Internal class used to encapsulate allowed Operations.
     * @author Xmas
    *
    */
   private static class Operation {
 
     /**
      * Right class.
      */
     final Class<?> right;
 
     /**
      * Allowed operations.
      */
     final List<Integer> operations;
 
     /**
      * Constructor.
      *
      * @param right Right class.
      * @param operators List of valid operands
      */
     public Operation(Class<?> right, int ... operators) {
       this.right = right;
       operations = new ArrayList<Integer>();
       for (int i = 0; i < operators.length; i++) {
         operations.add(operators[i]);
       }
     }
 
     /**
      * Check class and operand if is valid.
      * @param right Right class.
      * @param operation Operation to check.
      * @return If is Allowed.
      */
     public boolean isAllowed(Class<?> right, int operation) {
       return this.right.equals(right) && operations.contains(operation);
     }
 
   }
 
   /**
    * Left operand.
    */
   private EvalValue lval;
 
   /**
    * Right operand.
    */
   private EvalValue rval;
 
   /**
    * Operation.
    */
   private int op;
 
   /**
    * Creates a new instance.
    *
    * @param lval  Left operand
    * @param op    Operation
    * @param rval  Right operand
    * @param parentClass Parent Class
    * @throws EvalException If an error occurs
    */
   public CompareNode(EvalValue lval, int op, EvalValue rval, Class<?> parentClass)
     throws EvalException {
     super(lval.getLinePos(), lval.getCharPos());
     if (!COMPARATORS.get(op)) {
       String operation;
       try {
         operation = tokenImage[op];
       }  catch (IndexOutOfBoundsException e) {
         operation = "?";
       }
       Object[] eparams = { lval.getLinePos(), lval.getCharPos(), operation };
       throw new EvalException("FTR006", eparams);
     }
     this.lval = lval;
     this.rval = rval;
     this.op = op;
 
     checkSyntax(parentClass);
   }
 
   /**
    *
    * @param parentClass Parent Class
    * @throws EvalException If an error occurs
    */
   private void checkSyntax(Class<?> parentClass) throws EvalException {
     Class<?> lClass = lval.getClassValue(parentClass);
     Class<?> rClass = rval.getClassValue(parentClass);
 
     if (isNumber(lClass)) {
       lClass = Number.class;
     }
     if (isNumber(rClass)) {
       rClass = Number.class;
     }
 
     Operation[] operations = LEFTRIGHTOPERANDS.get(lClass);
 
     if (operations != null) {
       for (int i = 0; i < operations.length; i++) {
         Operation oper = operations[i];
         if (oper.isAllowed(rClass, this.op)) {
           return;
         }
       }
     } else {
       switch (op) {
         case EQ:
         case NE:
           if ((lClass != null) && (rClass != null) && !lClass.equals(rClass)) {
             // FTR008=The element {0} with type {1} at position [{2}, {3}], has a diff
             // type that the item {4} with type {5} at position [{6}, {7}]
             Object[] params = {
                 lval.toString(), lClass, lval.getLinePos(), lval.getCharPos(),
                 rval.toString(), rClass, rval.getLinePos(), rval.getCharPos()
             };
             throw new EvalException("FTR008", params);
           }
           break;
 
         default:
           // FTR006=Invalid operand {2} at position [{0}, {1}]
           String operation = "?";
           try {
             operation = tokenImage[op];
           }  catch (IndexOutOfBoundsException e) {
             // ignore this exception
           }
           Object[] params = { lval.getLinePos(), lval.getCharPos(), operation };
           throw new EvalException("FTR006", params);
       }
     }
   }
 
   /**
    * Class is a number instance.
    * @param number Class to check
    * @return true, if  class is a number instance
    */
   private static boolean isNumber(Class<?> number) {
     if (number == null) {
       return false;
     }
     if (Number.class.isAssignableFrom(number)) {
       return true;
     }
     return PRIMITIVE_NUMBER_CLASSES.contains(number);
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public boolean eval(Object src) throws EvalException {
     Object lobj = lval.getValue(src);
     Object robj = rval.getValue(src);
 
     if (lobj instanceof HashSet || robj instanceof HashSet) {
       CollectionNode tempNode = new CollectionNode(lval, op, rval);
       return tempNode.eval(src);
     }
 
     return evaluateOperation(this.lval, this.rval, lobj, this.op, robj);
   }
 
   /**
    * @param lval   Left EvalValue.
    * @param rval   Right EvalValue.
    * @param lobj  The left operand
    * @param op    Operation
    * @param robj  The right operand
    * @return If evaluation is passed.
    * @throws EvalException If error
    */
   public static boolean evaluateOperation(EvalValue lval, EvalValue rval,
     Object lobj, int op, Object robj) throws EvalException {
     switch (op) {
       case EQ:
         return eq(lobj, robj);
       case NE:
         return !eq(lobj, robj);
       case LE:
         return comp(lval, rval, lobj, robj, true, true);
       case LT:
         return comp(lval, rval, lobj, robj, true, false);
       case GT:
         return comp(lval, rval, lobj, robj, false, false);
       case GE:
         return comp(lval, rval, lobj, robj, false, true);
       case MATCHES:
         return match(lval, rval, lobj, robj);
       case LIKE:
         return like(lval, rval, lobj, robj);
       default:
         return false;
     }
   }
 
 
   /**
    * Gets the left value.
    *
    * @return  The left value
    */
   public EvalValue getLeftValue() {
     return lval;
   }
 
   /**
    * Gets the right value.
    *
    * @return  The right value
    */
   public EvalValue getRightValue() {
     return rval;
   }
 
   /**
    * Gets the operation of this node.
    *
    * @return  This node operation
    */
   public int getOp() {
     return op;
   }
 
   /**
    * Performs an "equals" operation.
    *
    * @param o1  The left operand
    * @param o2  The right operand
    * @return  <code>true</code> if both operands are equal
    */
   private static boolean eq(Object o1, Object o2) {
     if (o1 == null) {
       if (o2 == null) {
         return true;
       }
       return false;
     } else {
       if (o2 == null) {
         return false;
       } else {
         if (o1 instanceof Number && o2 instanceof Number) {
           return (isInt(o1) && isInt(o2))
                  ? ((Number)o1).longValue() == ((Number)o2).longValue()
                  : ((Number)o1).doubleValue() == ((Number)o2).doubleValue();
         } else {
           return o1.equals(o2);
         }
       }
     }
   }
 
   /**
    * Compares two operands. The result depends on the values of the sign and value flags.
    *
    * @param lval   Left EvalValue.
    * @param rval   Right EvalValue.
    * @param o1     The left operand
    * @param o2     The right operand
    * @param less   If true, it performs a "less than" operation; otherwise, it performs
    *               a "greater than" operation.
    * @param eq     If true, it performs a "less/greater than or equals" operation.
    *               If false, it will perform a "strictly less/greater than" operation
    * @return  true if the comparison is OK
    * @throws EvalException FTR006: The operands are not comparable
    */
   @SuppressWarnings("unchecked")
   private static boolean comp(EvalValue lval, EvalValue rval, Object o1, Object o2,
     boolean less, boolean eq) throws EvalException {
     // Sanity check.
     if (o1 == null || o2 == null) {
       return false;
     }
 
     int sign = (less) ? -1 : 1;
     int value = (eq) ? 0 : 1;
 
     if (o1 instanceof Number && o2 instanceof Number) {
       Number n1 = (Number)o1;
       Number n2 = (Number)o2;
       if (isInt(n1) && isInt(n2)) {
         long diff = n1.longValue() - n2.longValue();
         return (sign * diff) >= value;
       } else {
         double dif = n1.doubleValue() - n2.doubleValue();
         long diff = dif == 0.0 ? 0 : (dif > 0.0 ? sign : -sign);
         return diff >= value;
       }
     } else if (o1 instanceof Comparable && o1.getClass().equals(o2.getClass())) {
       int diff = ((Comparable)o1).compareTo(o2);
       return (sign * diff) >= value;
     }
     throw new EvalException("FTR006", lval.getLinePos(), lval.getCharPos(), "");
   }
 
   /**
    * Performs a matching operation between two string operands.
    *
    * @param lval   Left EvalValue.
    * @param rval   Right EvalValue.
    * @param o1  The left operand
    * @param o2  The right operand
    * @return  true if o1 matches o2
    * @throws EvalException FTR007:  Pattern syntax exception
    */
   private static boolean match(EvalValue lval, EvalValue rval, Object o1, Object o2)
     throws EvalException {
     // Sanity check.
     if (o1 == null || o2 == null) {
       return false;
     }
     String regex = o2.toString();
     try {
       return o1.toString().matches(regex);
     } catch (PatternSyntaxException e) {
       throw new EvalException("FTR007", rval.getLinePos(), rval.getCharPos(), regex);
     }
   }
 
   /**
    * Performs a 'like' operation.
    *
    * @param lval   Left EvalValue.
    * @param rval   Right EvalValue.
    * @param o1  The left operand
    * @param o2  The right operand
    * @return    true if o1 'is like' o2
    * @throws EvalException If an error occurs
    */
   private static boolean like(EvalValue lval, EvalValue rval, Object o1, Object o2)
     throws EvalException {
     // Sanity check.
     if (o1 == null || o2 == null) {
       return false;
     }
     StringBuffer sb = new StringBuffer();
     String src = o2.toString();
     for (int i = 0; i < src.length(); i++) {
       char c = src.charAt(i);
       switch (c) {
         case '.':
         case '\\':
           sb.append('\\');
           break;
         case '?':
         case '*':
           sb.append('.');
         default:
           break;
       }
       sb.append(c);
     }
     return match(lval, rval, o1, sb);
   }
 
   /**
    * Gets if obj is an integer type (Integer, Long, Short or Byte).
    *
    * @param obj  The object
    * @return <code>true</code> if it is an integer type
    */
   private static boolean isInt(Object obj) {
     if (obj == null) {
       return false;
     }
     return isNumber(obj.getClass());
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public String toString() {
     String oper = tokenImage[op];
     if (oper.startsWith("\"")) {
       oper = oper.substring(1, oper.length() - 1);
     }
     return lval + " " + oper + " " + rval;
   }
 }