/**
    * This file Copyright (c) 2014-2017 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.dirwatch;
  
  import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
  import static java.nio.file.StandardWatchEventKinds.*;
  
  import info.magnolia.cms.util.ExceptionUtil;
  import info.magnolia.init.MagnoliaConfigurationProperties;
  import info.magnolia.objectfactory.Components;
  
  import java.io.IOException;
  import java.nio.file.FileSystems;
  import java.nio.file.FileVisitOption;
  import java.nio.file.FileVisitResult;
  import java.nio.file.Files;
  import java.nio.file.LinkOption;
  import java.nio.file.Path;
  import java.nio.file.SimpleFileVisitor;
  import java.nio.file.WatchEvent;
  import java.nio.file.WatchKey;
  import java.nio.file.WatchService;
  import java.nio.file.attribute.BasicFileAttributes;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang3.EnumUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Predicate;
  
  /**
   * The {@link DirectoryWatcher} covers implementation of the low level WatchService API.
   * <p>
   * Highly inspired by http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/essential/io/examples/WatchDir.java
   * Since java.nio.file.Watch* is not guaranteed to be using native events, we'll probably want to extract an interface for this. (non-native implementations use polling and can be quite slow)
   * JDK on OSX doesn't have a native impl for 7 or 8: https://bugs.openjdk.java.net/browse/JDK-7133447
   * See http://wiki.netbeans.org/NativeFileNotifications
   * https://code.google.com/p/barbarywatchservice/
   */
  public class DirectoryWatcher implements Runnable {
  
      private static final Logger log = LoggerFactory.getLogger(DirectoryWatcher.class);
  
      private static final String WATCHER_SENSITIVITY = "magnolia.resources.watcher.sensitivity";
      private static final String DEFAULT_WATCHER_SENSITIVITY_VALUE = "high";
  
      private final WatchService watcher;
      private final Map<WatchKey, Path> keys = new HashMap<>();
  
      private final boolean recursive;
      private final boolean followSymLinks;
      private final List<WatcherRegistration> registrations = new ArrayList<>();
      private final boolean devMode;
      private final String watcherSensitivity;
  
      public DirectoryWatcher(boolean recursive, boolean followLinks, MagnoliaConfigurationProperties properties) throws IOException {
          this.recursive = recursive;
          this.followSymLinks = followLinks;
          this.watcher = FileSystems.getDefault().newWatchService();
          this.devMode = properties.getBooleanProperty("magnolia.develop");
          this.watcherSensitivity = getWatcherSensitivity(properties.getProperty(WATCHER_SENSITIVITY), DEFAULT_WATCHER_SENSITIVITY_VALUE);
      }
 
     /**
      * @deprecated Since 5.4.5, Please use {@link #DirectoryWatcher(boolean, boolean, MagnoliaConfigurationProperties)} instead.
      */
     @Deprecated
     public DirectoryWatcher(boolean recursive, boolean followLinks) throws IOException {
         this(recursive, followLinks, Components.getComponent(MagnoliaConfigurationProperties.class));
     }
 
     public void register(Path dir, Predicate<Path> filterPredicate, WatcherCallback callback) throws IOException {
         if (recursive) {
             log.debug("Scanning {}", dir);
             registerRecursively(dir, filterPredicate);
             log.debug("Done scanning {}", dir);
         } else {
             registerDirectory(dir);
         }
         registrations.add(new WatcherRegistration(dir, filterPredicate, callback));
     }
 
     /**
      * Register the given directory with the WatchService.
      */
     protected void registerDirectory(Path dir) throws IOException {
         final WatchKey key = dir.register(watcher, new WatchEvent.Kind[]{ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY}, getWatchEventModifiers(watcher));
         // Would have used ExtendedWatchEventModifier.FILE_TREE, but it's not supported on osx nor linux;
         // AFAIK, there is no way to query the WatchService to see if it supports a given modifier without passing it and getting an UnsupportedOperationException thrown at us, so...
         // Presumably, this is why we do recursion ourselves in here
 
         if (log.isDebugEnabled()) {
             Path prev = keys.get(key);
             if (prev == null) {
                 log.debug("* register: {}", dir);
             } else {
                 log.debug("* update: {} -> {}", prev, dir);
             }
         }
         keys.put(key, dir);
     }
 
     protected WatchEvent.Modifier[] getWatchEventModifiers(WatchService watchService) {
         // Improve watcher performance on OSX by using com.sun.nio.file.SensitivityWatchEventModifier if available.
         try {
             // If the WatchService is a PollingWatchService, which it is on OS X, AIX and Solaris prior to version 11
             Class<?> pollingWatchService = Class.forName("sun.nio.fs.PollingWatchService");
             if (pollingWatchService.isInstance(watchService)) {
                 // Try to find enum value of SensitivityWatchEventModifier in magnolia.properties (high, medium, low)
                 // Use Class.forName to avoid importing sun package for the SensitivityWatchEventModifier
                 Class clazz = Class.forName("com.sun.nio.file.SensitivityWatchEventModifier");
                 // Get enum value of the modifier or if the value is wrong set it to high sensitivity
                 WatchEvent.Modifier sensitivityModifier = (WatchEvent.Modifier) EnumUtils.getEnum(clazz, StringUtils.upperCase(watcherSensitivity));
                 if (sensitivityModifier == null) {
                     sensitivityModifier = (WatchEvent.Modifier) EnumUtils.getEnum(clazz, "HIGH");
                 }
                 return new WatchEvent.Modifier[] { sensitivityModifier };
             }
         } catch (ClassNotFoundException ignored) {
             // This is expected on JVMs where PollingWatchService or SensitivityWatchEventModifier are not available
         }
         return new WatchEvent.Modifier[0];
     }
 
     /**
      * Register the given directory, and all its sub-directories, with the WatchService.
      */
     protected void registerRecursively(final Path start, final Predicate<Path> filterPredicate) throws IOException {
 
         // register directory and sub-directories
         Files.walkFileTree(start, this.followSymLinks ? Collections.singleton(FileVisitOption.FOLLOW_LINKS) : Collections.emptySet(), Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
 
             @Override
             public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                 if (!filterPredicate.apply(dir)) {
                     return FileVisitResult.SKIP_SUBTREE;
                 }
 
                 registerDirectory(dir);
                 return FileVisitResult.CONTINUE;
             }
 
             @Override
             public FileVisitResult visitFileFailed(Path file, IOException e) throws IOException {
                 log.warn("Visiting failed for {}", file);
                 return FileVisitResult.SKIP_SUBTREE;
             }
         });
     }
 
     @Override
     public void run() {
         try {
             while (!Thread.currentThread().isInterrupted()) {
 
                 // 1. wait for key to be signaled
                 final WatchKey key;
                 try {
                     key = watcher.take();
                 } catch (InterruptedException x) {
                     Thread.currentThread().interrupt();
                     return;
                 }
 
                 final Path dir = keys.get(key);
                 if (dir == null) {
                     log.debug("WatchKey not recognized!!");
                     continue;
                 }
 
                 // 2. retrieve each pending event for the key
                 final List<WatchEvent<?>> watchEvents = key.pollEvents();
                 log.debug("   {} events", watchEvents.size());
 
                 for (WatchEvent<?> event : watchEvents) {
                     final WatchEvent.Kind<?> kind = event.kind();
                     log.debug("event: {}", event);
                     log.debug("kind: {}", kind);
 
                     // TODO OVERFLOW indicates that events may been lost or discarded.
                     if (kind == OVERFLOW) {
                         continue;
                     }
 
                     final Path completePath = getCompletePath(dir, event);
                     log.debug("--> {} : {}: {}", Thread.currentThread(), event.kind().name(), completePath);
 
                     // 2a. register new directories
                     if (Files.isDirectory(completePath, this.followSymLinks ? new LinkOption[0] : new LinkOption[] {NOFOLLOW_LINKS})) {
                         if (recursive && (kind == ENTRY_CREATE || kind == ENTRY_MODIFY)) {
 
                             // Loop over registrations to re-register accordingly
                             try {
                                 for (WatcherRegistration registration : registrations) {
                                     if (!completePath.startsWith(registration.getRootPath())) {
                                         continue;
                                     }
                                     Predicate<Path> filterPredicate = registration.getFilterPredicate();
 
                                     if (!filterPredicate.apply(dir)) {
                                         continue;
                                     }
 
                                     registerRecursively(completePath, filterPredicate);
                                 }
                             } catch (IOException x) {
                                 log.warn("Unable to register all subdirectories because of the following exception:", x);
                             }
                         }
                         // TODO shouldn't we unregister deleted directories ?
                         log.debug(" --> watch keys {}", keys.values());
                     }
 
                     // 2b. process event
                     try {
                         processEvent(kind, completePath, event);
                     } catch (Throwable t) {
                         log.error("Exception when executing callback for {}: {}", event.context(), ExceptionUtil.exceptionToWords(t), t);
                         // if we throw here we kill the thread
                     }
                 }
 
                 // 3. reset key and remove from set if directory no longer accessible
                 boolean valid = key.reset();
                 if (!valid) {
                     keys.remove(key);
 
                     // all directories are inaccessible
                     if (keys.isEmpty()) {
                         break;
                     }
                 }
             }
 
         } catch (Throwable t) {
             log.error("Exception occurred in DirectoryWatcher: {}", t, t);
             throw t; // This kills the thread
         }
     }
 
     /**
      * Process given pending {@link WatchEvent} as needed.
      *
      * @param kind the event {@link WatchEvent.Kind kind}
      * @param completePath an absolute {@link Path} where the event occurred
      * @param watchEvent the raw event for further custom processing
      */
     protected void processEvent(final WatchEvent.Kind<?> kind, final Path completePath, final WatchEvent<?> watchEvent) {
         logEvent(kind, completePath);
 
         if (kind != ENTRY_CREATE && kind != ENTRY_MODIFY && kind != ENTRY_DELETE) {
             throw new RuntimeException("Unknown event type " + kind + " for " + completePath.toAbsolutePath().toString());
         }
 
         for (WatcherRegistration registration : registrations) {
             if (!completePath.startsWith(registration.getRootPath())) {
                 continue;
             }
 
             if (!registration.getFilterPredicate().apply(completePath)) {
                 continue;
             }
 
             WatcherCallback callback = registration.getCallback();
             if (kind == ENTRY_CREATE) {
                 callback.added(completePath);
             } else if (kind == ENTRY_DELETE) {
                 callback.removed(completePath);
             } else if (kind == ENTRY_MODIFY) {
                 callback.modified(completePath);
             }
         }
     }
 
     /**
      * Logs file system events, the severity of log statements depends on the state of {@link #devMode dev mode flag}:
      * <ul>
      * <li>if it is on - severity level is {@code INFO};</li>
      * <li>otherwise - severity level is {@code DEBUG}.</li>
      * </ul>
      */
     private void logEvent(WatchEvent.Kind<?> kind, Path completePath) {
         String message;
         final String resourceType;
         if (!Files.exists(completePath)) {
             resourceType = "File resource(s)";
         } else {
             resourceType = Files.isDirectory(completePath) ? "Directory" : "File resource";
         }
 
         if (kind == ENTRY_CREATE) {
             message = "{} added at [{}]";
         } else if (kind == ENTRY_DELETE) {
             message = "{} deleted at [{}]";
         } else if (kind == ENTRY_MODIFY) {
             message = "{} modified at [{}]";
         } else {
             message = String.format("{} event of unhandled type (%s) occurred at [{}]", kind);
         }
 
         if (devMode) {
             log.info(message, resourceType, completePath);
         } else {
             log.debug(message, resourceType, completePath);
         }
     }
 
     /**
      * WatchEvent.context() returns a Path relative to the watchKey it was created for; we reconstruct it here.
      */
     private Path getCompletePath(Path parent, WatchEvent<?> watchEvent) {
         // Theoretically, there could be events with other types than Path. Practically, not so sure.
         final Path path = cast(watchEvent).context();
         return parent.resolve(path);
     }
 
     private String getWatcherSensitivity(String property, String defaultValue) {
         if (StringUtils.isBlank(property)) {
             return defaultValue;
         }
         if (StringUtils.equalsIgnoreCase(property, "high") || StringUtils.equalsIgnoreCase(property, "medium") || StringUtils.equalsIgnoreCase(property, "low")) {
             return property;
         }
         return defaultValue;
     }
 
     @SuppressWarnings("unchecked")
     private WatchEvent<Path> cast(WatchEvent<?> event) {
         return (WatchEvent<Path>) event;
     }
 
     private static class WatcherRegistration {
 
         private final Path rootPath;
         private final Predicate<Path> filterPredicate;
         private final WatcherCallback callback;
 
         public WatcherRegistration(Path rootPath, Predicate<Path> filterPredicate, WatcherCallback callback) {
             this.rootPath = rootPath;
             this.filterPredicate = filterPredicate;
             this.callback = callback;
         }
 
         public Path getRootPath() {
             return rootPath;
         }
 
         public Predicate<Path> getFilterPredicate() {
             return filterPredicate;
         }
 
         public WatcherCallback getCallback() {
             return callback;
         }
     }
 }