package com.atlassian.cache.ehcache;
   
   import com.atlassian.cache.CacheLoader;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.cache.CachedReference;
   import com.atlassian.cache.ManagedCache;
   import com.atlassian.cache.impl.AbstractCacheManager;
   import com.atlassian.cache.impl.StrongSupplier;
  import com.atlassian.cache.impl.WeakSupplier;
  import com.atlassian.cache.impl.jmx.MBeanRegistrar;
  import com.atlassian.util.concurrent.Supplier;
  import net.sf.ehcache.Ehcache;
  import net.sf.ehcache.management.ManagementService;
  
  import javax.annotation.Nullable;
  import javax.management.MBeanServer;
  
  /**
   * Maintains a mapping of name -> Cache and provides factory methods for creating ad getting caches.
   *
   * @since 2.0
   */
  public class EhCacheManager extends AbstractCacheManager implements MBeanRegistrar
  {
      private net.sf.ehcache.CacheManager delegate;
  
      /**
       * Creates an instance backed by a new instance of {@link net.sf.ehcache.CacheManager}.
       */
      public EhCacheManager()
      {
          this(net.sf.ehcache.CacheManager.create());
      }
  
      /**
       * Creates an instance backed by the provided instance of {@link net.sf.ehcache.CacheManager}.
       *
       * @param delegate an Ehcache's cache manager
       */
      public EhCacheManager(net.sf.ehcache.CacheManager delegate)
      {
          this.delegate = delegate;
      }
  
      net.sf.ehcache.CacheManager getEh()
      {
          return delegate;
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public <V> CachedReference<V> getCachedReference(final String name,
                                                       final com.atlassian.cache.Supplier<V> supplier,
                                                       final CacheSettings settings)
      {
          // Force the cache settings to be flushable and a maximum size of one.
          final CacheSettings overridenSettings = settings.override(
                  new CacheSettingsBuilder().flushable().maxEntries(1).build());
  
          // If the cache already exists we aggressively remove it from EHCache,
          // unless ReplicateViaCopy in which case we reuse it.
          if (caches.containsKey(name))
          {
              if (settings.getReplicateViaCopy(false))
              {
                  Ehcache ehCache = delegate.getCache(name);
                  DelegatingCachedReference cache = DelegatingCachedReference.create(ehCache, supplier, settings);
                  caches.put(name,  new WeakSupplier<ManagedCache>(cache));
                  return cache;
              }
              else
              {
                  delegate.removeCache(name);
              }
          }
  
          return cacheCreationLocks.get(name).withLock(new com.atlassian.util.concurrent.Supplier<DelegatingCachedReference<V>>()
              {
                  @Override
                  public DelegatingCachedReference<V> get()
                  {
                      final Ehcache ehcache = createCache(name, overridenSettings, true);
                      final DelegatingCachedReference<V> cache = DelegatingCachedReference.create(ehcache, supplier, overridenSettings);
                      caches.put(name, new WeakSupplier<ManagedCache>(cache));
                      return cache;
                  }
              });
      }
  
      @Override
      protected ManagedCache createSimpleCache(final String name, final CacheSettings settings)
      {
          final Supplier<ManagedCache> cacheSupplier = caches.get(name);
          if (cacheSupplier != null)
          {
              ManagedCache cache = cacheSupplier.get();
              if (cache != null)
              {
                 return cache;
             }
         }
         return cacheCreationLocks.get(name).withLock(new com.atlassian.util.concurrent.Supplier<ManagedCache>()
             {
                 @Override
                 public ManagedCache get()
                 {
                     if (!caches.containsKey(name))
                     {
                         final Ehcache simpleCache = createCache(name, settings, false);
                         DelegatingCache cache = DelegatingCache.create(simpleCache, null, settings);
                         caches.put(name,  new StrongSupplier<ManagedCache>(cache));
                     }
                     return  caches.get(name).get();
                 }
             });
 
     }
 
     @SuppressWarnings("unchecked")
     protected <K, V> ManagedCache createComputingCache(final String name, final CacheSettings settings, final CacheLoader<K, V> loader)
     {
         // If the cache already exists we aggressively remove it from EHCache,
         // unless ReplicateViaCopy in which case we reuse it.
         if (caches.containsKey(name))
         {
             if (settings.getReplicateViaCopy(false))
             {
                 Ehcache delegateCache = delegate.getCache(name);
                 DelegatingCache cache = DelegatingCache.create(delegateCache, loader, settings);
                 caches.put(name,  new WeakSupplier<ManagedCache>(cache));
                 return cache;
             }
             else
             {
                 delegate.removeCache(name);
             }
         }
         return cacheCreationLocks.get(name).withLock(new com.atlassian.util.concurrent.Supplier<ManagedCache>()
         {
             @Override
             public ManagedCache get()
             {
                 final Ehcache delegateCache = createCache(name, settings, true);
                 DelegatingCache cache = DelegatingCache.create(delegateCache, loader, settings);
                 caches.put(name,  new WeakSupplier<ManagedCache>(cache));
                 return cache;
             }
         });
     }
 
     private Ehcache createCache(String name, CacheSettings settings, boolean selfLoading)
     {
         return new EhCacheHelper().getEhcache(name, delegate, settings, selfLoading);
     }
 
     @Override
     public void registerMBeans(@Nullable final MBeanServer mBeanServer)
     {
         if (mBeanServer != null)
         {
             ManagementService.registerMBeans(delegate, mBeanServer, true, true, true, true);
         }
     }
 
 }