/**
    * This file Copyright (c) 2008-2015 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;
  
  import info.magnolia.cms.util.DeprecationUtil;
  import info.magnolia.cms.util.ObservationUtil;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.repository.RepositoryManager;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.inject.Inject;
  import javax.jcr.RepositoryException;
  import javax.jcr.observation.Event;
  import javax.jcr.observation.EventIterator;
  import javax.jcr.observation.EventListener;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Implemenation of the <code>FlushPolicy</code> providing functionality for triggering flush operation based on changes in observed workspaces.
   */
  public abstract class AbstractListeningFlushPolicy implements FlushPolicy {
  
      private static final Logger log = LoggerFactory.getLogger(AbstractListeningFlushPolicy.class);
  
      private List<String> workspaces;
      private List<String> excludedWorkspaces = new ArrayList<String>();
      private Map<String, EventListener> registeredListeners = new HashMap<>();
  
      private final CacheModule cacheModule;
      private final RepositoryManager repositoryManager;
  
      /**
       * @deprecated since 5.4. Use {@link #AbstractListeningFlushPolicy(CacheModule, RepositoryManager)} instead.
       */
      public AbstractListeningFlushPolicy() {
          this.cacheModule = Components.getComponent(CacheModule.class);
          this.repositoryManager = Components.getComponent(RepositoryManager.class);
      }
  
      @Inject
      public AbstractListeningFlushPolicy(CacheModule cacheModule, RepositoryManager repositoryManager) {
          this.cacheModule = cacheModule;
          this.repositoryManager = repositoryManager;
      }
  
      @Override
      public void start(Cache cache) {
          for (Iterator<String> iter = this.getWorkspacesToProcess().iterator(); iter.hasNext(); ) {
              final String workspace = iter.next();
              try {
                  if (repositoryManager.getWorkspaceMapping(workspace) != null) {
                      final CacheCleaner cacheCleaner = new CacheCleaner(cache, workspace);
                      final EventListener listener = ObservationUtil.instanciateDeferredEventListener(cacheCleaner, 5000, 30000);
                      final String path = this.getPath(cache);
                      ObservationUtil.registerChangeListener(workspace, path, listener);
                      registeredListeners.put(workspace + ":" + path, listener);
                  }
              } catch (Exception e) {
                  log.warn("Failed to register cache flushing observation for workspace '{}'. "
                          + "Publishing any content to this workspace will not result in update of the cache. Please flush the cache manually.", workspace, e.getMessage());
             }
         }
     }
 
     protected String getPath(Cache cache) {
         return "/";
     }
 
     @Override
     public void stop(Cache cache) {
         for (Map.Entry<String, EventListener> entry : registeredListeners.entrySet()) {
             if (entry.getValue() == null) {
                 // happens on restart of cache module after someone configures new listener repository ... we are trying to stop the listener which was not created yet
                 continue;
             }
             ObservationUtil.unregisterChangeListener(StringUtils.substringBefore(entry.getKey(), ":"), entry.getValue());
         }
     }
 
     private List<String> getWorkspacesToProcess() {
         if (this.getWorkspaces() != null) {
             return this.getWorkspaces();
         } else {
             ArrayList<String> workspaces = new ArrayList<String>(repositoryManager.getWorkspaceNames());
             workspaces.removeAll(this.getExcludedWorkspaces());
             return workspaces;
         }
     }
 
     /**
      * Implement this method to react on buffered events on a given cache and repository.
      *
      * @return true if single events should be processed as well, false otherwise.
      */
     protected abstract boolean preHandleEvents(Cache cache, String repository);
 
     /**
      * Implement this method to wrap up flushing process after all single events have been processed.
      * This method will be invoked only if {@link #preHandleEvents(Cache, String)} returns true;
      */
     protected abstract void postHandleEvents(Cache cache, String repository);
 
     /**
      * Implement this method to react on each and every event on a given cache and repository,
      * even if multiple where buffered.
      * This method will be invoked only if {@link #preHandleEvents(Cache, String)} returns true;
      */
     protected abstract void handleSingleEvent(Cache cache, String repository, Event event);
 
     /**
      * Flushes all content related to given uuid&repository combination from provided cache.
      * Note that more then only one pages can be flushed when this method is called.
      */
     protected void flushByUUID(String uuid, String repository, Cache cache) {
 
         final ContentCachingConfiguration config = cacheModule.getContentCaching(cache.getName());
         final CachePolicy policy = config.getCachePolicy();
         if (policy == null) {
             // no cache policy, no cache key, nothing to flush here ...
             return;
         }
         // do NOT remove key mappings, just retrieve them. Rather try remove not existent items then leaving entries in other caches that might depend on the same mapping
         Object[] cacheEntryKeys = config.getCachePolicy().retrieveCacheKeys(uuid, repository);
         log.debug("Flushing {} due to detected content {}:{} update.", cacheEntryKeys, repository, uuid);
 
         if (cacheEntryKeys == null || cacheEntryKeys.length == 0) {
             // nothing to remove
             return;
         }
         for (Object key : cacheEntryKeys) {
             cache.remove(key);
         }
         // we are done here
     }
 
     /**
      * Event listener triggering the cleanup of the cache.
      */
     protected class CacheCleaner implements EventListener {
         private final Cache cache;
         private final String repository;
 
         public CacheCleaner(Cache cache, String repository) {
             this.cache = cache;
             this.repository = repository;
         }
 
         @Override
         public void onEvent(EventIterator events) {
             List<Event> eventList = new ArrayList<Event>();
             // do not react on jcr: specific events. Those are sent to every registered workspace when any of the workspaces stores new version of its content
             while (events.hasNext()) {
                 final Event event = events.nextEvent();
                 try {
                     if (!event.getPath().startsWith("/jcr:")) {
                         eventList.add(event);
                     }
                 } catch (RepositoryException e) {
                     log.warn("Failed to process an event {}, the observation based cache flushing might not have been fully completed.", event.toString());
                 }
             }
             if (eventList.isEmpty()) {
                 return;
             }
             // if there are still any events left, continue here
             boolean shouldContinue = preHandleEvents(cache, repository);
             if (shouldContinue) {
                 for (Event event : eventList) {
                     handleSingleEvent(cache, repository, event);
                 }
                 postHandleEvents(cache, repository);
             }
         }
     }
 
     // --------- config methods below
 
     /**
      * The workspaces to which the listener is attached - upon any event on these,
      * the cache is cleared.
      */
     public List<String> getWorkspaces() {
         return workspaces;
     }
 
     public void setWorkspaces(List<String> workspaces) {
         if (!this.getExcludedWorkspaces().isEmpty()) {
             log.error("You should configure only 'workspaces' or 'excludedWorkspaces' on {}. Not both of them.", this.getClass());
             return;
         }
         this.workspaces = workspaces;
     }
 
     /**
      * The workspaces to which the listener is NOT attached.
      */
     public List<String> getExcludedWorkspaces() {
         return excludedWorkspaces;
     }
 
     public void setExcludedWorkspaces(List<String> excludedWorkspaces) {
         if (this.getWorkspaces() != null) {
             log.error("You should configure only 'workspaces' or 'excludedWorkspaces' on {}. Not both of them.", this.getClass());
             return;
         }
         this.excludedWorkspaces = excludedWorkspaces;
     }
 
     /**
      * @deprecated since 5.4. Use {@link #getWorkspaces()} instead.
      */
     public List<String> getRepositories() {
         DeprecationUtil.isDeprecated("Use info.magnolia.module.cache.AbstractListeningFlushPolicy#getWorkspaces instead.");
         return this.getWorkspaces();
     }
 
     /**
      * @deprecated since 5.4. Use {@link #setWorkspaces(List)} instead.
      */
     public void setRepositories(List<String> repositories) {
         DeprecationUtil.isDeprecated("Use info.magnolia.module.cache.AbstractListeningFlushPolicy#setWorkspaces instead.");
         this.setWorkspaces(repositories);
     }
 
     /**
      * @deprecated since 5.4. Use {@link #setWorkspaces(List)} instead.
      */
     public void addRepository(String repository) {
         DeprecationUtil.isDeprecated("Use info.magnolia.module.cache.AbstractListeningFlushPolicy#setWorkspaces instead.");
         workspaces.add(repository);
     }
 }