package com.atlassian.cache.hazelcast;
   
   import java.util.Random;
   
   import com.atlassian.cache.CacheSettings;
   
   import com.hazelcast.config.EvictionPolicy;
   import com.hazelcast.config.MapConfig;
   import com.hazelcast.config.MaxSizeConfig;
  import com.hazelcast.config.NearCacheConfig;
  
  import static com.hazelcast.config.MaxSizeConfig.MaxSizePolicy.PER_NODE;
  
  /**
   * Performs the (re)configuration of Hazelcast {@link MapConfig} objects.
   *
   * @since 2.4.0
   */
  public class HazelcastMapConfigConfigurator
  {
      // If the cache is a hybrid cache, only the entry versions are tracked in the IMap. These versions should remain
      // cached longer than the values in local caches. A multiplier is applied to the config parameters that affect
      // cache eviction to enforce this.
      public static final int HYBRID_MULTIPLIER = 2;
  
      public static final int NEAR_CACHE_EXPIRY_RATIO = Integer.getInteger("atlassian.cache.nearCacheExpiryRatio", 75);
  
      public MapConfig configureMapConfig(CacheSettings settings, MapConfig mapConfig)
      {
          boolean hybrid = !settings.getReplicateViaCopy(true);
          Integer multiplier = hybrid ? HYBRID_MULTIPLIER : 1;
          Integer maxEntries = settings.getMaxEntries();
  
          final NearCacheConfig nearCacheConfig = mapConfig.getNearCacheConfig() == null ?
                  new NearCacheConfig() :
                  new NearCacheConfig(mapConfig.getNearCacheConfig());
  
          if (maxEntries != null)
          {
              final int maxSize = multiplier * maxEntries;
  
              mapConfig.setMaxSizeConfig(new MaxSizeConfig().setMaxSizePolicy(PER_NODE).setSize(maxSize));
              mapConfig.setEvictionPolicy(EvictionPolicy.LFU);
  
              nearCacheConfig.setMaxSize(maxSize);
              nearCacheConfig.setEvictionPolicy(EvictionPolicy.LFU.name());
          }
  
          final Long expireAfterAccess = settings.getExpireAfterAccess();
          if (expireAfterAccess != null)
          {
              final int maxIdleSeconds = multiplier * roundUpToWholeSeconds(expireAfterAccess);
  
              mapConfig.setMaxIdleSeconds(maxIdleSeconds);
  
              // Near-cache hits don't reset the last-accessed timestamp on the underlying IMap entry.
              // So make the near cache have a TTL that is less than the maxIdle of the IMap:
              //
              // nearCacheTTL = (0.75 + jitter) * maxIdleSeconds
              //
              // That way the near cache entry will always expire before the IMap - calling back through
              // and refreshing the IMap idle timer. We also add some random jitter (+ or - 0.15) so all nodes don't expire
              // at the same time.
  
              int jitter = new Random().nextInt(30) - 15;
              int nearCacheTtl = (int) Math.round(((NEAR_CACHE_EXPIRY_RATIO + jitter) * maxIdleSeconds) / 100.0);
              nearCacheConfig.setTimeToLiveSeconds(Math.max(1, nearCacheTtl));
          }
  
          final Long expireAfterWrite = settings.getExpireAfterWrite();
          if (expireAfterWrite != null)
          {
              final int timeToLiveSeconds = multiplier * roundUpToWholeSeconds(expireAfterWrite);
  
              mapConfig.setTimeToLiveSeconds(timeToLiveSeconds);
  
              nearCacheConfig.setTimeToLiveSeconds(timeToLiveSeconds);
          }
  
          final boolean nearCache = settings.getReplicateAsynchronously(true);
          if (nearCache)
          {
              mapConfig.setNearCacheConfig(nearCacheConfig);
          }
          else
          {
              mapConfig.setNearCacheConfig(null);
          }
  
          return mapConfig;
      }
  
      private static int roundUpToWholeSeconds(final Long expireAfterAccess)
      {
          return (int) Math.ceil(expireAfterAccess / 1000d);
      }
  }