/**
    * This file Copyright (c) 2016-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.resourceloader.file;
  
  import static info.magnolia.resourceloader.ResourceMatcher.file;
  import static info.magnolia.resourceloader.ResourceOriginChange.Type.*;
  import static info.magnolia.resourceloader.ResourceOriginChangeMatcher.resourceChange;
  import static info.magnolia.resourceloader.file.FileSystemResourceOrigin.RESOURCES_DIR_PROPERTY;
  import static info.magnolia.test.hamcrest.ExceptionMatcher.instanceOf;
  import static info.magnolia.test.hamcrest.ExecutionMatcher.throwsAnException;
  import static java.nio.file.Files.exists;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Mockito.*;
  
  import info.magnolia.dirwatch.DirectoryWatcher;
  import info.magnolia.dirwatch.DirectoryWatcherService;
  import info.magnolia.init.MagnoliaConfigurationProperties;
  import info.magnolia.resourceloader.ResourceChangeHandler;
  import info.magnolia.resourceloader.ResourceOrigin;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.StandardCopyOption;
  import java.util.function.Predicate;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.TemporaryFolder;
  
  public class FileWatcherCallbackTest {
  
      private static final int FILE_OPERATION_TIMEOUT = 30 * 1000;
      private static final String IGNORED_DIRECTORY = "rsyncstagingdir";
  
      @Rule
      public TemporaryFolder watchedDir = new TemporaryFolder();
  
      @Rule
      public TemporaryFolder nonWatchedDir = new TemporaryFolder();
  
      private Predicate<Path> watchedPathFilter = path -> !path.endsWith(IGNORED_DIRECTORY);
  
      private FileSystemResourceOrigin fileSystemResourceOrigin;
      private DirectoryWatcher watcher;
      private FileWatcherCallback fileWatcherCallback;
  
      @Before
      public void setUp() throws Exception {
          final MagnoliaConfigurationProperties mcp = mock(MagnoliaConfigurationProperties.class);
          doReturn(watchedDir.getRoot().toString()).when(mcp).getProperty(RESOURCES_DIR_PROPERTY);
  
          watcher = new DirectoryWatcher(true, true, mcp);
          this.fileSystemResourceOrigin = new FileSystemResourceOrigin(mcp, mock(DirectoryWatcherService.class), "foo");
  
          fileWatcherCallback = new FileWatcherCallback(fileSystemResourceOrigin, watchedPathFilter);
          watcher.register(watchedDir.getRoot().toPath(), watchedPathFilter, fileWatcherCallback);
  
          final Thread watcherThread = new Thread(watcher);
          watcherThread.start();
      }
  
     @Test
     public void communicatesFolderCreationAndDeletion() throws Exception {
         // GIVEN
         // register a resource change handler
         final ResourceChangeHandler handler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(handler);
 
         // WHEN
         // create a folder and a couple of files within it
         final File qux = watchedDir.newFolder("qux");
         final Path quux = Files.createFile(qux.toPath().resolve("quux"));
         final Path xyzzy = Files.createFile(qux.toPath().resolve("xyzzy"));
 
         // THEN
         // both files exist
         assertThat(quux.toFile().exists(), is(true));
         assertThat(xyzzy.toFile().exists(), is(true));
 
         // corresponding creation changes are communicated
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/qux")));
 
         // The following two verifies are marked with atLeast(1) so that we adapt to the cases when the sub-files of a deleted folder are also reported (not in OS X, but in Linux)
         // otherwise the test will think there were way too many invocations and fail...
         verify(handler, timeout(FILE_OPERATION_TIMEOUT).atLeast(1)).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/qux/quux")));
         verify(handler, timeout(FILE_OPERATION_TIMEOUT).atLeast(1)).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/qux/xyzzy")));
 
         // WHEN
         // delete the directory
         FileUtils.deleteDirectory(qux);
 
         // THEN
         // directory removal is communicated, but unfortunately the contents removal - isn't. One event for the directory
         // itself is all we can expect
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(REMOVED).at("/qux")));
     }
 
     @Test
     public void communicatesAllPossibleFileChangeEvents() throws Exception {
         // GIVEN
         // register a resource change handler
         final ResourceChangeHandler handler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(handler);
 
         // WHEN
         File foo = watchedDir.newFile("foo");
 
         // THEN
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/foo")));
 
         // WHEN
         // modify the file
         final FileOutputStream fos = new FileOutputStream(foo);
         fos.write(1);
         IOUtils.closeQuietly(fos);
 
         // THEN
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(MODIFIED).at("/foo")));
 
         // WHEN
         // file is deleted
         foo.delete();
 
         // THEN
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(REMOVED).at("/foo")));
     }
 
     @Test
     public void movedDirectoryIsDetected() throws Exception {
         // GIVEN
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN
         // first create a folder an a file in it
         final Path foo = watchedDir.newFolder("foo").toPath();
         Files.createFile(foo.resolve("bar.yaml"));
 
         // THEN make sure at least file creation is communicated (let's save a bit on timeouts)
 
         // The following verify is marked with atLeast(1) so that we adapt to the case when the sub-files of a deleted folder are also reported (not in OS X, but in Linux)
         // otherwise the test will think there were way too many invocations and fail...
         verify(resourceChangeHandler, timeout(FILE_OPERATION_TIMEOUT).atLeast(1)).onResourceChanged(argThat(resourceChange().at("/foo/bar.yaml").ofType(ADDED)));
 
         // THEN create another folder
         final Path bar = Files.createDirectory(watchedDir.getRoot().toPath().resolve("bar"));
         // make sure no file with the same name as in foo exists in bar
         assertThat(() -> fileSystemResourceOrigin.getByPath("/bar/bar.yaml"),
                 throwsAnException(instanceOf(ResourceOrigin.ResourceNotFoundException.class)));
 
         // WHEN whole folder is moved
         Files.move(foo, bar, StandardCopyOption.REPLACE_EXISTING);
 
         // THEN old folder is destroyed
         verify(resourceChangeHandler, timeout(FILE_OPERATION_TIMEOUT).atLeastOnce()).onResourceChanged(argThat(resourceChange().at("/foo").ofType(REMOVED)));
         // New file is created
         verify(resourceChangeHandler, timeout(FILE_OPERATION_TIMEOUT).atLeastOnce()).onResourceChanged(argThat(resourceChange().at("/bar/bar.yaml").ofType(ADDED)));
 
         assertThat(fileSystemResourceOrigin.getByPath("/bar/bar.yaml"), file().withPath("/bar/bar.yaml"));
     }
 
     @Test
     public void subTreeIsSkippedWhenFileCantBeRead() throws Exception {
         // GIVEN
         final ResourceChangeHandler handler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(handler);
 
         // WHEN
         // let's create a folder with a file inside of it
         File toCreateDir = watchedDir.newFolder("qux");
         Files.createFile(toCreateDir.toPath().resolve("bar.yaml"));
         assertThat(fileSystemResourceOrigin.getByPath("/qux/bar.yaml"), file().withPath("/qux/bar.yaml"));
 
         // THEN
         // so far, so good
         verify(handler, timeout(FILE_OPERATION_TIMEOUT)).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/qux")));
 
         // WHEN
         // remove rights on the folder
         toCreateDir.setReadable(false);
         toCreateDir.setWritable(false);
         toCreateDir.setExecutable(false);
 
         // THEN
         // file is no longer accessible
         assertThat(() -> fileSystemResourceOrigin.getByPath("/qux/bar.yaml"), throwsAnException(instanceOf(ResourceOrigin.ResourceNotFoundException.class)));
     }
 
     @Test
     public void watchedPathFilterDiscardsIgnoredElementsRegistration() throws Exception {
         // GIVEN
         final ResourceChangeHandler handler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(handler);
 
         // WHEN
         // let's create an ignored directory with files
         final File qux = watchedDir.newFolder(IGNORED_DIRECTORY);
         final Path quux = Files.createFile(qux.toPath().resolve("quux"));
         final Path xyzzy = Files.createFile(qux.toPath().resolve("xyzzy"));
         assertThat(quux.toFile().exists(), is(true));
         assertThat(xyzzy.toFile().exists(), is(true));
 
         // THEN
         // no events is what we want
         verify(handler, never()).onResourceChanged(argThat(resourceChange().ofType(ADDED).at(getIgnoredDirectoryPath(""))));
         verify(handler, never()).onResourceChanged(argThat(resourceChange().ofType(ADDED).at(getIgnoredDirectoryPath("/quux"))));
         verify(handler, never()).onResourceChanged(argThat(resourceChange().ofType(ADDED).at(getIgnoredDirectoryPath("/xyzzy"))));
     }
 
     @Test
     public void allowsDirectoryWatchingViaSymbolicLinks() throws Exception {
         // GIVEN
         final ResourceChangeHandler handler = mock(ResourceChangeHandler.class);
         fileSystemResourceOrigin.registerResourceChangeHandler(handler);
 
         // create a symbolic link and make it point at a non-watched folder containing one file
         final Path symLinkPath = watchedDir.getRoot().toPath().resolve(Paths.get("symLink"));
         final Path symLinkTarget = nonWatchedDir.newFolder("symLinkTarget").toPath();
         Files.createFile(symLinkTarget.resolve(Paths.get("bar.yaml")));
         final Path symbolicLink = Files.createSymbolicLink(symLinkPath, symLinkTarget);
 
         // make sure that the resulting path is visible via a sym link
         final Path barPathViaSymLink = symbolicLink.resolve(Paths.get("bar.yaml"));
         assertThat(exists(barPathViaSymLink), is(true));
 
         // WHEN
         // a symbolic link is added to the watched dir
         watcher.register(symbolicLink, watchedPathFilter, fileWatcherCallback);
 
         // THEN
         // make sure the corresponding event is registered by our watcher upon adding the link
         verify(handler, timeout(FILE_OPERATION_TIMEOUT).atLeastOnce()).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/symLink/bar.yaml")));
 
         // WHEN
         // another file is added to the sym link target
         Files.createFile(symLinkTarget.resolve(Paths.get("foo.yaml")));
 
         // make sure that the resulting path is visible via a sym link
         final Path fooPathViaSymLink = symbolicLink.resolve(Paths.get("foo.yaml"));
         assertThat(exists(fooPathViaSymLink), is(true));
 
         // THEN
         // a corresponding event is registered by our watcher
         verify(handler, timeout(FILE_OPERATION_TIMEOUT).atLeastOnce()).onResourceChanged(argThat(resourceChange().ofType(ADDED).at("/symLink/foo.yaml")));
     }
 
     private String getIgnoredDirectoryPath(String path) {
         Path ignoredDirectoryPath = Paths.get(IGNORED_DIRECTORY);
         return ignoredDirectoryPath.resolve(path).toString();
     }
 }