package com.atlassian.vcache.internal.legacy;
   
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.cache.ehcache.EhCacheManager;
   import com.atlassian.cache.ehcache.replication.rmi.RMICacheReplicatorConfigFactory;
   import com.atlassian.marshalling.api.MarshallingPair;
  import com.atlassian.marshalling.jdk.StringMarshalling;
  import com.atlassian.vcache.DirectExternalCache;
  import com.atlassian.vcache.ExternalCacheSettings;
  import com.atlassian.vcache.StableReadExternalCache;
  import com.atlassian.vcache.internal.RequestContext;
  import com.atlassian.vcache.internal.core.DefaultRequestContext;
  import com.atlassian.vcache.internal.core.Sha1ExternalCacheKeyGenerator;
  import com.atlassian.vcache.internal.core.cas.IdentifiedData;
  import com.atlassian.vcache.internal.core.metrics.DefaultMetricsCollector;
  import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
  import com.atlassian.vcache.internal.test.AbstractStableReadExternalCacheIT;
  import net.sf.ehcache.CacheManager;
  import org.junit.Ignore;
  
  import java.util.Optional;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  
  public class LegacyStableReadExternalCacheEhcacheIT extends AbstractStableReadExternalCacheIT {
      private RequestContext requestContext = new DefaultRequestContext("tenant-id");
      private Sha1ExternalCacheKeyGenerator keyGenerator = new Sha1ExternalCacheKeyGenerator("it-test");
      private Optional<MarshallingPair<String>> marshalling = Optional.of(StringMarshalling.pair());
      private final MetricsCollector metricsCollector = new DefaultMetricsCollector(() -> requestContext);
      private CacheFactory cacheFactory;
      {
          final CacheManager rawEhcache = CacheManager.create();
          // Make sure we are not getting old caches for our test.
          rawEhcache.removeAllCaches();
  
          cacheFactory = new EhCacheManager(rawEhcache, new RMICacheReplicatorConfigFactory(), null);
      }
  
      @Override
      protected StableReadExternalCache<String> createCache(String name, ExternalCacheSettings settings) {
          final CacheSettings legacySettings = new CacheSettingsBuilder()
                  .remote()
                  .maxEntries(settings.getEntryCountHint().get())
                  .expireAfterWrite(settings.getDefaultTtl().get().toNanos(), TimeUnit.NANOSECONDS)
                  .build();
  
          final Cache<String, IdentifiedData> delegate = cacheFactory.getCache(name, null, legacySettings);
          return new LegacyStableReadExternalCache<>(
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshalling,
                  new LegacyServiceSettingsBuilder().enableAvoidCasOperations().build(),
                  metricsCollector);
      }
  
      @Override
      protected DirectExternalCache<String> obtainDirectCache(String name, ExternalCacheSettings settings) {
          final Cache<String, IdentifiedData> delegate = cacheFactory.getCache(name);
          return new LegacyDirectExternalCache<>(
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshalling,
                  new LegacyServiceSettingsBuilder().build());
      }
  
      @Ignore("CAS Operations do not work in this configuration")
      @Override
      public void dual_cache_get_set() throws ExecutionException, InterruptedException {
      }
  
      @Ignore("CAS Operations do not work in this configuration")
      @Override
      public void dual_cache_get_with_supplier_take2() throws ExecutionException, InterruptedException {
      }
  }