/**
    * 
    */
   package org.sourceforge.jemm.util.managed;
   
   import java.util.Collection;
   import java.util.Map;
   import java.util.Set;
   import java.util.concurrent.ConcurrentHashMap;
  
  import org.sourceforge.jemm.util.managed.bucket.BucketLockedBucketFactory;
  import org.sourceforge.jemm.util.managed.bucket.ECMapBucket;
  import org.sourceforge.jemm.util.managed.bucket.ECMapBucketFactory;
  
  /**
   * EnhancedConcurrentHashMap is similar to ConcurrentHashMap, but adds some extra 
   * features.  The main extra method is 'perform' that allows an arbitrary action to 
   * be performed whilst the lock on the given key is held (even if there is no entry
   * in the map beforehand.
   * 
   * <B>N.B</B> This map does not support null values, if put(key,null) is used, contains(key) will return false.
   * 
   * @param <K> The key type. 
   * @param <V>  The value type
   *
   * @author Rory Graves
   */
  public class EnhancedConcurrentHashMap<K,V> implements EnhancedConcurrentMap<K, V> {
      /** The default number of locking buckets. */
      public static final int DEFAULT_NO_BUCKETS = 8;
  
      private final int noBuckets;
      private final ECMapBucket<K,V>[] buckets;
      
      /**
       * Creates an EnhancedConcurrentHashMap with a default number of buckets.
       */
      public EnhancedConcurrentHashMap() {
          this(new BucketLockedBucketFactory<K, V>(),DEFAULT_NO_BUCKETS);
      }
  
      /** 
       * Creates an EnhancedConcurrentHashMap with the given number of internal buckets.
       * @param noBuckets
       */
      public EnhancedConcurrentHashMap(int noBuckets) {
          this(new BucketLockedBucketFactory<K, V>(),noBuckets);
      }
    
      @SuppressWarnings("unchecked") 
      protected EnhancedConcurrentHashMap(ECMapBucketFactory<K, V> bucketFactory,int noBuckets) {
          this.noBuckets = noBuckets;
          this.buckets = new ECMapBucket[noBuckets];
          for(int i=0; i<noBuckets; i++)
              buckets[i] = bucketFactory.createBucket();
      }
      
      /**
       * Perform the given action whilst holding the lock on the given key.
       * The action is able to access, update or clear the value associated 
       * with the given key as part of the action.
       * @param key The key to lock during the action.
       * @param action The action to perform whilst the lock is held.
       */
      @Override public void perform(K key,ECMAction<K,V> action) {
          getBucket(key).perform(key, action);
      }
      
      /**
       * Method to separate hashCodes values into segment buckets.
       * @param keyHashCode of the item being bucketed
       * @param noBuckets The number of segments available.
       * @return The assigned segment (0...(noSegments-1))
       */
      private ECMapBucket<K, V> getBucket(K key) {
          if(key == null)
              throw new IllegalArgumentException("Key may not be null");
  
          int hashCode = key.hashCode(); 
  
          // Math.abs behaves oddly with Integer.MIN_VALUE
          if(hashCode == Integer.MIN_VALUE) 
              hashCode = 0;
  
          int absHashCode = Math.abs(hashCode);
          return buckets[absHashCode % noBuckets];
      }
  
      /**
       * Atomically associate a value with a key, if a value is not already assocated with the given key.
       * @param key The key
       * @param value The new value to associate.
       * @return The old value associated with 'key'
       * @see ConcurrentHashMap#putIfAbsent(Object,Object)
       */
      @Override public V putIfAbsent(K key, V value) {
          return getBucket(key).putIfAbsent(key,value);
      }
  
     @SuppressWarnings("unchecked") 
     @Override public boolean remove(Object key, Object value) {
         return getBucket((K) key).remove((K) key,(V) value);
     }
 
     @Override public V replace(K key, V value) {
         return getBucket(key).replace(key,value);
     }
 
     @Override public boolean replace(K key, V oldValue, V newValue) {
         return getBucket(key).replace(key,oldValue,newValue);
     }
 
     /** 
      * Clear all the entries in this map.
      * <B>N.B.</B> This is not a thread safe operation, inserts that occur simultaneously may be lost or survive
      * at random.  
      * @see java.util.Map#clear()
      */
     @Override public void clear() {
         for (ECMapBucket<K, V> bucket : buckets)
             bucket.clear();
     }
 
     @SuppressWarnings("unchecked") 
     @Override public boolean containsKey(Object key) {
         return getBucket((K) key).containsKey((K) key);
     }
 
     @SuppressWarnings("unchecked") 
     @Override public boolean containsValue(Object value) {
         for (ECMapBucket<K, V> bucket : buckets)
             if(bucket.contains((V) value))
                 return true;
         
         return false;
     }
 
     @Override public Set<java.util.Map.Entry<K, V>> entrySet() {
         throw new UnsupportedOperationException();
     }
 
     @SuppressWarnings("unchecked") 
     @Override public V get(Object key) {
         return getBucket((K) key).get((K) key);
     }
 
     @Override public boolean isEmpty() {
         for (ECMapBucket<K, V> bucket : buckets)
             if(bucket.size() > 0)
                 return false;
         
         return true;
     }
 
     @Override public Set<K> keySet() {
         throw new UnsupportedOperationException();
     }
 
     @Override public V put(K key, V value) {
         if(key == null)
             throw new IllegalArgumentException("Key may not be null");
         if(value == null)
             throw new IllegalArgumentException("Value may not be null");
         return getBucket(key).put(key,value);
     }
 
     @Override public void putAll(Map<? extends K, ? extends V> m) {
         throw new UnsupportedOperationException();
     }
 
     @SuppressWarnings("unchecked") 
     @Override public V remove(Object key) {
         return getBucket((K) key).remove((K) key);
     }
 
     @Override public int size() {
         int size = 0;
         for (ECMapBucket<K,V> bucket : buckets)
             size += bucket.size();
         
         return size;
     }
 
     @Override public Collection<V> values() {
         throw new UnsupportedOperationException();
     }
 
 }