/*
   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.Collection;
  import java.util.HashSet;
  import java.util.Set;
  
  /**
   * Collection operations node (contains, in).
   *
   * @author Rodrigo Ruiz
   * @version 1.0
   */
  public class CollectionNode extends EvalNode implements  FilterParserConstants {
    /**
     * Left operand.
     */
    private EvalValue lval;
  
    /**
     * Right operand.
     */
    private EvalValue rval;
  
    /**
     * Operation type.
     */
    private int op;
  
    /**
     * Creates a new instance.
     *
     * @param lval  The left operand
     * @param op    The operation
     * @param rval  The right operand
     */
    public CollectionNode(EvalValue lval, int op, EvalValue rval) {
      super(lval.getLinePos(), lval.getCharPos());
      this.lval = lval;
      this.rval = rval;
      this.op = op;
    }
  
    /**
     * {@inheritDoc}
     */
    @Override public boolean eval(Object src) throws EvalException {
      Object o1 = lval.getValue(src);
      Object o2 = rval.getValue(src);
  
      // Check nulls
      if (((o1 == null) && !(o2 instanceof Set))
        || ((o2 == null) && !(o1 instanceof Set))) {
        switch (op) {
          case CONTAINS:
          case IN:
            // continue executing code.
            break;
          case EQ:
            return o1 == o2;
          case NE:
            return o1 != o2;
          default:
            return false;
        }
      }
  
      Set<Object> s1 = toHashSet(o1);
      Set<Object> s2 = toHashSet(o2);
      Collection<Object> c1 = deref(s1, src);
      Collection<Object> c2 = deref(s2, src);
  
      switch (op) {
        case CONTAINS:
          return c1.containsAll(c2);
        case IN:
          return c2.containsAll(c1);
  
        case EQ:
          if ((s1 instanceof AllItemsHashSet) || (s2 instanceof AllItemsHashSet)) {
            return c1.equals(c2);
          } else {
            return operateOneByOne(s1, s2, c1, c2);
          }
       case NE:
         if ((s1 instanceof AllItemsHashSet) || (s2 instanceof AllItemsHashSet)) {
           return operateOneByOne(s1, s2, c1, c2);
         } else {
           return !c1.equals(c2);
         }
 
       default:
         return operateOneByOne(s1, s2, c1, c2);
     }
   }
 
   /**
    * Compare two sets element by element.
    * @param s1 First Set
    * @param s2 Second Set
    * @param c1 First Collection
    * @param c2 Second Collection
    * @return Result of comparison
    * @throws EvalException If error.
    */
   private boolean operateOneByOne(Set<Object> s1, Set<Object> s2,
     Collection<Object> c1, Collection<Object> c2) throws EvalException {
     boolean existsFalse = false;
     boolean existsTrue = false;
     Object[] list1 = c1.toArray();
     Object[] list2 = c2.toArray();
     if ((list1.length == 0) || (list2.length == 0)) {
       switch (op) {
         case EQ:
           return list1.length == list2.length;
         case LE:
           return list1.length <= list2.length;
         case GE:
           return list1.length >= list2.length;
         case NE:
           return list1.length != list2.length;
         case LT:
           return list1.length < list2.length;
         case GT:
           return list1.length > list2.length;
         default:
           return false;
       }
     }
     for (int i = 0; i < list1.length; i++) {
       for (int j = 0; j < list2.length; j++) {
         if (CompareNode.evaluateOperation(lval, rval, list1[i], op, list2[j])) {
           existsTrue = true;
         } else {
           existsFalse = true;
         }
       }
     }
     if ((s1 instanceof AllItemsHashSet) || (s2 instanceof AllItemsHashSet)) {
       return !existsFalse;
     } else {
       return existsTrue;
     }
   }
 
   /**
    * Converts any EvalValue contained in the set into its value.
    *
    * @param set  The set to process
    * @param src  The data source, for dynamic items
    * @return  A set containing no EvalValue instances
    * @throws EvalException If an error occurs getting dereferencing an item
    */
   private Set<Object> deref(Set<Object> set, Object src) throws EvalException {
     Set<Object> set2 = new HashSet<Object>();
     for (Object item : set) {
       if (item instanceof EvalValue) {
         item = ((EvalValue)item).getValue(src);
       }
       set2.add(normalize(item));
     }
     return set2;
   }
 
   /**
    * Gets a normalized version of the specified object. The "normalization" converts
    * compatible objects into comparable ones. For example, it will convert all integer
    * values to instances of Long, so comparisons and containment operations will not
    * fail.
    *
    * @param obj  The source object
    * @return  The converted object
    */
   private Object normalize(Object obj) {
     if (obj instanceof Integer || obj instanceof Short || obj instanceof Byte) {
       long longValue = ((Number)obj).longValue();
       return longValue;
     } else if (obj instanceof Float) {
       double doubleValue = ((Number)obj).doubleValue();
       return doubleValue;
     } else {
       return obj;
     }
   }
 
   /**
    * Converts an object into a set, if it is not yet.
    *
    * @param obj  The object to convert
    * @return  A set containing the object, or object items if it is an array
    *          or collection, or the object if it is already a set
    */
   @SuppressWarnings("unchecked")
   private HashSet<Object> toHashSet(Object obj) {
     if (obj == null) {
       HashSet<Object> hash = new AllItemsHashSet();
       hash.add(null);
       return hash;
     } else if (obj instanceof HashSet) {
       return (HashSet<Object>)obj;
     } else {
       HashSet<Object> set;
       if (obj.getClass().isArray()) {
         set = ArrayValue.arrayToHash(obj, ArrayValue.ArrayType.ALL_ITEMS);
       } else {
         set = new AnyItemsHashSet();
         set.add(obj);
       }
       return set;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public String toString() {
     String oper = tokenImage[op];
     if (oper.startsWith("\"")) {
       oper = oper.substring(1, oper.length() - 1);
     }
     return lval + " " + oper + " " + rval;
   }
 }