package com.atlassian.cache.ehcache;
   
   import javax.annotation.Nonnull;
   import javax.annotation.Nullable;
   import javax.management.MBeanServer;
   
   import com.atlassian.cache.CacheLoader;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
  import com.atlassian.cache.CacheSettingsDefaultsProvider;
  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.constructs.blocking.CacheEntryFactory;
  import net.sf.ehcache.constructs.blocking.SelfPopulatingCache;
  import net.sf.ehcache.management.ManagementService;
  
  /**
   * 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 final net.sf.ehcache.CacheManager delegate;
  
      private boolean statisticsEnabled = true;
  
      /**
       * Creates an instance backed by a new instance of {@link net.sf.ehcache.CacheManager}.
       */
      public EhCacheManager()
      {
          this(net.sf.ehcache.CacheManager.create(), null);
      }
  
      /**
       * 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, CacheSettingsDefaultsProvider cacheSettingsDefaultsProvider)
      {
          super(cacheSettingsDefaultsProvider);
  
          this.delegate = delegate;
      }
  
      net.sf.ehcache.CacheManager getEh()
      {
          return delegate;
      }
  
      public boolean isStatisticsEnabled()
      {
          return statisticsEnabled;
      }
  
      public void setStatisticsEnabled(final boolean statisticsEnabled)
      {
          this.statisticsEnabled = statisticsEnabled;
      }
  
      @Nonnull
      @SuppressWarnings("unchecked")
      @Override
      public <V> CachedReference<V> getCachedReference(@Nonnull final String name,
                                                       @Nonnull final com.atlassian.cache.Supplier<V> supplier,
                                                       @Nonnull 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());
  
          return cacheCreationLocks.get(name).withLock(new com.atlassian.util.concurrent.Supplier<DelegatingCachedReference<V>>()
              {
                  @Override
                  public DelegatingCachedReference<V> get()
                  {
                      Ehcache ehCache = getCleanCache(name, overridenSettings);
                      final Ehcache spCache = new SelfPopulatingCache(ehCache, new CacheEntryFactory()
                      {
                          @Override
                          public Object createEntry(final Object o) throws Exception
                          {
                              return supplier.get();
                          }
                      });
  
                      final DelegatingCachedReference<V> cache = DelegatingCachedReference.create(spCache, overridenSettings);
                      caches.put(name, new WeakSupplier<ManagedCache>(cache));
                      return cache;
                  }
             });
     }
 
     @Override
     protected ManagedCache createSimpleCache(@Nonnull final String name, @Nonnull 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, settings);
                         caches.put(name,  new StrongSupplier<ManagedCache>(cache));
                     }
                     return  caches.get(name).get();
                 }
             });
 
     }
 
     @SuppressWarnings("unchecked")
     protected <K, V> ManagedCache createComputingCache(@Nonnull final String name, @Nonnull final CacheSettings settings, final CacheLoader<K, V> loader)
     {
         return cacheCreationLocks.get(name).withLock(new com.atlassian.util.concurrent.Supplier<ManagedCache>()
         {
             @Override
             public ManagedCache get()
             {
                 Ehcache ehCache = getCleanCache(name, settings);
 
                 Ehcache spCache = new SelfPopulatingCache(ehCache, new CacheEntryFactory()
                 {
                     @Override
                     public Object createEntry(final Object key) throws Exception
                     {
                         if (key == null)
                         {
                             throw new NullPointerException();
                         }
                         @SuppressWarnings("unchecked")
                         final K loaderKey = (K) key;
                         return loader.load(loaderKey);
                     }
                 });
                 DelegatingCache cache = DelegatingCache.create(spCache, settings);
                 caches.put(name,  new WeakSupplier<ManagedCache>(cache));
                 return cache;
             }
         });
     }
 
     private Ehcache getCleanCache(final String name, final CacheSettings settings)
     {
         // Particularly for plugins that are reloaded the cache may already exist from earlier times.
         // Because actually removing the old cache and recreating it breaks RMI replication we get the old one,
         // but to avoid any class loading issues with the old plugin class loader which would be unavailable
         // we remove all entries from the local version of the cache
 
         Ehcache ehCache = delegate.getCache(name);
         if (ehCache != null)
         {
             // Remove all entries but do not notify replication listeners.
             ehCache.removeAll(true);
         }
         else
         {
             ehCache = createCache(name, settings, true);
         }
         return ehCache;
     }
 
     private Ehcache createCache(String name, CacheSettings settings, boolean selfLoading)
     {
         return new EhCacheHelper().getEhcache(name, delegate, settings, selfLoading, statisticsEnabled);
     }
 
     @Override
     public void shutdown()
     {
 
         delegate.shutdown();
     }
 
     @Override
     public void registerMBeans(@Nullable final MBeanServer mBeanServer)
     {
         if (mBeanServer != null)
         {
             ManagementService.registerMBeans(delegate, mBeanServer, true, true, true, true);
         }
     }
 
     @Override
     public void unregisterMBeans(@Nullable final MBeanServer mBeanServer)
     {
         if (mBeanServer != null)
         {
             final ManagementService managementService = new ManagementService(delegate, mBeanServer, true, true, true, true);
             managementService.dispose();
         }
     }
 }