package com.atlassian.cache.vcache;
   
   import java.io.Serializable;
   import javax.annotation.Nonnull;
   
   import com.atlassian.cache.CacheException;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CachedReference;
   import com.atlassian.cache.CachedReferenceListener;
  import com.atlassian.cache.Supplier;
  import com.atlassian.vcache.StableReadExternalCache;
  import com.atlassian.vcache.VCacheUtils;
  
  import com.google.common.base.Throwables;
  
  import static java.util.Objects.requireNonNull;
  
  class ExternalCachedReference<V>
          extends ManagedCacheSupport
          implements CachedReference<V>
  {
      private static final String REFERENCE_KEY = "ReferenceKey";
  
      private final StableReadExternalCache<Serializable> delegate;
      private final Supplier<V> supplier;
  
      ExternalCachedReference(String name,
                              StableReadExternalCache<Serializable> delegate,
                              Supplier<V> supplier,
                              CacheSettings settings)
      {
          super(name, settings);
          this.delegate = requireNonNull(delegate);
          this.supplier = requireNonNull(supplier);
      }
  
      @Nonnull
      @Override
      public V get()
      {
          try
          {
              //noinspection unchecked
              return (V) VCacheUtils.join(delegate.get(REFERENCE_KEY, () -> Utils.asSerializable(supplier.get())));
          }
          catch (RuntimeException ex)
          {
              Throwables.propagateIfInstanceOf(Throwables.getRootCause(ex), CacheException.class);
              throw new CacheException("Unknown failure", ex);
          }
      }
  
      @Override
      public void reset()
      {
          delegate.remove(REFERENCE_KEY);
      }
  
      @Override
      public void addListener(@Nonnull CachedReferenceListener<V> listener, boolean includeValues)
      {
          throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
      }
  
      @Override
      public void removeListener(@Nonnull CachedReferenceListener<V> listener)
      {
          throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
      }
  
      @Override
      public void clear()
      {
          delegate.remove(REFERENCE_KEY);
      }
  
      @Override
      public boolean isLocal()
      {
          return false;
      }
  }