/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.properties.spi.config.cache.guava;
  
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map.Entry;
  import java.util.Set;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  import java.util.logging.Logger;
  
  import com.google.common.cache.Cache;
  import com.google.common.cache.CacheBuilder;
  import com.google.common.cache.CacheLoader;
  import com.google.common.cache.LoadingCache;
  import com.google.common.cache.RemovalListener;
  import com.google.common.cache.RemovalNotification;
  
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyCollection;
  import de.smartics.properties.impl.config.cache.CacheConfigurationPropertiesManagement;
  import de.smartics.properties.spi.config.cache.infinispan.InfinispanCompoundKeyDelegatingCache;
  import de.smartics.util.lang.StaticAnalysis;
  
  /**
   * The cache manager implementation using
   * <code>com.google.common.cache.Cache</code> provided by <a
   * href="http://code.google.com/p/guava-libraries/">guava-libraries</a>.
   */
  public final class GuavaCacheManager
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The logger for this class.
     */
    private static final Logger LOGGER = Logger.getLogger(GuavaCacheManager.class
        .getName());
  
    /**
     * The name of the key to retrieve the cache names.
     */
    public static final String INFINISPAN_DELEGATING_CACHE_CACHE_NAME =
        "INFINISPAN_DELEGATING_CACHE_CACHE";
  
    /**
     * The lock for synchronized access.
     *
     * @serial
     */
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  
    /**
     * The read lock for synchronized access.
     *
     * @serial
     */
    private final Lock readLock = lock.readLock();
  
    /**
     * The write lock for synchronized access.
     *
     * @serial
     */
    private final Lock writeLock = lock.writeLock();
  
    /**
     * Removal listener for configurations.
     */
    // CHECKSTYLE:OFF
    @SuppressWarnings(StaticAnalysis.RAWTYPES)
    private final RemovalListener<Object, Object> configurationCacheCacheEntryRemovalListener =
        new RemovalListener<Object, Object>()
        {
          public void onRemoval(final RemovalNotification<Object, Object> removal)
          {
            final String key = removal.getKey().toString();
            LOGGER.fine("REMOVED: Confiurations cache removed cache with key: "
                        + key);
            final Object value = removal.getValue();
            if (value instanceof CacheConfigurationPropertiesManagement)
           {
             removeFromInfinispanCache((CacheConfigurationPropertiesManagement) value);
           }
         }
 
         private void removeFromInfinispanCache(
             final CacheConfigurationPropertiesManagement management)
         {
           final PropertyCollection collection =
               management.getPropertyStoreAccessor()
                   .getPropertyCollectionFromStore();
           final String configurationKeyString = management.getKey().toString();
           final InfinispanCompoundKeyDelegatingCache ic =
               fetchInfinispanCompuondKeyDelegatingCache(configurationKeyString);
 
           for (final Iterator iterator = collection.iterator(); iterator
               .hasNext();)
           {
             final Property property = (Property) iterator.next();
             final String propertyKey = property.getName();
             ic.remove(propertyKey);
             LOGGER.finest("REMOVED from infinispan cache: key:" + propertyKey);
           }
         }
 
         @SuppressWarnings("unchecked")
         private InfinispanCompoundKeyDelegatingCache fetchInfinispanCompuondKeyDelegatingCache(
             final String configurationKeyString)
         {
           final de.smartics.properties.spi.config.cache.Cache infinispanDelegatingCache =
               getInfinispanDelegatingCache();
           final InfinispanCompoundKeyDelegatingCache ic =
               (InfinispanCompoundKeyDelegatingCache) infinispanDelegatingCache
                   .get(configurationKeyString);
           return ic;
         }
       };
 
   // CHECKSTYLE:ON
 
   /**
    * Removal listener for configurations.
    */
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   private final RemovalListener<Object, Cache> infinispanCacheCacheEntryRemovalListener =
       new RemovalListener<Object, Cache>()
       {
         public void onRemoval(final RemovalNotification<Object, Cache> removal)
         {
           final String key = removal.getKey().toString();
           LOGGER.fine("REMOVED: Infinispan cache removed cache with key: "
                       + key);
         }
       };
 
   /**
    * Removal listener for infinispan caches.
    */
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   private final RemovalListener<Object, Cache> mainCacheCacheEntryRemovalListener =
       new RemovalListener<Object, Cache>()
       {
         public void onRemoval(final RemovalNotification<Object, Cache> removal)
         {
           final Object key = removal.getKey().toString();
           LOGGER.fine("REMOVED: Main cache removed cache with key: " + key);
         }
       };
 
   /**
    * The cache builder to build the caches on the fly.
    */
   // TODO configure eviction
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   private final CacheBuilder configurationsCacheCacheBuilder = CacheBuilder
       .newBuilder().expireAfterWrite(30, TimeUnit.MINUTES)
       .removalListener(configurationCacheCacheEntryRemovalListener);
 
   /**
    * The cache builder to build the caches on the fly.
    */
   // TODO configure eviction
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   private final CacheBuilder infinispanCacheCacheBuilder = CacheBuilder
       .newBuilder().expireAfterWrite(30, TimeUnit.MINUTES)
       .removalListener(infinispanCacheCacheEntryRemovalListener);
 
   /**
    * The cache builder to build the main cache (the one that stores the other
    * caches).
    */
   // TODO configure eviction
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   private final CacheBuilder mainCacheBuilder = CacheBuilder.newBuilder()
       .removalListener(mainCacheCacheEntryRemovalListener);
 
   /**
    * The cache to store the caches.
    */
   @SuppressWarnings({ StaticAnalysis.RAWTYPES, StaticAnalysis.UNCHECKED })
   private final LoadingCache<String, Cache> configurationCacheCache =
       mainCacheBuilder.build(new CacheLoader<String, Cache>()
       {
         public Cache load(final String key)
         {
           LOGGER.fine("BUILDING: Building config cache cache for key: " + key);
           return configurationsCacheCacheBuilder.build();
         }
       });
 
   /**
    * The cache to store the caches.
    */
   @SuppressWarnings({ StaticAnalysis.RAWTYPES, StaticAnalysis.UNCHECKED })
   private final LoadingCache<String, Cache> infinispanCacheCache =
       mainCacheBuilder.build(new CacheLoader<String, Cache>()
       {
         public Cache load(final String key)
         {
           LOGGER
               .fine("BUILDING: Building guava (infinispanCacheCache) cache for key: "
                     + key);
           return infinispanCacheCacheBuilder.build();
         }
       });
 
   /**
    * The cache to store the caches wrapped in a guava delegating cache.
    */
   @SuppressWarnings({ StaticAnalysis.RAWTYPES, StaticAnalysis.UNCHECKED })
   private final GuavaDelegatingCache guavaBasedInfinispanCacheCache =
       new GuavaDelegatingCache(infinispanCacheCache);
 
   // --- members --------------------------------------------------------------
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    */
   public GuavaCacheManager()
   {
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Removes all keys from all caches.
    */
   public void clearAll()
   {
     writeLock.lock();
     try
     {
       internalClearAll(configurationCacheCache);
       internalClearAll(infinispanCacheCache);
     }
     finally
     {
       writeLock.unlock();
     }
 
   }
 
   @SuppressWarnings("rawtypes")
   private void internalClearAll(final LoadingCache<String, Cache> cache)
   {
     for (final Entry<String, Cache> entry : cache.asMap().entrySet())
     {
       entry.getValue().cleanUp();
     }
     cache.cleanUp();
   }
 
   /**
    * Clears the cache with the given name.
    *
    * @param cacheName the name of the cache to be cleared.
    */
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   public void clear(final String cacheName)
   {
     writeLock.lock();
     try
     {
       final Cache current = findCache(cacheName);
       if (current != null)
       {
         current.cleanUp();
       }
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @SuppressWarnings("rawtypes")
   private Cache findCache(final String cacheName)
   {
     Cache current = configurationCacheCache.getIfPresent(cacheName);
     if (current == null)
     {
       current = infinispanCacheCache.getIfPresent(cacheName);
     }
     return current;
   }
 
   /**
    * Clears and stops the cache.
    *
    * @param cacheName the name of the cache to be cleared and stopped.
    */
   public void discard(final String cacheName)
   {
     clear(cacheName);
   }
 
   /**
    * Stops all caches, rendering the manager in a stopped state.
    */
   public void stopAll()
   {
     clearAll();
   }
 
   /**
    * Stops the cache with the given name.
    *
    * @param cacheName the name of the cache to stop.
    */
   public void stop(final String cacheName)
   {
     clear(cacheName);
   }
 
   /**
    * Returns the cache with the given name. The cache is already started.
    *
    * @param cacheName the name of the cache to fetch.
    * @return the requested cache already started.
    */
   @SuppressWarnings({ StaticAnalysis.RAWTYPES, StaticAnalysis.UNCHECKED })
   public de.smartics.properties.spi.config.cache.Cache getConfigurationsCache(
       final String cacheName)
   {
     writeLock.lock();
     try
     {
       LOGGER.finest("GETTING: gCC: " + cacheName);
       final Cache currentCache = configurationCacheCache.get(cacheName);
       return new GuavaDelegatingCache(currentCache);
     }
     catch (final ExecutionException e)
     {
       // TODO Smartics exception
       return null;
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   /**
    * Returns the infinispan delegating cache.
    *
    * @return the requested cache.
    */
   @SuppressWarnings(StaticAnalysis.RAWTYPES)
   public de.smartics.properties.spi.config.cache.Cache getInfinispanDelegatingCache()
   {
     LOGGER.finest("GETTING: idc");
     return guavaBasedInfinispanCacheCache;
   }
 
   /**
    * Returns the set of cache names.
    *
    * @return the set of cache names.
    */
   public Set<String> getCacheNames()
   {
     readLock.lock();
     try
     {
       final Set<String> cacheNames = new HashSet<String>();
       cacheNames.addAll(configurationCacheCache.asMap().keySet());
       cacheNames.addAll(infinispanCacheCache.asMap().keySet());
       return cacheNames;
     }
     finally
     {
       readLock.unlock();
     }
   }
   // --- object basics --------------------------------------------------------
 
 }