/**
    * This file Copyright (c) 2015-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.resourceloader.file;
  
  import java.io.File;
  import java.io.IOException;
  import java.nio.file.DirectoryStream;
  import java.nio.file.Path;
  import java.nio.file.PathMatcher;
  import java.nio.file.Paths;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.regex.Pattern;
  
  import org.apache.commons.io.FilenameUtils;
  
  import com.google.common.base.Predicate;
  
  /**
   * Predicate and DirectoryStream.Filter which checks a given Path is under the root and is able to exclude.
   * <ul><li>directories</li>
   * <li>file extensions</li>
   * <li>any other pattern</li></ul>
   * @see java.nio.file.DirectoryStream.Filter
   */
  public class ExclusionsFilter implements Predicate<Path>, DirectoryStream.Filter<Path> {
  
      private final Path rootPath;
      private final List<String> excludePatterns;
  
      /**
       * @param rootPath an absolute root path to evaluate paths against
       * @param excludedDirectories directory names that will be excluded regardless of their location.
       * @param excludedExtensions file extensions that will be excluded.
       * @param otherPatterns regex or glob path patterns, relative to given <code>rootPath</code>. Defaults to regex: if no prefix is given.
       * @see java.nio.file.FileSystem#getPathMatcher(java.lang.String)
       */
      public ExclusionsFilter(Path rootPath, List<String> excludedDirectories, List<String> excludedExtensions, List<String> otherPatterns) {
          this.rootPath = validateRootPath(rootPath);
          this.excludePatterns = new ArrayList<>();
          addDirectoryExcludes(excludePatterns, excludedDirectories);
          addExtensionExcludes(excludePatterns, excludedExtensions);
          addPatternList(excludePatterns, otherPatterns);
      }
  
      @Override
      public boolean accept(Path entry) throws IOException {
          return apply(entry);
      }
  
      @Override
      public boolean apply(Path dir) {
          // is starting visiting from root directory
          Path normalizedDir = Paths.get(FilenameUtils.normalize(dir.toString()));
          if (!normalizedDir.isAbsolute() || !normalizedDir.startsWith(rootPath)) {
              return false;
          }
  
          Path rel = rootPath.relativize(normalizedDir);
  
          // is an excluded directory
          for (String excludePattern : excludePatterns) {
              final PathMatcher matcher = normalizedDir.getFileSystem().getPathMatcher(excludePattern);
              if (matcher.matches(rel)) {
                  return false;
              }
          }
  
         return true;
     }
 
     private Path validateRootPath(Path rootPath) {
         Path normalizedPath = Paths.get(FilenameUtils.normalize(rootPath.toString()));
         if (!normalizedPath.isAbsolute()) {
             throw new IllegalStateException(rootPath + " is not an absolute Path.");
         }
         return normalizedPath;
     }
 
     private void addDirectoryExcludes(List<String> excludePatterns, List<String> excludedDirectories) {
         for (String directory : excludedDirectories) {
             excludePatterns.add("regex:(^|.*" + (File.separator.replace("\\", "\\\\")) + ")" + Pattern.quote(directory) + "($|" + (File.separator.replace("\\", "\\\\")) + ".*)");
         }
     }
 
     private void addExtensionExcludes(List<String> excludePatterns, List<String> excludedExtensions) {
         for (String ext : excludedExtensions) {
             excludePatterns.add("regex:.*\\." + Pattern.quote(ext) + "$");
         }
     }
 
     private void addPatternList(List<String> excludePatterns, List<String> stringPatterns) {
         for (String pattern : stringPatterns) {
             if (pattern.startsWith("glob:") || pattern.startsWith("regex:")) {
                 excludePatterns.add(pattern);
             } else {
                 excludePatterns.add("regex:" + pattern);
             }
         }
     }
 
 }