/**
    * This file Copyright (c) 2014-2016 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.cms.util;
  
  import info.magnolia.context.MgnlContext;
  import info.magnolia.observation.WorkspaceEventListenerRegistration;
  
  import javax.jcr.RepositoryException;
  import javax.jcr.observation.Event;
  import javax.jcr.observation.EventIterator;
  import javax.jcr.observation.EventListener;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Manager that enables observing a specific workspace and specific node types.
   */
  public abstract class WorkspaceObservingManager {
  
      private static final Logger log = LoggerFactory.getLogger(WorkspaceObservingManager.class);
      private final Object reloadMonitor = new Object();
  
      private final String workspace;
      private final boolean includeSubNodes;
      private final String[] nodeTypes;
      private final String observedPath;
      private final int eventTypesMask;
  
      private long delay = 1000;
      private long maxDelay = 5000;
  
      private WorkspaceEventListenerRegistration.Handle handle = null;
  
      public WorkspaceObservingManager(String workspace, String observedPath, boolean includeSubNodes, String[] nodeTypes, int eventTypesMask) {
          this.workspace = workspace;
          this.observedPath = observedPath;
          this.includeSubNodes = includeSubNodes;
          this.nodeTypes = nodeTypes;
          this.eventTypesMask = eventTypesMask;
      }
  
      public WorkspaceObservingManager(String workspace, String observedPath, boolean includeSubNodes, String[] nodeTypes) {
          this(workspace, observedPath, includeSubNodes, nodeTypes, Event.NODE_ADDED | Event.NODE_REMOVED | Event.NODE_MOVED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED);
      }
  
      public WorkspaceObservingManager(String workspace, String observedPath, boolean includeSubNodes, String nodeType) {
          this(workspace, observedPath, includeSubNodes, nodeType == null ? null : new String[]{nodeType});
      }
  
      public void start() {
          onStart();
  
          registerChangeListener(instantiateEventListener());
  
          synchronized (reloadMonitor) {
              try {
                  reload();
              } catch (RepositoryException e) {
                  log.error("Error reloading", e);
              }
          }
      }
  
      protected void onStart() {
          // just in case if #start() is invoked multiple times unregister listener
          if (handle != null) {
              try {
                 handle.unregister();
             } catch (RepositoryException e) {
                 log.error("Unable to remove event listener from workspace {}", workspace, e);
             }
         }
     }
 
     protected void registerChangeListener(final EventListener eventListener) {
         try {
             handle = WorkspaceEventListenerRegistration.observe(workspace, observedPath, eventListener)
                     .withSubNodes(isIncludeSubNodes())
                     .withNodeTypes(getNodeTypes())
                     .withEventTypesMask(getEventTypesMask())
                     .withDelay(getDelay(), getMaxDelay())
                     .register();
         } catch (RepositoryException e) {
             log.warn("Error occurred during registration of an event listener", e);
         }
     }
 
     protected EventListener instantiateEventListener() {
         return new EventListener() {
             @Override
             public void onEvent(EventIterator events) {
                 synchronized (reloadMonitor) {
                     MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
                         @Override
                         public void doExec() {
                             try {
                                 reload();
                             } catch (RepositoryException e) {
                                 log.error("Error reloading", e);
                             }
                         }
                     }, true);
                 }
             }
         };
     }
 
     protected abstract void reload() throws RepositoryException;
 
     protected String getWorkspace() {
         return workspace;
     }
 
     protected boolean isIncludeSubNodes() {
         return includeSubNodes;
     }
 
     protected String[] getNodeTypes() {
         return nodeTypes;
     }
 
     protected String getObservedPath() {
         return observedPath;
     }
 
     protected int getEventTypesMask() {
         return eventTypesMask;
     }
 
     /**
      * Returns the object used to synchronize on to keep multiple reload operations to occur at the same time. Useful
      * in subclasses to block calls while the reload is in progress.
      */
     protected Object getReloadMonitor() {
         return reloadMonitor;
     }
 
     public long getDelay() {
         return delay;
     }
 
     /**
      * Sets the delay of the deferred {@link EventListener}.
      * Make sure to call this method before calling {@link #start()}.
      */
     public void setDelay(long delay) {
         this.delay = delay;
     }
 
     public long getMaxDelay() {
         return maxDelay;
     }
 
     /**
      * Sets the maximum delay of the deferred {@link EventListener}.
      * Make sure to call this method before calling {@link #start()}.
      */
     public void setMaxDelay(long maxDelay) {
         this.maxDelay = maxDelay;
     }
 
 }