/*
      Copyright 2007 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.util.collection;
  
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.Map.Entry;
  
  import fulmine.IAddressable;
  import fulmine.util.reference.is;
  
  /**
   * A collection implementation that stores and identifies objects based on their
   * {@link AbstractCoalescingCollection#getSystemIdentity(Object) identity}
   * within a {@link Map}. This provides coalescing of objects that are added to
   * the event store, like a set but based on the system identity of the object
   * rather than the hashcode.
   * <p>
   * This class is not thread aware and is not thread safe.
   * 
   * @author Ramon Servadei
   * 
   * @param <E>
   *            the element type this collection operates with, a sub-class of
   *            {@link IAddressable}
   * @see System#identityHashCode(Object)
   */
  public abstract class AbstractCoalescingCollection<E extends IAddressable>
      implements Collection<E>
  {
  
      /**
       * An internal iterator implementation that provides access to the values of
       * the data map in the order they were inserted. Delegates to a map entry
       * iterator of the data map but exposes only the value of the map entry the
       * delegate iterator returns.
       * 
       * @author Ramon Servadei
       * 
       * @param <E>
       */
      private final class DelegateIterator implements Iterator<E>
      {
          private final Iterator<Entry<Object, E>> delegate;
  
          private DelegateIterator(Iterator<Entry<Object, E>> delegate)
          {
              super();
              this.delegate = delegate;
          }
  
          public boolean hasNext()
          {
              return delegate.hasNext();
          }
  
          public E next()
          {
              return delegate.next().getValue();
          }
  
          public void remove()
          {
              delegate.remove();
          }
      }
  
      protected final Map<Object, E> data;
  
      /**
       * Constructor to pass in the data map implementation
       * 
       * @param data
       *            the data map implementation backing this collection
       */
      protected AbstractCoalescingCollection(Map<Object, E> data)
      {
          this.data = data;
      }
  
      public boolean add(E e)
      {
          Object sysId = AbstractCoalescingCollection.getSystemIdentity(e);
          final E value = this.data.put(sysId, e);
         return value == null || value != e;
     }
 
     public boolean addAll(Collection<? extends E> c)
     {
         boolean changed = false;
         if (c != null)
         {
             for (E e : c)
             {
                 changed |= add(e);
             }
         }
         return changed;
     }
 
     public void clear()
     {
         this.data.clear();
     }
 
     public boolean contains(Object o)
     {
         return this.data.containsKey(AbstractCoalescingCollection.getSystemIdentity(o));
     }
 
     public boolean containsAll(Collection<?> c)
     {
         return this.data.values().containsAll(c);
     }
 
     public boolean isEmpty()
     {
         return this.data.isEmpty();
     }
 
     public Iterator<E> iterator()
     {
         return new DelegateIterator(this.data.entrySet().iterator());
     }
 
     public boolean remove(Object o)
     {
         return this.data.remove(AbstractCoalescingCollection.getSystemIdentity(o)) != null;
     }
 
     public boolean removeAll(Collection<?> c)
     {
         boolean changed = false;
         if (c != null)
         {
             for (Object object : c)
             {
                 changed |= remove(object);
             }
         }
         return changed;
     }
 
     /**
      * Unsupported.
      * 
      * @throws UnsupportedOperationException
      */
     public boolean retainAll(Collection<?> c)
     {
         throw new UnsupportedOperationException();
     }
 
     public int size()
     {
         return this.data.size();
     }
 
     public Object[] toArray()
     {
         Object[] array = new Object[this.data.size()];
         final Set<Entry<Object, E>> entrySet = this.data.entrySet();
         int i = 0;
         for (Entry<Object, E> entry : entrySet)
         {
             array[i++] = entry.getValue();
         }
         return array;
     }
 
     @SuppressWarnings("unchecked")
     public <T> T[] toArray(T[] array)
     {
         final Set<Entry<Object, E>> entrySet = this.data.entrySet();
         int i = 0;
         for (Entry<Object, E> entry : entrySet)
         {
             array[i++] = (T) entry.getValue();
         }
         return array;
     }
 
     @Override
     public final String toString()
     {
         return getClass().getSimpleName()
             + CollectionUtils.toFormattedString(this.data.keySet()).toString();
     }
 
     @Override
     public final int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result =
             prime * result + ((this.data == null) ? 0 : this.data.hashCode());
         return result;
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public final boolean equals(Object obj)
     {
         if (is.same(this, obj))
         {
             return true;
         }
         if (!(obj instanceof AbstractCoalescingCollection))
         {
             return false;
         }
         final AbstractCoalescingCollection other =
             (AbstractCoalescingCollection) obj;
         return is.eq(this.data, other.data);
     }
 
     /**
      * Get the system identity for the object. If the object implements
      * {@link IAddressable}, then the identity is formed of the
      * {@link IAddressable#getIdentity()}, {@link IAddressable#getType()} and
      * {@link IAddressable#getDomain()}, otherwise a platform dependent system
      * identifier mechanism is invoked on the object.
      * 
      * @param object
      *            the object to get the system identity for
      * @return the {@link String} identity representing the unique system
      *         identifier for the object.
      */
     public static final String getSystemIdentity(Object object)
     {
         if (object instanceof IAddressable)
         {
             final IAddressable addressable = ((IAddressable) object);
             return addressable.getAddress();
         }
         final int identityHashCode = System.identityHashCode(object);
         return Integer.toString(identityHashCode);
     }
 
 }