package com.atlassian.vcache.internal.core.service;
   
   import com.atlassian.vcache.JvmCache;
   import com.atlassian.vcache.JvmCacheSettings;
   import com.atlassian.vcache.VCacheException;
   import com.atlassian.vcache.internal.core.RecursionDetector;
   import com.google.common.cache.Cache;
   import com.google.common.cache.CacheBuilder;
   import com.google.common.util.concurrent.UncheckedExecutionException;
  
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Optional;
  import java.util.Set;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.ReentrantLock;
  import java.util.function.Function;
  import java.util.function.Supplier;
  
  import static com.atlassian.vcache.internal.NameValidator.requireValidCacheName;
  import static java.util.Objects.requireNonNull;
  
  /**
   * Implementation of the {@link JvmCache} that uses Guava.
   *
   * @param <K> the key type
   * @param <V> the value type
   * @since 1.0
   */
  public class GuavaJvmCache<K, V> implements JvmCache<K, V> {
      private final ReentrantLock globalLock = new ReentrantLock();
      private final String name;
      private final Cache<K, V> delegate;
      private final RecursionDetector<K> recursionDetector = new RecursionDetector<>();
  
      /**
       * Creates an instance. <b>NOTE:</b> all the supplied settings must be set.
       *
       * @param name     the name of the cache
       * @param settings the settings for the cache.
       */
      public GuavaJvmCache(String name, JvmCacheSettings settings) {
          this.name = requireValidCacheName(name);
          //noinspection OptionalGetWithoutIsPresent
          this.delegate = CacheBuilder.newBuilder()
                  .maximumSize(settings.getMaxEntries().get())
                  .expireAfterWrite(settings.getDefaultTtl().get().toMillis(), TimeUnit.MILLISECONDS)
                  .build();
      }
  
      @Override
      public Set<K> getKeys() {
          return withLock(() -> new HashSet<>(delegate.asMap().keySet()));
      }
  
      @Override
      public Optional<V> get(K key) {
          return withLock(() -> Optional.ofNullable(delegate.getIfPresent(key)));
      }
  
      @Override
      public V get(K key, Supplier<? extends V> supplier) {
          try (RecursionDetector.Guard<K> ignored = recursionDetector.guardOn(key)) {
              return withLock(() -> {
                  try {
                      return delegate.get(requireNonNull(key), supplier::get);
                  } catch (UncheckedExecutionException | ExecutionException e) {
                      throw new VCacheException("Supplier failed", e);
                  }
              });
          }
      }
  
      @SafeVarargs
      @Override
      public final Map<K, V> getBulk(Function<Set<K>, Map<K, V>> factory, K... keys) {
          // This method needs to be final to prevent subclasses bypassing the locking enforced by this class.
          return getBulk(factory, Arrays.asList(keys));
      }
  
      @Override
      public Map<K, V> getBulk(Function<Set<K>, Map<K, V>> factory, Iterable<K> keys) {
          return withLock(() -> LocalCacheUtils.getBulk(
                  factory,
                  keys,
                  this::get,
                  args -> put(args.key, args.value),
                  recursionDetector));
      }
  
      @Override
      public void put(K key, V value) {
          withLock(() -> delegate.put(requireNonNull(key), requireNonNull(value)));
      }
  
      @Override
      public Optional<V> putIfAbsent(K key, V value) {
         return withLock(() -> Optional.ofNullable(delegate.asMap().putIfAbsent(requireNonNull(key), requireNonNull(value))));
     }
 
     @Override
     public boolean replaceIf(K key, V currentValue, V newValue) {
         return withLock(() -> delegate.asMap().replace(requireNonNull(key), requireNonNull(currentValue), requireNonNull(newValue)));
     }
 
     @Override
     public void remove(K key) {
         withLock(() -> delegate.invalidate(key));
     }
 
     @Override
     public void removeAll() {
         withLock((Runnable) delegate::invalidateAll);
     }
 
     @Override
     public boolean removeIf(K key, V value) {
         return withLock(() -> delegate.asMap().remove(key, value));
     }
 
     @Override
     public String getName() {
         return name;
     }
 
     private <R> R withLock(Supplier<R> supplier) {
         globalLock.lock();
         try {
             return supplier.get();
         } finally {
             globalLock.unlock();
         }
     }
 
     private void withLock(Runnable runner) {
         globalLock.lock();
         try {
             runner.run();
         } finally {
             globalLock.unlock();
         }
     }
 }