/**
    * This file Copyright (c) 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.resourceloader.classpath;
  
  import info.magnolia.classpathwatch.ClasspathScannerService;
  import info.magnolia.cms.util.ClasspathResourcesUtil;
  import info.magnolia.init.MagnoliaConfigurationProperties;
  import info.magnolia.resourceloader.AbstractResourceOrigin;
  import info.magnolia.resourceloader.ResourceOriginFactory;
  import info.magnolia.resourceloader.ResourceVisitor;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.JarURLConnection;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.net.URLConnection;
  import java.nio.charset.Charset;
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.servlet.ServletContext;
  
  import org.apache.commons.lang3.StringUtils;
  import org.reflections.Reflections;
  import org.reflections.scanners.ResourcesScanner;
  import org.reflections.util.ClasspathHelper;
  import org.reflections.util.ConfigurationBuilder;
  import org.reflections.util.FilterBuilder;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.auto.factory.AutoFactory;
  import com.google.auto.factory.Provided;
  import com.google.common.base.Joiner;
  import com.google.common.base.Predicate;
  import com.google.common.base.Predicates;
  import com.google.common.collect.Collections2;
  import com.google.common.collect.FluentIterable;
  import com.google.common.collect.Sets;
  import com.google.common.io.Resources;
  
  /**
   * A {@link info.magnolia.resourceloader.ResourceOrigin} which loads resources from the classpath.
   * <p>
   * Because the classpath does actually not know about folders but only about classes, this origin constructs a virtual folder/file structure of {@link ClasspathResource}s. <br/>
   * For this to work the origin relies on the following assumptions:
   * <ul>
   * <li>There is only one root path and it is "/"</li>
   * <li>All paths begin with "/"</li>
   * <li>Paths to folders never end with "/"</li>
   * <li>File or folder names do not contain "/"</li>
   * </ul>
   */
  @AutoFactory(implementing = ResourceOriginFactory.class)
  public class ClasspathResourceOrigin extends AbstractResourceOrigin<ClasspathResource> {
  
      private static final Logger log = LoggerFactory.getLogger(ClasspathResourceOrigin.class);
      private static final String OBSERVED_FILES_PATTERN = ".*\\.(ftl|yaml)$";
  
      private final ClasspathScannerService classpathScannerService;
      private final ServletContext servletContext;
      private final MagnoliaConfigurationProperties magnoliaProperties;
  
     private Map<String, ClasspathResource> resourceCache;
 
     ClasspathResourceOrigin(@Provided ClasspathScannerService classpathScannerService, String name, @Provided ServletContext ctx, @Provided MagnoliaConfigurationProperties magnoliaProperties) {
         super(name);
         this.classpathScannerService = classpathScannerService;
         this.servletContext = ctx;
         this.magnoliaProperties = magnoliaProperties;
         collectResources();
     }
 
     @Override
     public ClasspathResource getRoot() {
         return getByPath("/");
     }
 
     @Override
     public void watchForChanges(ResourceVisitor visitor) {
         if (!classpathScannerService.isEnabled()) {
             return;
         }
 
         String observedResourcesPattern = observedResourcesPattern();
         log.info("Setting up {} to watch for resource changes with pattern {}.", classpathScannerService, observedResourcesPattern);
 
         /*
          * Propagate ClasspathResourceOrigin's Reflections config (filtering predicates for resources and URLs) to ClasspathScanner,
          * yet further restricting periodic scanning to YAML files only.
          */
         final FilterBuilder resourcesFilter = new FilterBuilder();
         // /!\ if there is an include, needs to be the first one in FilterBuilder
         resourcesFilter.include(observedResourcesPattern);
         applyResourceExclusions(resourcesFilter);
 
         final Predicate<? super URL> urlsFilter = urlsFilter();
 
         classpathScannerService.watch(resourcesFilter, urlsFilter, new VisitorFunction(this, visitor));
     }
 
     protected String observedResourcesPattern() {
         String pattern = magnoliaProperties.getProperty("magnolia.resources.classpath.observation.pattern");
         if (StringUtils.isNotBlank(pattern)) {
             return pattern;
         } else {
             log.info("Classpath observation pattern is not being set explicitly, current observation is made for only ftl + yaml files");
             return OBSERVED_FILES_PATTERN;
         }
     }
 
     @Override
     public ClasspathResource getByPath(String path) {
         String decoratedPath = decoratePath(path);
         String validatedPath = validatePath(decoratedPath);
         if (resourceCache.containsKey(validatedPath)) {
             return resourceCache.get(validatedPath);
         }
 
         // If the given resource is not found in the cache, then we are searching for it
         ClasspathResource resource = getResourceFor(validatedPath);
         if (resource == null) {
             throw new ResourceNotFoundException(this, validatedPath);
         }
 
         resourceCache.put(validatedPath, resource);
         return resource;
     }
 
     ClasspathResource getResourceFor(String path) {
         String strippedPath = stripLeadingSlash(path);
         if (!hasPath(path) || !resourcesFilter().apply(strippedPath)) {
             return null;
         }
 
         boolean isFile = isResourceFile(strippedPath);
         return newClasspathResource(path, isFile);
     }
 
     @Override
     public boolean hasPath(String path) {
         final String decoratedPath = decoratePath(path);
         return resourceCache.containsKey(validatePath(decoratedPath)) || getResourceUrl(stripLeadingSlash(decoratedPath)) != null;
     }
 
     private URL getResourceUrl(String path) {
         URLConnection connection = null;
         try {
             URL resource = Resources.getResource(path);
             // We have to verify whether it's possible to open resource stream, since it may be deleted.
             connection = resource.openConnection();
             connection.getInputStream();
             return resource;
         } catch (IllegalArgumentException | IOException e) {
             return null;
         } finally {
             if (connection != null) {
                 tryToCloseConnection(connection);
             }
         }
     }
 
     private void tryToCloseConnection(URLConnection connection) {
         if (connection instanceof JarURLConnection) {
             JarURLConnection jar = (JarURLConnection) connection;
             try {
                 if (jar.getUseCaches()) {
                     jar.getJarFile().close();
                 }
             } catch (IOException ignored) {
                 // This is ignored, because we might not get the inputstream and thus cannot close it.
                 // This is a known java bug, https://bugs.openjdk.java.net/browse/JDK-8080094
             }
         } else {
             try {
                 InputStream inputStream = connection.getInputStream();
                 if (inputStream != null) {
                     inputStream.close();
                 }
             } catch (IOException e) {
                 log.debug("Stream could not be closed", e);
             }
         }
     }
 
     /**
      * This method checks if a given path represents a resource file or folder,
      * To identify this, we simply check if  {@code path + "/"} exists or not.
      * If {@code true}, then we know that its a folder if not then its a simple file.
      */
     boolean isResourceFile(String path) {
         String strippedPath = stripLastSlash(path);
 
         URL filePath = Resources.getResource(path);
         File file = new File(filePath.getFile());
         if (file.exists()) {
             return file.isFile();
         }
 
         try {
             Resources.getResource(strippedPath + "/");
             return false;
         } catch (IllegalArgumentException e) {
             return true;
         }
     }
 
     /**
      * This method is used for stripping the last slash if its present.
      */
     private String stripLastSlash(String path) {
         String strippedPath;
         if (path.endsWith("/")) {
             strippedPath = StringUtils.chop(path);
         } else {
             strippedPath = path;
         }
         return strippedPath;
     }
 
     @Override
     protected boolean isFile(ClasspathResource resource) {
         throw shouldNotBeCalled();
     }
 
     @Override
     protected boolean isDirectory(ClasspathResource resource) {
         throw shouldNotBeCalled();
     }
 
     @Override
     protected String getPath(ClasspathResource resource) {
         return resource.getRealPath();
     }
 
     @Override
     protected String getName(ClasspathResource resource) {
         return StringUtils.substringAfterLast(resource.getRealPath(), "/");
     }
 
     @Override
     protected long getLastModified(ClasspathResource resource) {
         try {
             final URL resourceUrl = getUrl(resource);
             return resourceUrl.openConnection().getLastModified();
         } catch (IOException e) {
             throw new RuntimeException("Last modified time could not be retrieved for path " + resource + " : " + e, e);
         }
     }
 
     /**
      * Lists children of a given resource, only if the given resource is an actual directory.
      * Basically this method will search for the direct children both files and folders.
      * <p><code>
      * given(resource).withPath("/foo")<br>
      * given(resource).withPath("/foo/bar")<br>
      * given(resource).withPath("/foo/bar/foo")<br>
      * when(listChildren("/foo"))<br>
      * then(foundChildren).is("/foo/bar")
      * </code></p>
      */
     @Override
     protected List<ClasspathResource> listChildren(ClasspathResource resource) {
         if (resource != null && resource.isFile()) {
             throw new IllegalArgumentException(resource.getRealPath() + " is not a directory.");
         }
 
         Set<ClasspathResource> children = Sets.newHashSet();
         ChildFinder childFinder = new ChildFinder(resource.getRealPath());
 
         for (String childPath : childFinder.getDirectChildren()) {
             URL resourceUrl = getResourceUrl(stripLeadingSlash(childPath));
             if (resourceUrl == null) {
                 resourceCache.remove(childPath);
             } else {
                 children.add(resourceCache.get(validatePath(childPath)));
             }
         }
 
         for (String path : childFinder.getDirectories()) {
             children.add(newClasspathResource(path, false));
         }
 
         return FluentIterable.from(children).toList();
     }
 
     protected ClasspathResource updateResourceFor(String resourcePath) {
         URL resource = getResourceUrl(resourcePath);
         String validatedPath = validatePath(resourcePath);
         if (resource != null) {
             // Resource is present, hence it had been added, then we should be caching it as well.
             return newClasspathResource(validatedPath, true);
         } else {
             removeFromCache(validatedPath);
             return new ClasspathResource(this, validatedPath, true);
         }
     }
 
     private void removeFromCache(String resourcePath) {
         resourceCache.remove(validatePath(resourcePath));
     }
 
     @Override
     protected ClasspathResource getParent(ClasspathResource resource) {
         if ("/".equals(resource.getRealPath())) {
             return null;
         }
 
         String parentPath = StringUtils.substringBeforeLast(resource.getRealPath(), "/");
         if (StringUtils.isNotBlank(parentPath)) {
             return getByPath(parentPath);
         } else {
             return getRoot();
         }
     }
 
     @Override
     protected InputStream doOpenStream(ClasspathResource resource) throws IOException {
         final URL url = getUrl(resource);
         // TODO prevent on directories ? (looks like it returns a list of resources ?)
         return url.openStream();
     }
 
     @Override
     protected Charset getCharsetFor(ClasspathResource resource) {
         return Charset.forName("UTF-8"); // TODO ?
     }
 
     protected URL getUrl(ClasspathResource resource) {
         final URL url = ClasspathResourcesUtil.getResource(resource.getRealPath());
         if (url == null) {
             throw new IllegalStateException("Can't open stream for " + resource);
         }
         return url;
     }
 
     protected void collectResources() {
         // Scan classpath for resources
         final long start = System.currentTimeMillis();
         final Predicate<String> resourcesFilter = resourcesFilter();
         final Collection<URL> classpathUrls = classpathUrls();
         final Reflections reflections = new Reflections(new ConfigurationBuilder()
                 .setScanners(new ResourcesScanner())
                 .setUrls(classpathUrls)
                 .filterInputsBy(resourcesFilter)
         );
 
         final Set<String> resources = reflections.getResources(Predicates.<String>alwaysTrue()); // predicate here is used for matching only the "simple name" of the resource; we do the pattern filtering upfront in ConfigurationBuilder anyway
         long scanDone = System.currentTimeMillis();
         log.debug("Took {}ms to find {} resources", scanDone - start, resources.size());
 
         // Build virtual directory structure of ClasspathResources and index it into resources map
         this.resourceCache = new LinkedHashMap<>();
         for (String resource : resources) {
             newClasspathResource(resource, true);
         }
         log.debug("Took {}ms to build virtual directory structure", System.currentTimeMillis() - scanDone);
     }
 
     protected Collection<URL> classpathUrls() {
         final ClassLoader contextClassLoader = ClasspathHelper.contextClassLoader();
         final Collection<URL> allURLs;
         if (contextClassLoader instanceof URLClassLoader) {
             allURLs = ClasspathHelper.forClassLoader(contextClassLoader);
         } else {
             // Some app servers (e.g. JBoss EAP/Wildfly) have complex classloader hierarchies and the context classloader
             // does not provide the resource search path URLs. For such a case in order to make sure we still get the relevant
             // URLs from the WEB-INF/lib we fall back to resolving them via a servlet context.
             allURLs = ClasspathHelper.forWebInfLib(servletContext);
         }
         Predicate<? super URL> excludedExtensions = urlsFilter();
         return Collections2.filter(allURLs, excludedExtensions);
     }
 
     protected Predicate<? super URL> urlsFilter() {
         final String excludedUrlExtensionsPattern = extensionsPattern(excludedUrlExtensions());
         return URLPredicate.excludedExtensions(excludedUrlExtensionsPattern);
     }
 
     protected Predicate<String> resourcesFilter() {
         final FilterBuilder filterBuilder = new FilterBuilder();
         return applyResourceExclusions(filterBuilder);
     }
 
     /**
      * Applies exclusions "standalone" as we they need to use them in {@link #watchForChanges(ResourceVisitor)} as well, in different ways.
      */
     private FilterBuilder applyResourceExclusions(FilterBuilder filterBuilder) {
         // "mgnl-resources" is re-included by LegacyClasspathResourceOrigin, we don't want any other mgnl-* folder for now.
         filterBuilder.exclude("mgnl-.*");
 
         filterBuilder.exclude(extensionsPattern(excludedResourcesExtensions()));
 
         final String[] excludedPackages = excludedPackages();
         for (String excludedPackage : excludedPackages) {
             filterBuilder.excludePackage(excludedPackage);
         }
         return filterBuilder;
     }
 
     protected String extensionsPattern(String[] extensions) {
         return ".*\\.(" + Joiner.on('|').join(extensions) + ")$";
     }
 
     protected String[] excludedUrlExtensions() {
         return new String[]{
                 // native libs
                 "dylib", "dll", "jnilib",
                 // some people end up with .pom files on their classpaths
                 "pom"
         };
     }
 
     protected String[] excludedResourcesExtensions() {
         return new String[]{
                 "package\\.html", "java", "jar",
                 // native libs (quite possibly covered by the com.* excludes but eh)
                 "dylib", "dll", "jnilib"
         };
     }
 
     protected String[] excludedPackages() {
         return new String[]{
                 "META-INF",
                 "com.oracle.java",
                 "com.oracle.tools",
                 "com.sun",
                 "sun",
                 "oracle", // Only found /oracle/jrockit/jfr/settings/jfc.xsd in my tests but eh
                 "java",
                 "javax",
                 "jdk",
                 "org.apache", // TODO is this too strict or arbitrary ?
                 "lombok",
                 "VAADIN",
                 "gwt-unitCache"
         };
     }
 
     /**
      * This method is not creating the directory structure anymore.
      *
      * @deprecated since 5.4.4 - use {@link #newClasspathResource(String, boolean)} instead.
      */
     @Deprecated
     protected ClasspathResource createResourcesFor(final String resourcePath) {
         return newClasspathResource(resourcePath, true);
     }
 
     protected ClasspathResource newClasspathResource(String path, boolean isFile) {
         final String validatedPath = validatePath(path);
         final ClasspathResource resource = new ClasspathResource(this, validatedPath, isFile);
         resourceCache.put(validatedPath, resource);
         return resource;
     }
 
     /**
      * Verifies the given path is as-expected by this origin, and "prepares" it.
      *
      * <p>{@link ClasspathResourceOrigin} expects a leading {@code "/"} and therefore, if leading {@code "/"} is not
      * present, then this method will add it.</p>
      */
     protected String validatePath(String resource) {
         if (resource.startsWith("/")) {
             return resource;
         } else {
             return "/" + resource;
         }
     }
 
     private class ChildFinder {
 
         private final String parentPath;
         private final Set<String> directories = Sets.newHashSet();
         private final Set<String> directChildren = Sets.newHashSet();
 
         private ChildFinder(String initialParentPath) {
             if (StringUtils.isNotEmpty(initialParentPath)) {
                 this.parentPath = initialParentPath.endsWith("/") ? initialParentPath : initialParentPath + "/";
             } else {
                 this.parentPath = initialParentPath;
             }
 
             doIterate();
         }
 
         private void doIterate() {
             for (String resourcePath : resourceCache.keySet()) {
                 if (isDirectChild(resourcePath)) {
                     directChildren.add(decoratePath(resourcePath));
                 }
             }
         }
 
         private boolean isDirectChild(String path) {
             String relativePath = path;
             if (!parentPath.isEmpty()) {
                 if (!relativePath.startsWith(parentPath)) {
                     return false;
                 }
                 // make relative
                 relativePath = StringUtils.substringAfter(path, parentPath);
             }
 
             if (relativePath.contains("/")) {
                 directories.add(decoratePath(parentPath + StringUtils.substringBefore(relativePath, "/")));
                 return false;
             }
 
             return !path.equals(parentPath);
         }
 
         Set<String> getDirectories() {
             return directories;
         }
 
         Set<String> getDirectChildren() {
             return directChildren;
         }
     }
 
     /**
      * This method is adding the prefix to given resource path if its required.
      *
      * <p>For {@link ClasspathResourceOrigin}, there will be no prefix added, however, for other origins, it might be
      * needed, e.g. for origin {@link LegacyClasspathResourceOrigin} prefix
      * {@link LegacyClasspathResourceOrigin#LEGACY_PREFIX} will be added.</p>
      */
     String decoratePath(String resourcePath) {
         return resourcePath;
     }
 
     private IllegalStateException shouldNotBeCalled() {
         return new IllegalStateException("This method should not be called, it is implemented directly by ClasspathResource");
     }
 
     /**
      * This method is used for stripping the leading slash if its present.
      *
      * <p>{@link Resources#getResource(String)} expects resources path without a leading slash, therefore this is
      * conflicting with origin {@link ClasspathResourceOrigin} logic of having a leading slash.</p>
      */
     private String stripLeadingSlash(String path) {
         if (path.startsWith("/")) {
             return path.substring(1);
         }
         return path;
     }
 }