/**
    * This file Copyright (c) 2014-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.dirwatch;
  
  import info.magnolia.init.MagnoliaConfigurationProperties;
  
  import java.io.IOException;
  import java.nio.file.Path;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  import java.util.function.Predicate;
  
  import javax.inject.Inject;
  import javax.inject.Singleton;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Service to watch for added and removed files and especially for file changes.
   * <p>
   * This creates a {@link DirectoryWatcher}, i.e. our low-level implementation of Java's {@link java.nio.file.WatchService WatchService} API.
   * This watcher is then only started (submitted for execution) upon first request to register a directory.
   */
  @Singleton
  public class DirectoryWatcherService {
  
      private static final Logger log = LoggerFactory.getLogger(DirectoryWatcherService.class);
  
      private static final boolean RECURSIVE = true;
      private static final boolean FOLLOW_LINKS = true;
  
      private final ExecutorService executorService;
      private final DirectoryWatcher watcher;
  
      private Future<?> watcherFuture;
  
      @Inject
      public DirectoryWatcherService(MagnoliaConfigurationProperties properties) throws IOException {
          // We intentionally use a single thread executor (gather all registrations on a single DirectoryWatcher)
          this.executorService = Executors.newSingleThreadExecutor();
          this.watcher = new DirectoryWatcher(RECURSIVE, FOLLOW_LINKS, properties);
      }
  
      public void start() {
      }
  
      /**
       * Registers a directory to the {@link DirectoryWatcher}, with given filtering predicate and callback.
       */
      public synchronized void register(Path path, Predicate<Path> filterPredicate, WatcherCallback callback) throws IOException {
          if (watcherFuture == null) {
              log.info("Starting DirectoryWatcher");
              watcherFuture = executorService.submit(watcher);
          }
          watcher.register(path, filterPredicate, callback);
      }
  
      /**
       * Registers a directory to the {@link DirectoryWatcher}, with given filtering predicate and callback.
       *
       * @deprecated since 6.1 use {@link #register(Path, Predicate, WatcherCallback)} with plain Java predicate
       */
      @Deprecated
      public synchronized void register(Path path, com.google.common.base.Predicate<Path> filterPredicate, WatcherCallback callback) throws IOException {
          register(path, (Predicate<Path>) filterPredicate::apply, callback);
     }
 
     public void stop() {
         executorService.shutdownNow();
 
         boolean terminated = false;
         try {
             terminated = executorService.awaitTermination(1, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             log.error("Exception during service termination", e);
         }
         if (terminated) {
             log.info("{} terminated.", getClass().getSimpleName());
         } else {
             log.warn("{} not terminated, some tasks are still running.", getClass().getSimpleName());
         }
     }
 
 }