package com.atlassian.vcache.internal.redis;
   
   import com.atlassian.marshalling.api.MarshallingPair;
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.ExternalCacheSettings;
   import com.atlassian.vcache.JvmCache;
   import com.atlassian.vcache.JvmCacheSettings;
   import com.atlassian.vcache.StableReadExternalCache;
   import com.atlassian.vcache.TransactionalExternalCache;
  import com.atlassian.vcache.internal.BegunTransactionalActivityHandler;
  import com.atlassian.vcache.internal.RequestContext;
  import com.atlassian.vcache.internal.VCacheCreationHandler;
  import com.atlassian.vcache.internal.VCacheSettingsDefaultsProvider;
  import com.atlassian.vcache.internal.core.ExternalCacheKeyGenerator;
  import com.atlassian.vcache.internal.core.Sha1ExternalCacheKeyGenerator;
  import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
  import com.atlassian.vcache.internal.core.service.AbstractVCacheService;
  import com.atlassian.vcache.internal.core.service.GuavaJvmCache;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import redis.clients.jedis.Jedis;
  
  import java.time.Duration;
  import java.util.function.Supplier;
  
  import static java.util.Objects.requireNonNull;
  
  /**
   * Main service that is backed by <tt>Redis</tt>.
   *
   * @since 1.0.0
   */
  public class RedisVCacheService extends AbstractVCacheService {
      private static final Logger log = LoggerFactory.getLogger(RedisVCacheService.class);
  
      private final Supplier<Jedis> clientSupplier;
  
      /**
       * Creates an instance, with the default {@link com.atlassian.vcache.internal.core.ExternalCacheKeyGenerator}.
       *
       * @param productIdentifier          the unique product identifier, such as <tt>jira</tt> or <tt>confluence</tt>
       * @param clientSupplier             the supplier for the Memcached client
       * @param threadLocalContextSupplier the supplier for the request context.
       * @param workContextContextSupplier A supplier of a thread safe request context.
       * @param defaultsProvider           the cache defaults provider
       * @param creationHandler            the handler called when caches are being created.
       * @param metricsCollector           the collector for gathering metrics.
       */
      public RedisVCacheService(String productIdentifier,
                                Supplier<Jedis> clientSupplier,
                                Supplier<RequestContext> threadLocalContextSupplier,
                                Supplier<RequestContext> workContextContextSupplier,
                                VCacheSettingsDefaultsProvider defaultsProvider,
                                VCacheCreationHandler creationHandler,
                                MetricsCollector metricsCollector,
                                BegunTransactionalActivityHandler begunTransactionalActivityHandler,
                                Duration lockTimeout) {
          super(threadLocalContextSupplier,
                  workContextContextSupplier,
                  defaultsProvider,
                  creationHandler,
                  metricsCollector,
                  new Sha1ExternalCacheKeyGenerator(productIdentifier),
                  begunTransactionalActivityHandler,
                  lockTimeout);
          this.clientSupplier = requireNonNull(clientSupplier);
      }
  
      /**
       * Creates an instance, with a supplied {@link com.atlassian.vcache.internal.core.ExternalCacheKeyGenerator}.
       *
       * @param clientSupplier             the supplier for the Memcached client
       * @param threadLocalContextSupplier the supplier for the request context.
       * @param workContextContextSupplier A supplier of a thread safe request context.
       * @param defaultsProvider           the cache defaults provider
       * @param creationHandler            the handler called when caches are being created.
       * @param metricsCollector           the collector for gathering metrics.
       */
      public RedisVCacheService(Supplier<Jedis> clientSupplier,
                                Supplier<RequestContext> threadLocalContextSupplier,
                                Supplier<RequestContext> workContextContextSupplier,
                                VCacheSettingsDefaultsProvider defaultsProvider,
                                VCacheCreationHandler creationHandler,
                                MetricsCollector metricsCollector,
                                ExternalCacheKeyGenerator externalCacheKeyGenerator,
                                BegunTransactionalActivityHandler begunTransactionalActivityHandler,
                                Duration lockTimeout) {
          super(threadLocalContextSupplier,
                  workContextContextSupplier,
                  defaultsProvider,
                  creationHandler,
                  metricsCollector,
                  externalCacheKeyGenerator,
                  begunTransactionalActivityHandler,
                  lockTimeout);
          this.clientSupplier = requireNonNull(clientSupplier);
      }
  
      @Override
     protected Logger log() {
         return log;
     }
 
     @Override
     protected <K, V> JvmCache<K, V> createJvmCache(String name, JvmCacheSettings settings) {
         return new GuavaJvmCache<>(name, settings, lockTimeout);
     }
 
     @Override
     protected <V> TransactionalExternalCache<V> createTransactionalExternalCache(
             String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable) {
         return new RedisTransactionalExternalCache<>(
                 clientSupplier,
                 threadLocalContextSupplier,
                 externalCacheKeyGenerator,
                 name,
                 valueMarshalling,
                 settings,
                 transactionControlManager,
                 metricsCollector,
                 lockTimeout);
     }
 
     @Override
     protected <V> StableReadExternalCache<V> createStableReadExternalCache(String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable) {
         return new RedisStableReadExternalCache<>(
                 clientSupplier,
                 workContextContextSupplier,
                 externalCacheKeyGenerator,
                 name,
                 valueMarshalling,
                 settings,
                 metricsCollector,
                 lockTimeout);
     }
 
     @Override
     protected <V> DirectExternalCache<V> createDirectExternalCache(String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable) {
         return new RedisDirectExternalCache<>(
                 clientSupplier,
                 workContextContextSupplier,
                 externalCacheKeyGenerator,
                 name,
                 valueMarshalling,
                 settings,
                 lockTimeout);
     }
 }