/*
   Copyright (C) 2006 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.lang.reflect.Array;
  import java.util.HashSet;
  
  /**
   * Collection operations node (contains, in).
   *
   * @author Xmas
   * @version 1.0
   */
  public final class ArrayValue extends EvalValue {
  
    /**
     * Forms to access to this array.
     */
    public enum ArrayType { INDEXED, ALL_ITEMS, ANY_ITEMS };
  
    /**
     * Array Type.
     */
    private ArrayType arrayType;
  
    /**
     * Left operand.
     */
    private EvalValue value;
  
    /**
     * If Array if Indexed, then contains position of this array.
     */
    private Integer index = null;
  
    /**
     * Creates a new instance.
     *
     * @param token  The token
     * @param value  The value
     * @param parentClass Parent Class
     * @param arrayIndexType    The array index
     * @throws EvalException If an error occurs
     */
    public ArrayValue(Token token, EvalValue value, Token arrayIndexType,
      Class<?> parentClass) throws EvalException {
      super(token.beginLine, token.beginColumn);
      // Check if is array
      Class<?> valueClass = value.getClassValue(parentClass);
      if (!valueClass.isArray()) {
        // FTR010=The variable at position [{0}, {1}] is not an array.
        throw new EvalException("FTR010", token.beginLine, token.beginColumn);
      }
      // Set data
      this.value = value;
      switch (arrayIndexType.kind) {
        case FilterParserConstants.NUMBER:
          this.index = Integer.parseInt(arrayIndexType.image);
          if (this.index < 0) {
            // FTR009
            // In the array at position [{0}, {1}], the index {2} is out of bounds.
            throw new EvalException("FTR009", token.beginLine, token.beginColumn, index);
          }
          this.arrayType = ArrayType.INDEXED;
          break;
        case FilterParserConstants.ALLITEMS:
          this.arrayType = ArrayType.ALL_ITEMS;
          break;
        case FilterParserConstants.ANYITEMS:
          this.arrayType = ArrayType.ANY_ITEMS;
          break;
        default:
          throw new EvalException("UNK000", "Unknown array indexation type "
              + arrayIndexType.kind);
      }
    }
  
    /**
     * {@inheritDoc}
     */
    @Override public Object getValue(Object src) throws EvalException {
      Object myarray = value.getValue(src);
      if (myarray == null) {
        return null;
      }
     if (index == null) {
       HashSet<Object> hash;
       hash = arrayToHash(myarray, this.arrayType);
       return hash;
     } else {
       int count = Array.getLength(myarray);
       int i = index.intValue();
       if ((i < 0) || (i >= count)) {
         // We suppose that arrays are infinite. The values not defined has value null.
         return null;
       }
       Object obj = Array.get(myarray, i);
       return processObject(obj);
     }
   }
 
   /**
    * Convert an object array to HashSet.
    *
    * @param myarray Array to convert
    * @param arrayType type of returned hash: AND or OR
    * @return HashSet with the content of array.
    */
   public static HashSet<Object> arrayToHash(Object myarray, ArrayType arrayType) {
     HashSet<Object> hash;
     int count = Array.getLength(myarray);
     if (arrayType == ArrayType.ALL_ITEMS) {
       hash = new AllItemsHashSet(count);
     } else {
       hash = new AnyItemsHashSet(count);
     }
     for (int i = 0; i < count; i++) {
       hash.add(processObject(Array.get(myarray, i)));
     }
     return hash;
   }
 
   /**
    * Convert objects Number to Long or Double.
    * @param obj Original Object
    * @return <code>obj</code> if <code>obj</code> is not a number.
    *   Otherwise return the representation in Long or Double of <code>obj</code>.
    */
   private static Object processObject(Object obj) {
     if (obj == null) {
       return null;
     }
     if (obj instanceof Number) {
       if (obj instanceof Long || obj instanceof Integer
            || obj instanceof Short || obj instanceof Byte) {
         return ((Number)obj).longValue();
       } else {
         return ((Number)obj).doubleValue();
       }
     }
     return obj;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public String toString() {
     return value + "[" + ((index == null) ? "*" : index.toString()) + "]";
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public Class<?> getClassValue(Class<?> parentClass) throws EvalException {
     Class<?> valueClass = value.getClassValue(parentClass);
     return valueClass.getComponentType();
   }
 }