/**
    * This file Copyright (c) 2008-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.cache.cachepolicy;
  
  import info.magnolia.cms.cache.CacheConstants;
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.context.WebContext;
  import info.magnolia.module.cache.Cache;
  import info.magnolia.module.cache.CacheModule;
  import info.magnolia.module.cache.CachePolicy;
  import info.magnolia.module.cache.CachePolicyResult;
  import info.magnolia.module.cache.FlushPolicy;
  import info.magnolia.module.cache.cachekey.CacheKeyGenerator;
  import info.magnolia.module.cache.cachekey.DefaultCacheKey;
  import info.magnolia.module.cache.cachekey.DefaultCacheKeyGenerator;
  import info.magnolia.module.cache.cachepolicy.instructor.CacheInstructor;
  import info.magnolia.module.cache.cachepolicy.voters.BrowserTtlVoter;
  import info.magnolia.module.cache.cachepolicy.voters.ServerTtlVoter;
  import info.magnolia.module.cache.cachepolicy.voters.TtlVoting;
  import info.magnolia.module.cache.filter.CacheResponseWrapper;
  import info.magnolia.module.cache.filter.UncacheableEntry;
  import info.magnolia.voting.voters.VoterSet;
  
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Set;
  import java.util.function.BiConsumer;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * A basic CachePolicy driven by shouldBypassVoters. This policy implementation uses {@link info.magnolia.module.cache.cachekey.DefaultCacheKey} to identify each cache entry.
   */
  public class Default implements CachePolicy {
  
      public static final String UUID_KEY_MAP_KEY = "uuid-key-mapping";
      private static final Logger log = LoggerFactory.getLogger(Default.class);
  
      private CacheKeyGenerator<?> cacheKeyGenerator = new DefaultCacheKeyGenerator();
      private VoterSet shouldBypassVoters;
      private VoterSet<CacheResponseWrapper> ttlVoters = new VoterSet<>();
  
      private boolean refreshOnNoCacheRequests = false;
  
      private final CacheModule cacheModule;
      private final Provider<CacheInstructor> cacheInstructorProvider;
  
      @Inject
      public Default(CacheModule cacheModule, Provider<CacheInstructor> cacheInstructorProvider) {
          this.cacheModule = cacheModule;
          this.cacheInstructorProvider = cacheInstructorProvider;
          ttlVoters.setVoting(new TtlVoting());
          ttlVoters.addVoter(new ServerTtlVoter(cacheInstructorProvider));
          ttlVoters.addVoter(new BrowserTtlVoter());
      }
  
  
      @Override
      public CachePolicyResult shouldCache(final Cache cache, final AggregationState aggregationState, final FlushPolicy flushPolicy) {
          final Object key = retrieveCacheKey(aggregationState);
  
          if (shouldBypass(aggregationState, key)) {
              return new CachePolicyResult(CachePolicyResult.bypass, key, null);
         }
 
         if (shouldRefresh(aggregationState, key)) {
             log.debug("Cache refresh requested for {}", key);
             return new CachePolicyResult(CachePolicyResult.store, key, null);
         }
 
         // no multithreaded expiring cache can guarantee existence of the key between two subsequent calls without synchronization here on common object or mutex
         // and synchronization on the cache is too heavy weight
         // if (cache.hasElement(key)) {
         // final Object entry = cache.get(key);
         // ... so unless having mutexes for our own cache keys and being able to synchronize on that
         // simply make sure there is just one call ... ever. Either underlying cache has it's own key-mutex system (like ehCache) or
         // stale value returned by cache might result in entries being generated multiple times or served stale for while ... so choose your underlying cache impl carefully
         // either way, Magnolia should not need to care nor should it play a police for cache implementation
 
         // for default cache impl (blocking ehCache) this call will block on given key, and on given key only, if previously requested until value is available or timeout occurs
         final Object cachedEntry = cache.get(key);
         // also assume that if the value can't be retrieved for given key, underlying cache is not a pig and will throw exception at some point releasing the thread and propagating the error to the user
 
         if (cachedEntry != null) {
             if (cachedEntry instanceof UncacheableEntry) {
                 return new CachePolicyResult(CachePolicyResult.bypass, key, null);
             } else {
                 return new CachePolicyResult(CachePolicyResult.useCache, key, cachedEntry);
             }
         }
         return new CachePolicyResult(CachePolicyResult.store, key, null);
     }
 
     /**
      * Checks whether requested content should be served from cache or refreshed instead.
      *
      * @return True if cache entry for the key should be recreated, false otherwise.
      */
     protected boolean shouldRefresh(AggregationState aggregationState, Object key) {
         if (isRefreshOnNoCacheRequests()) {
             String cacheControl = ((WebContext) MgnlContext.getInstance()).getRequest().getHeader(CacheConstants.HEADER_CACHE_CONTROL);
             String pragma = ((WebContext) MgnlContext.getInstance()).getRequest().getHeader(CacheConstants.HEADER_PRAGMA);
             return (cacheControl != null && cacheControl.equals(CacheConstants.HEADER_VALUE_NO_CACHE)) || (pragma != null && pragma.equals(CacheConstants.HEADER_VALUE_NO_CACHE));
         }
         return false;
     }
 
     protected boolean shouldBypass(AggregationState aggregationState, Object key) {
         final String uri;
         if (key instanceof DefaultCacheKey) {
             uri = ((DefaultCacheKey) key).getUri();
         } else {
             uri = key.toString();
         }
         // true if shouldBypassVoters vote positively
         if (shouldBypassVoters != null) {
             return shouldBypassVoters.vote(uri) <= 0;
         }
         log.warn("No cache voter defined.");
         return false;
     }
 
     public Object retrieveCacheKey(final AggregationState aggregationState) {
         CacheKeyGenerator<?> cacheKeyGenerator = cacheInstructorProvider.get().getKeyGenerator();
         if (cacheKeyGenerator == null) {
             cacheKeyGenerator = getCacheKeyGenerator();
         }
         return cacheKeyGenerator.generateKey(aggregationState);
     }
 
     @Override
     public Object[] retrieveCacheKeys(final String uuid, final String repository) {
         final String uuidKey = repository + ":" + uuid;
         final Set<Object> keys = getUUIDKeySetFromCacheSafely(uuidKey);
         return keys.toArray();
     }
 
     @Override
     public void persistCacheKey(final String repo, final String uuid, final Object key) {
         final String uuidKey = repo + ":" + uuid;
         final Cache cache = getUuidKeyCache();
         // need to be thread safe to prevent losing keys added by other threads while manipulating collection
         threadSafeUUIDCacheOp(cache, uuidKey, (c, k) -> {
             k.add(key);
             c.put(uuidKey, k);
         });
     }
 
     private Set<Object> threadSafeUUIDCacheOp(final Cache cache, final String uuidKey, final BiConsumer<Cache, Set<Object>> c) {
         synchronized (cache) {
             Set<Object> keys = (Set<Object>) cache.get(uuidKey);
             if (keys == null) {
                 keys = Collections.synchronizedSet(new HashSet<>());
             }
             c.accept(cache, keys);
             return keys;
         }
     }
 
     @Override
     public Object[] removeCacheKeys(final String uuid, final String repository) {
         final String uuidKey = repository + ":" + uuid;
         final Cache cache = getUuidKeyCache();
         // need to be thread safe to prevent losing keys added by other threads while manipulating collection
         return threadSafeUUIDCacheOp(cache, uuidKey, (c, k) -> c.remove(uuidKey)).toArray();
     }
 
     private Cache getUuidKeyCache() {
         return cacheModule.getCacheFactory().getCache(UUID_KEY_MAP_KEY);
     }
 
     /**
      * Method to safely (without danger of blocking cache) obtain persistent mapping between UUIDs and cache keys.
      * Obtained mapping is a __COPY__ of actual mapping in cache. Any changes to it are __NOT__ persisted in cache itself!!!
      */
     private synchronized Set<Object> getUUIDKeySetFromCacheSafely(String uuidKey) {
         final Cache cache = getUuidKeyCache();
         synchronized (cache) {
             // need to be thread safe to prevent loosing keys added by other threads while manipulating collection
             return threadSafeUUIDCacheOp(cache, uuidKey, (c, k) -> c.put(uuidKey, k));
         }
     }
 
     public boolean isRefreshOnNoCacheRequests() {
         return this.refreshOnNoCacheRequests;
     }
 
     public void setRefreshOnNoCacheRequests(boolean allowNoCacheHeader) {
         this.refreshOnNoCacheRequests = allowNoCacheHeader;
     }
 
     @Override
     public VoterSet<CacheResponseWrapper> getTtlVoters() {
         return ttlVoters;
     }
 
     public void setTtlVoters(VoterSet<CacheResponseWrapper> ttlVoters) {
         this.ttlVoters = ttlVoters;
     }
 
     public VoterSet getShouldBypassVoters() {
         return shouldBypassVoters;
     }
 
     public void setShouldBypassVoters(VoterSet shouldBypassVoters) {
         this.shouldBypassVoters = shouldBypassVoters;
     }
 
     public CacheKeyGenerator<?> getCacheKeyGenerator() {
         return cacheKeyGenerator;
     }
 
     public void setCacheKeyGenerator(CacheKeyGenerator<?> cacheKeyGenerator) {
         this.cacheKeyGenerator = cacheKeyGenerator;
     }
 }