/**
    * This file Copyright (c) 2014-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.dirwatch;
  
  import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
  import static java.nio.file.StandardWatchEventKinds.*;
  
  import info.magnolia.cms.util.ExceptionUtil;
  
  import java.io.IOException;
  import java.nio.file.FileSystems;
  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.HashMap;
  import java.util.List;
  import java.util.Map;
  
  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 final WatchService watcher;
      private final Map<WatchKey, Path> keys = new HashMap<>();
  
      private final boolean recursive;
      private final LinkOption[] visitorOptions;
      private final List<WatcherRegistration> registrations = new ArrayList<>();
  
      public DirectoryWatcher(boolean recursive, boolean followLinks) throws IOException {
          this.recursive = recursive;
          this.visitorOptions = followLinks ? new LinkOption[] { NOFOLLOW_LINKS } : new LinkOption[0];
          this.watcher = FileSystems.getDefault().newWatchService();
      }
  
      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, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
         // 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);
     }
 
     /**
      * 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, 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 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(key, event);
                     log.debug("--> {} : {}: {}", Thread.currentThread(), event.kind().name(), completePath);
 
                     // 2a. register new directories
                     if (Files.isDirectory(completePath, visitorOptions)) {
                         if (recursive && (kind == ENTRY_CREATE)) {
 
                             // Loop over registrations to re-register accordingly
                             try {
                                 for (WatcherRegistration registration : registrations) {
                                     if (!completePath.startsWith(registration.getRootPath())) {
                                         continue;
                                     }
                                     Predicate<Path> filterPredicate = registration.getFilterPredicate();
                                     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) {
         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;
             }
 
             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);
             }
         }
     }
 
     /**
      * WatchEvent.context() returns a Path relative to the watchKey it was created for; we reconstruct it here.
      */
     private Path getCompletePath(WatchKey key, WatchEvent<?> watchEvent) {
         // Theoretically, there could be events with other types than Path. Practically, not so sure.
         final Path path = cast(watchEvent).context();
         final Path parent = (Path) key.watchable();
         return parent.resolve(path);
     }
 
     @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;
         }
     }
 }