package com.atlassian.cache.ehcache;
   
   import java.io.UnsupportedEncodingException;
   import java.net.URLEncoder;
   
   import com.atlassian.cache.CacheSettings;
   
   import net.sf.ehcache.CacheManager;
   import net.sf.ehcache.Ehcache;
  import net.sf.ehcache.config.CacheConfiguration;
  import net.sf.ehcache.config.CacheConfiguration.CacheEventListenerFactoryConfiguration;
  import net.sf.ehcache.config.PersistenceConfiguration;
  
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  import static java.util.concurrent.TimeUnit.SECONDS;
  import static net.sf.ehcache.config.PersistenceConfiguration.Strategy.NONE;
  
  /**
   * Helper for building EhCache caches
   *
   * @since 2.0
   */
  class EhCacheHelper
  {
      // These are all the flags supported by RMICacheReplicatorFactory
      private static final String CACHE_PROPERTIES =
              "replicateAsynchronously=%s," +
              "replicatePuts=%s," +
              "replicatePutsViaCopy=%s," +
              "replicateUpdates=%s," +
              "replicateUpdatesViaCopy=%s," +
              "replicateRemovals=true";
  
      static final PersistenceConfiguration.Strategy PERSISTENCE_STRATEGY = NONE;
  
      private static final PersistenceConfiguration PERSISTENCE_CONFIGURATION =
              new PersistenceConfiguration().strategy(PERSISTENCE_STRATEGY);
  
      private static final String URL_ENCODING = "UTF-8";
  
      private static CacheEventListenerFactoryConfiguration getCacheEventListenerFactoryConfiguration(
              final CacheSettings settings, final boolean selfLoading)
      {
          final boolean replicateAsynchronously = settings.getReplicateAsynchronously(false);
          final boolean replicateViaCopy = settings.getReplicateViaCopy(false);
  
          // If the cache is self loading there is no need to replicate puts or updates as the loader takes care of
          // populating the cache as needed.
          // Else if the cache is replicating via copy then puts and updates should be replicated.
          // Else replicating puts is dangerous as it may lead to invalidations ping ponging between nodes. Whether to
          // replicate updates is ambiguous, but setting it may help to prevent stale caches while being less vulnerable
          // to the invalidation storm that comes with simply replicating puts.
          final boolean replicatePuts = !selfLoading && replicateViaCopy;
          final boolean replicateUpdates = !selfLoading;
  
          final String cacheProperties =
                  String.format(CACHE_PROPERTIES, replicateAsynchronously, replicatePuts, replicateViaCopy, replicateUpdates, replicateViaCopy);
          return new CacheEventListenerFactoryConfiguration()
                  .className(RMICacheReplicatorFactory.class.getName())
                  .properties(cacheProperties);
      }
  
      Ehcache getEhcache(final String name, final CacheManager ehMgr, final CacheSettings settings, final boolean selfLoading, final boolean statisticsEnabled)
      {
          //Create a Cache specifying its configuration.
          CacheConfiguration config = ehMgr.getConfiguration().getDefaultCacheConfiguration().clone()
                  .name(name)
                  .statistics(statisticsEnabled)
                  .persistence(PERSISTENCE_CONFIGURATION);
  
          final boolean replicateCache = isReplicateCache(ehMgr, settings);
          if (replicateCache)
          {
              config.cacheEventListenerFactory(
                      getCacheEventListenerFactoryConfiguration(settings, selfLoading));
          }
  
          if (null != settings.getMaxEntries())
          {
              config.setMaxEntriesLocalHeap(settings.getMaxEntries());
          }
  
          if (null != settings.getExpireAfterAccess())
          {
              config.timeToIdleSeconds(SECONDS.convert(settings.getExpireAfterAccess(), MILLISECONDS));
          }
  
          if (null != settings.getExpireAfterWrite())
          {
              config.timeToLiveSeconds(SECONDS.convert(settings.getExpireAfterWrite(), MILLISECONDS));
          }
  
          // Cache should not be eternal if expiry has been set
          if (settings.getExpireAfterAccess() != null || settings.getExpireAfterWrite() != null)
          {
              config.setEternal(false);
          }
  
          ehMgr.addCacheIfAbsent(new net.sf.ehcache.Cache(config));
         return ehMgr.getCache(getCacheName(name, replicateCache));
     }
 
     private String getCacheName(final String name, final boolean replicateCache)
     {
         if (replicateCache)
         {
             try
             {
                 return URLEncoder.encode(name, URL_ENCODING);
             }
             catch (final UnsupportedEncodingException e)
             {
                 throw new IllegalStateException(e);
             }
         }
         return name;
     }
 
     private boolean isReplicateCache(final CacheManager ehMgr, final CacheSettings settings)
     {
         final boolean isLocalCacheSetting = settings.getLocal(false); // default to non-local as per API
         return !isLocalCacheSetting && ehMgr.getCacheManagerPeerProvider("RMI") != null;
     }
 }