package com.trendmicro.grid.acl.ds.cache.aspects;
   
   import com.trendmicro.grid.acl.ds.cache.CacheSettings;
   import com.trendmicro.grid.acl.ds.cache.ThirdLevelCacheStatisticsSummary;
   import com.trendmicro.grid.acl.l0.datatypes.Tagged;
   import net.sf.tinyjee.cache.config.CacheRegion;
   import net.sf.tinyjee.cache.config.CacheRegions;
   
   import javax.annotation.Resource;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Map;
  import java.util.concurrent.Callable;
  
  import static com.trendmicro.grid.acl.ds.cache.CacheDestination.Mode;
  import static java.util.concurrent.TimeUnit.HOURS;
  import static java.util.concurrent.TimeUnit.MINUTES;
  import static net.sf.tinyjee.cache.config.DistributionPolicy.DISTRIBUTE_VALUES;
  import static net.sf.tinyjee.cache.config.DistributionPolicy.REPLICATE_VALUES;
  import static net.sf.tinyjee.cache.config.EvictionPolicy.LIRS;
  import static net.sf.tinyjee.cache.config.PersistentMode.TEMPORARY;
  
  /**
   * Is the base to all aspects that deal with caching and defines all cache regions at a central location.
   *
   * @author Juergen_Kellerer, 2011-02-19
   * @version 1.0
   */
  @CacheRegions({
  		// START-SNIPPET: 3rdLevelCacheRegions
  		@CacheRegion(name = CacheSettings.CACHE_REGION_FILE_DETAILS,
  				// Using 4% of heap to cache file details (assuming an entry weights 2kb).
  				// At least 250 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(250, memoryPercent(5) / kb(2))}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = DISTRIBUTE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
  				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
  				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 6000}", defaultExpirationTimeUnit = MINUTES),
  
  		@CacheRegion(name = CacheSettings.CACHE_REGION_FILE_INFORMATION,
  				// Using 15% of heap to cache file information (assuming an entry weights 256b).
  				// At least 250 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(250, memoryPercent(15) / 256)}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = DISTRIBUTE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
  				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
  				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 6000}", defaultExpirationTimeUnit = MINUTES),
  
  		@CacheRegion(name = CacheSettings.CACHE_REGION_PACKAGE_DETAILS,
  				// Using 2% of heap to cache package details (assuming an entry weights 4kb).
  				// At least 250 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(250, memoryPercent(3) / kb(4))}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = DISTRIBUTE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
  				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
  				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 6000}", defaultExpirationTimeUnit = MINUTES),
  
  		@CacheRegion(name = CacheSettings.CACHE_REGION_PACKAGE_INFORMATION,
  				// Using 4% of heap to cache package information (assuming an entry weights 512b).
  				// At least 250 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(250, memoryPercent(5) / 512)}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = DISTRIBUTE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
  				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
  				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 6000}", defaultExpirationTimeUnit = MINUTES),
  
  		@CacheRegion(name = CacheSettings.CACHE_REGION_PACKAGE_FILE_IDENTIFIERS,
  				// Using 2% of heap to cache package name to id mapping (assuming an entry weights 128b).
  				// At least 250 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(250, memoryPercent(2) / 128)}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = REPLICATE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
  				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
  				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 6000}", defaultExpirationTimeUnit = MINUTES),
  
  		@CacheRegion(name = CacheSettings.CACHE_REGION_UNKNOWN_FILE_IDENTIFIERS,
  				// Using 0.5% of heap to cache unknown identifiers (assuming an entry weights 64b).
  				// At least 512 entries are kept in memory.
  				maxElementsInMemoryExpression = "${max(512, memoryPercent(0.5) / 64)}",
  				persistentMode = TEMPORARY,
  				evictionPolicy = LIRS,
  				distributionPolicy = REPLICATE_VALUES,
  				// Clean entries if not accessed for 6 hours
  				idleTime = 6, idleTimeUnit = HOURS,
 				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
 				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 120}", defaultExpirationTimeUnit = MINUTES),
 
 		@CacheRegion(name = CacheSettings.CACHE_REGION_UNKNOWN_NAMES,
 				// Using 0.5% of heap to cache unknown names (assuming an entry weights 64b).
 				// At least 512 entries are kept in memory.
 				maxElementsInMemoryExpression = "${max(512, memoryPercent(0.5) / 64)}",
 				persistentMode = TEMPORARY,
 				evictionPolicy = LIRS,
 				distributionPolicy = REPLICATE_VALUES,
 				// Clean entries if not accessed for 6 hours
 				idleTime = 6, idleTimeUnit = HOURS,
 				// Expire entries after 15 minutes if we're not running clustered or in 'readonly' mode.
 				defaultExpirationTimeExpression = "${not runClustered || readonly ? 15 : 120}", defaultExpirationTimeUnit = MINUTES)
 		// END-SNIPPET: 3rdLevelCacheRegions
 })
 public abstract class AbstractCacheAspect {
 
 	public static <V> Callable<Collection<V>> chainOf(final Callable<V>... callables) {
 		return new Callable<Collection<V>>() {
 			@Override
 			public Collection<V> call() throws Exception {
 				final Collection<V> results = new ArrayList<V>(callables.length);
 				for (Callable<V> callable : callables) results.add(callable.call());
 
 				return results;
 			}
 		};
 	}
 
 	public static <V> Callable<V> ofFirst(final Callable<V> first, final Callable... runAfters) {
 		return new Callable<V>() {
 			@Override
 			public V call() throws Exception {
 				try {
 					return first.call();
 				} finally {
 					for (Callable runAfter : runAfters) runAfter.call();
 				}
 			}
 		};
 	}
 
 	public static <K, V> Collection<V> call(Callable<Map<K, V>> callable) throws Exception {
 		return callable.call().values();
 	}
 
 	/**
 	 * Returns true if the element is tagged with the given tags.
 	 *
 	 * @param element the element to check.
 	 * @param tags    the tags to verify.
 	 * @return true if the element contains all the tags, false if not, 'null' if the element was 'null'.
 	 */
 	protected static Boolean isTaggedWith(Tagged element, String[] tags) {
 		if (element == null)
 			return null;
 		else {
 			for (String tag : tags) {
 				boolean invert = tag.startsWith("-");
 				boolean containsTag = element.containsTag(invert ? tag.substring(1) : tag);
 				if (invert ? containsTag : !containsTag) return false;
 			}
 			return true;
 		}
 	}
 
 	@Resource
 	private ThirdLevelCacheStatisticsSummary cacheStatistics;
 
 	final boolean sync = CacheSettings.IS_SYNCHRONOUS;
 
 	final Mode cacheWriteMode = Mode.Put; // Mode.putIfAbsent - would be enough but is not stable in unit tests.
 
 	public ThirdLevelCacheStatisticsSummary getCacheStatistics() {
 		return cacheStatistics;
 	}
 
 	public boolean isSync() {
 		return sync;
 	}
 
 	public Mode getCacheWriteMode() {
 		return cacheWriteMode;
 	}
 }