package org.andromda.translation.ocl.validation;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Random;
  import java.util.Set;
  import java.util.TreeSet;
  import org.apache.commons.collections.Bag;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.Predicate;
  import org.apache.commons.collections.SetUtils;
  import org.apache.commons.collections.Transformer;
  import org.apache.commons.collections.bag.HashBag;
  import org.apache.commons.lang.StringUtils;
  
  /**
   * Used to translated OCL collection expressions to their corresponding Java collection expressions.
   */
  public final class OCLCollections
  {
      /**
       * Counts the number of occurrences of the argument item in the source collection.
       * @param collection
       * @param item
       * @return CollectionUtils.cardinality(item, collection)
       */
      public static int count(
              final Collection collection,
              Object item)
      {
          return collection == null ? 0 : CollectionUtils.cardinality(item, collection);
      }
  
      /**
       * Return true if the object is not an element of the collection, false otherwise.
       * @param collection
       * @param item
       * @return !collection.contains(item
       */
      public static boolean excludes(
              final Collection collection,
              final Object item)
      {
          return collection == null || !collection.contains(item);
      }
  
      /**
       * Returns true if all elements of the parameter collection are not present in the current collection, false
       * otherwise.
       * @param collection
       * @param items
       * @return excludesAll
       */
      public static boolean excludesAll(
              final Collection collection,
              final Collection items)
      {
          boolean excludesAll = true;
          for (final Iterator iterator = items.iterator(); iterator.hasNext();)
          {
              final Object object = iterator.next();
              if (!excludes(collection, object))
              {
                  excludesAll = false;
                  break;
              }
          }
          return excludesAll;
      }
  
      /**
       * Returns true if the object is an element of the collection, false otherwise.
       * @param collection
       * @param item
       * @return collection.contains(item)
       */
      public static boolean includes(
              final Collection collection,
              final Object item)
      {
          return collection != null && collection.contains(item);
      }
  
      /**
       * Returns true if all elements of the parameter collection are present in the current collection, false otherwise.
       * @param collection
       * @param items
       * @return collection.containsAll(items)
       */
      public static boolean includesAll(
              final Collection collection,
              final Collection items)
      {
          return collection != null && collection.containsAll(items);
     }
 
     /**
      * Returns true if the collection contains no elements, false otherwise.
      * @param collection
      * @return collection.isEmpty()
      */
     public static boolean isEmpty(final Collection collection)
     {
         return (collection == null) || (collection.isEmpty());
     }
 
     /**
      * Returns true if the argument is <code>null</code>, false otherwise.
      * @param object
      * @return isEmpty
      */
     public static boolean isEmpty(final Object object)
     {
         boolean isEmpty = object == null;
         if (!isEmpty)
         {
             if (object instanceof Collection)
             {
                 isEmpty = ((Collection) object).isEmpty();
             }
             else if (object instanceof String)
             {
                 isEmpty = isEmpty((String) object);
             }
             else if (object != null && object.getClass().isArray())
             {
                 isEmpty = ((Object[]) object).length == 0;
             }
         }
         return isEmpty;
     }
 
     /**
      * Returns true if the argument is either <code>null</code> or only contains whitespace characters, false
      * otherwise.
      * @param string
      * @return isBlank(string)
      */
     public static boolean isEmpty(final String string)
     {
         return StringUtils.isBlank(string);
     }
 
     /**
      * Returns true if the collection contains one or more elements, false otherwise.
      * @param collection
      * @return isEmpty(collection)
      */
     public static boolean notEmpty(final Collection collection)
     {
         return (collection != null) && !isEmpty(collection);
     }
 
     /**
      * Returns true if the argument is not <code>null</code>, false otherwise.
      * @param object
      * @return notEmpty
      */
     public static boolean notEmpty(final Object object)
     {
         boolean notEmpty = object != null;
         if (notEmpty)
         {
             if (object instanceof Collection)
             {
                 notEmpty = !((Collection) object).isEmpty();
             }
             else if (object instanceof String)
             {
                 notEmpty = notEmpty((String) object);
             }
             else if (object != null && object.getClass().isArray())
             {
                 notEmpty = ((Object[]) object).length > 0;
             }
         }
         return notEmpty;
     }
 
     /**
      * Returns true if the argument is neither <code>null</code> nor only contains whitespace characters, false
      * otherwise.
      * @param string
      * @return isNotBlank(string)
      */
     public static boolean notEmpty(final String string)
     {
         return StringUtils.isNotBlank(string);
     }
 
     /**
      * Checks the instance of the <code>object</code> and makes sure its a Collection, if the object is a collection the
      * size is checked and returned, if its NOT a collection, 0 is returned.
      *
      * @param object the object to check.
      * @return the size of the collection
      */
     public static int size(final Object object)
     {
         int size = 0;
         if (object != null)
         {
             if (object instanceof Collection)
             {
                 size = size((Collection) object);
             } else if (object.getClass().isArray())
             {
                 size = ((Object[]) object).length;
             }
         }
         return size;
     }
 
     /**
      * Returns the number of elements in the collection.
      * @param collection
      * @return collection.size()
      */
     public static int size(final Collection collection)
     {
         int size = 0;
         if (collection != null)
         {
             size = collection.size();
         }
         return size;
     }
 
     /**
      * Returns the sum of all the elements in the collection. Every element must extend Number or this method
      * will throw an exception.
      *
      * @param collection a collection containing only classes extending Number
      * @return the sum of all the elements in the collection
      */
     public static double sum(final Object collection)
     {
         double sum = 0;
         if (collection != null)
         {
             if (collection instanceof Collection)
             {
                 // TODO Fix infinite loop
                 sum = sum(collection);
             }
             else if (collection.getClass().isArray())
             {
                 sum = sum(Arrays.asList((Object[]) collection));
             }
         }
         return sum;
     }
 
     /**
      * Returns the sum of all the element in the collection. Every element must extend Number or this method
      * will throw an exception.
      *
      * @param collection a collection containing only classes extending Number
      * @return the sum of all the elements in the collection
      */
     public static double sum(final Collection collection)
     {
         double sum = 0;
         if (collection != null && !collection.isEmpty())
         {
             for (final Iterator iterator = collection.iterator(); iterator.hasNext();)
             {
                 Object object = iterator.next();
                 if (object instanceof Number)
                 {
                     sum += ((Number) object).doubleValue();
                 } else
                 {
                     throw new UnsupportedOperationException(
                             "In order to calculate the sum of a collection\'s elements " +
                                     "all of them must extend Number, found: " + object.getClass().getName());
                 }
             }
         }
         return sum;
     }
 
     /**
      * Appends the item to the list.
      * @param list
      * @param item
      * @return true if the operation was a success
      */
     public static boolean append(
             final List list,
             final Object item)
     {
         return list == null ? false : list.add(item);
     }
 
     /**
      * Insert the item into the first position of the list.
      * @param list
      * @param item
      * @return the element previously at the first position
      */
     public static Object prepend(
             final List list,
             final Object item)
     {
         return list.set(0, item);
     }
 
     /**
      * Appends the item to the bag.
      * @param collection
      * @param item
      * @return true if the operation was a success
      */
     public static boolean append(
             final Bag collection,
             final Object item)
     {
         return collection == null ? false : collection.add(item);
     }
 
     /**
      * Returns the argument as a bag.
      * @param collection
      * @return new HashBag(collection)
      */
     public static Bag asBag(final Collection collection)
     {
         return collection == null ? new HashBag() : new HashBag(collection);
     }
 
     /**
      * Returns the argument as an ordered set.
      * @param collection
      * @return SetUtils.orderedSet(new TreeSet(collection))
      */
     public static Set asOrderedSet(final Collection collection)
     {
         return collection == null ? Collections.emptySet() : SetUtils.orderedSet(new TreeSet(collection));
     }
 
     /**
      * Returns the argument as a list.
      * @param collection
      * @return new ArrayList(collection)
      */
     public static List asSequence(final Collection collection)
     {
         return collection == null ? Collections.emptyList() : new ArrayList(collection);
     }
 
     /**
      * Returns the argument as a set.
      * @param collection
      * @return new HashSet(collection)
      */
     public static Set asSet(final Collection collection)
     {
         return collection == null ? Collections.emptySet() : new HashSet(collection);
     }
 
     /**
      * Returns the element at the specified index in the argument list.
      * @param list
      * @param index
      * @return list.get(index)
      */
     public static Object at(
             final List list,
             final int index)
     {
         return list == null ? null : list.get(index);
     }
 
     /**
      * Removes all occurrences of the item in the source collection.
      * @param collection
      * @param item
      * @return true if one or more elements were removed
      */
     public static boolean excluding(
             final Collection collection,
             final Object item)
     {
         return collection == null ? false : collection.remove(item);
     }
 
     /**
      * Adds the item to the list
      * @param collection
      * @param item
      * @return true if the element was added
      */
     public static boolean including(
             final Collection collection,
             final Object item)
     {
         return collection == null ? false : collection.add(item);
     }
 
     /**
      * Recursively flattens this collection, this method returns a Collection containing no nested Collection
      * instances.
      * @param collection
      * @return flattenedCollection.addAll(flatten((Collection) object))
      */
     public static Collection flatten(final Collection collection)
     {
         final Collection flattenedCollection = new ArrayList();
         for (final Iterator iterator = collection.iterator(); iterator.hasNext();)
         {
             final Object object = iterator.next();
             if (object instanceof Collection)
             {
                 flattenedCollection.addAll(flatten((Collection) object));
             }
             else
             {
                 flattenedCollection.add(object);
             }
         }
 
         return flattenedCollection;
     }
 
     /**
      * Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not
      * contain this element. More formally, returns the lowest index i such that (o == null ? get(i) = =null :
      * o.equals(get(i))), or -1 if there is no such index.
      * @param collection
      * @param item
      * @return collection.indexOf(item)
      */
     public static int indexOf(
             final List collection,
             final Object item)
     {
         return collection == null ? -1 : collection.indexOf(item);
     }
 
     /**
      * Insert the item at the specified index into the collection.
      * @param collection
      * @param index
      * @param item
      */
     public static void insertAt(
             final List collection,
             int index,
             Object item)
     {
         collection.add(index, item);
     }
 
     /**
      * Returns the collection of elements common in both argument collections.
      * @param first
      * @param second
      * @return CollectionUtils.intersection(first, second)
      */
     public static Collection intersection(
             final Collection first,
             final Collection second)
     {
         return CollectionUtils.intersection(first, second);
     }
 
     /**
      * Returns the union of both collections into a single collection.
      * @param first
      * @param second
      * @return CollectionUtils.union(first, second)
      */
     public static Collection union(
             final Collection first,
             final Collection second)
     {
         return CollectionUtils.union(first, second);
     }
 
     /**
      * Returns the last element in the collection.
      *
      * @param object the collection or single instance which will be converted to a collection.
      * @return the last object of the collection or the object itself if the object is not a collection instance (or
      *         null if the object is null or an empty collection).
      */
     public static Object last(final Object object)
     {
         Object last = null;
         final List list = objectToList(object);
         if (!list.isEmpty())
         {
             last = list.get(list.size() - 1);
         }
         return last;
     }
 
     /**
      * Returns the first element in the collection.
      *
      * @param object the collection or single instance which will be converted to a collection.
      * @return the first object of the collection or the object itself if the object is not a collection instance (or
      *         null if the object is null or an empty collection).
      */
     public static Object first(final Object object)
     {
         Object first = null;
         final List list = objectToList(object);
         if (!list.isEmpty())
         {
             first = list.get(0);
         }
         return first;
     }
 
     /**
      * Returns those element that are contained in only one of both collections.
      * @param first
      * @param second
      * @return CollectionUtils.disjunction(first, second)
      */
     public static Collection symmetricDifference(
             final Collection first,
             final Collection second)
     {
         return CollectionUtils.disjunction(first, second);
     }
 
     /**
      * TODO: implement
      * @param collection
      * @return UnsupportedOperationException
      */
     public static Set subOrderedSet(final Set collection)
     {
         throw new UnsupportedOperationException(OCLCollections.class.getName() + ".subOrderedSet");
     }
 
     /**
      * TODO: implement
      * @param collection
      * @return UnsupportedOperationException
      */
     public static List subSequence(final List collection)
     {
         throw new UnsupportedOperationException(OCLCollections.class.getName() + ".subSequence");
     }
 
     /**
      * Returns a random element from the collection for which the argument expression evaluates true.
      * @param collection
      * @param predicate
      * @return selectedElements.get(random.nextInt(selectedElements.size())
      */
     public static Object any(
             final Collection collection,
             final Predicate predicate)
     {
         final List selectedElements = new ArrayList(select(collection, predicate));
         final Random random = new Random(System.currentTimeMillis());
         return selectedElements.isEmpty() ? null : selectedElements.get(random.nextInt(selectedElements.size()));
     }
 
     /**
      * Returns the collection of Objects that results from executing the transformer on each individual element in the
      * source collection.
      * @param collection
      * @param transformer
      * @return CollectionUtils.collect(collection, transformer)
      */
     public static Collection collect(
             final Collection collection,
             final Transformer transformer)
     {
         return CollectionUtils.collect(collection, transformer);
     }
 
     /**
      * TODO: implement
      * @param collection
      * @return UnsupportedOperationException
      */
     public static Collection collectNested(final Collection collection)
     {
         throw new UnsupportedOperationException(OCLCollections.class.getName() + ".collectNested");
     }
 
     /**
      * Returns true if a predicate is true for at least one element of a collection. <p/>A null collection or predicate
      * returns false.
      * @param collection
      * @param predicate
      * @return CollectionUtils.exists(collection, predicate)
      */
     public static boolean exists(
             final Collection collection,
             final Predicate predicate)
     {
         return CollectionUtils.exists(collection, predicate);
     }
 
     /**
      * Returns true if a predicate is true for at least one element of a collection. <p/>A null collection or predicate
      * returns false.
      * @param collection
      * @param predicate
      * @return exists((Collection) collection, predicate)
      */
     public static boolean exists(
             final Object collection,
             final Predicate predicate)
     {
         return collection instanceof Collection ? exists((Collection) collection, predicate) : false;
     }
 
     /**
      * <p/>
      * Executes every <code>predicate</code> for the given collectoin, if one evaluates to <code>false</code> this
      * operation returns <code>false</code>, otherwise <code>true</code> is returned. </p> If the input collection or
      * closure is null <code>false</code> is returned.
      * @param collection
      * @param predicate
      * @return true if every evaluated predicate returns true, false otherwise.
      */
     public static boolean forAll(
             final Collection collection,
             final Predicate predicate)
     {
         boolean valid = collection != null;
         if (valid && collection != null)
         {
             for (final Iterator iterator = collection.iterator(); iterator.hasNext();)
             {
                 final Object object = iterator.next();
                 valid = predicate.evaluate(object);
                 if (!valid)
                 {
                     break;
                 }
             }
         }
         return valid;
     }
 
     /**
      * <p/>
      * Executes every <code>predicate</code> for the given collection, if one evaluates to <code>false</code> this
      * operation returns <code>false</code>, otherwise <code>true</code> is returned. </p> If the input collection or
      * closure is null <code>false</code> is returned.
      * @param collection
      * @param predicate
      *
      * @return true if every evaluated predicate returns true, false otherwise.
      */
     public static boolean forAll(
             final Object collection,
             final Predicate predicate)
     {
         boolean valid = false;
         if (collection instanceof Collection)
         {
             valid = forAll((Collection) collection, predicate);
         }
         return valid;
     }
 
     /**
      * Returns <code>true</code> if the result of executing the <code>transformer</code> has a unique value for each
      * element in the source collection.
      * @param collection
      * @param transformer
      * @return unique
      */
     public static boolean isUnique(
             final Collection collection,
             final Transformer transformer)
     {
         boolean unique = true;
         final Set collected = new HashSet();
         for (final Iterator iterator = collection.iterator(); iterator.hasNext() && unique;)
         {
             final Object result = transformer.transform(iterator.next());
             if (collected.contains(result))
             {
                 unique = false;
             }
             else
             {
                 collected.add(result);
             }
         }
         return unique;
     }
 
     /**
      * Returns <code>true</code> if the result of executing the <code>transformer</code> has a unique value for each
      * element in the source collection.
      * @param collection
      * @param transformer
      * @return isUnique
      */
     public static boolean isUnique(
             final Object collection,
             final Transformer transformer)
     {
         boolean unique = collection != null;
         if (unique && collection != null && Collection.class.isAssignableFrom(collection.getClass()))
         {
             unique = isUnique((Collection) collection, transformer);
         }
         return unique;
     }
 
     /**
      * TODO: implement
      * @param collection
      * @return UnsupportedOperationException
      */
     public static Collection iterate(final Collection collection)
     {
         throw new UnsupportedOperationException(OCLCollections.class.getName() + ".iterate");
     }
 
     /**
      * Returns <code>true</true> when the argument expression evaluates true for one and only one element in the
      * collection. Returns <code>false</code> otherwise.
      * @param collection
      * @param predicate
      * @return found
      */
     public static boolean one(
             final Collection collection,
             final Predicate predicate)
     {
         boolean found = false;
 
         if (collection != null)
         {
             for (final Iterator iterator = collection.iterator(); iterator.hasNext();)
             {
                 if (predicate.evaluate(iterator.next()))
                 {
                     if (found)
                     {
                         found = false;
                         break;
                     }
                     found = true;
                 }
             }
         }
         return found;
     }
 
     /**
      * <p/>
      * Returns <code>true</true> if <code>collection</code> is actually a Collection instance and if the
      * <code>predicate</code> expression evaluates true for one and only one element in the collection. Returns
      * <code>false</code> otherwise. </p>
      * @param collection
      * @param predicate
      * @return one((Collection) collection, predicate)
      */
     public static boolean one(
             final Object collection,
             final Predicate predicate)
     {
         return collection != null && Collection.class.isAssignableFrom(collection.getClass()) &&
                 one((Collection) collection, predicate);
     }
 
     /**
      * Returns a subcollection of the source collection containing all elements for which the expression evaluates
      * <code>false</code>.
      * @param collection
      * @param predicate
      * @return CollectionUtils.selectRejected(collection, predicate)
      */
     public static Collection reject(
             final Collection collection,
             final Predicate predicate)
     {
         return CollectionUtils.selectRejected(collection, predicate);
     }
 
     /**
      * Returns a subcollection of the source collection containing all elements for which the expression evaluates
      * <code>true</code>.
      * @param collection
      * @param predicate
      * @return CollectionUtils.select(collection, predicate)
      */
     public static Collection select(
             final Collection collection,
             final Predicate predicate)
     {
         return CollectionUtils.select(collection, predicate);
     }
 
     /**
      * Returns a subcollection of the source collection containing all elements for which the expression evaluates
      * <code>true</code>.
      * @param collection
      * @param predicate
      * @return CollectionUtils.select((Collection) collection, predicate)
      */
     public static Collection select(
             final Object collection,
             final Predicate predicate)
     {
         return CollectionUtils.select((Collection) collection, predicate);
     }
 
     /**
      * TODO: implement
      * @param collection
      * @return UnsupportedOperationException
      */
     public static Collection sortedBy(final Collection collection)
     {
         throw new UnsupportedOperationException(OCLCollections.class.getName() + ".sortedBy");
     }
 
     /**
      * Converts the given object to a java.util.List implementation. If the object is not a collection type, then the
      * object is placed within a collection as the only element.
      *
      * @param object the object to convert.
      * @return the new List.
      */
     private static List objectToList(Object object)
     {
         List list = null;
         if (object instanceof Collection)
         {
             final Collection collection = (Collection) object;
             if (!(object instanceof List))
             {
                 object = new ArrayList(collection);
             }
             list = (List) object;
         } else
         {
             list = new ArrayList();
             if (object != null)
             {
                 list.add(object);
             }
         }
         return list;
     }
 }