package liquibase.servicelocator;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.net.URL;
  import java.net.URLConnection;
  import java.net.URLDecoder;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.jar.JarEntry;
  import java.util.jar.JarInputStream;
  
  import liquibase.logging.Logger;
  import liquibase.logging.core.DefaultLogger;
  
  /**
   * Default implement of {@link PackageScanClassResolver}
   */
  public class DefaultPackageScanClassResolver implements PackageScanClassResolver {
  
      private static Map<String, Set<String>> classesByJarUrl = new HashMap<String, Set<String>>();
  
      protected final transient Logger log = new DefaultLogger();
      private Set<ClassLoader> classLoaders;
      private Set<PackageScanFilter> scanFilters;
  
      @Override
      public void addClassLoader(ClassLoader classLoader) {
          try {
              getClassLoaders().add(classLoader);
          } catch (UnsupportedOperationException ex) {
              // Ignore this exception as the PackageScanClassResolver
              // don't want use any other classloader
          }
      }
  
      @Override
      public void addFilter(PackageScanFilter filter) {
          if (scanFilters == null) {
              scanFilters = new LinkedHashSet<PackageScanFilter>();
          }
          scanFilters.add(filter);
      }
  
      @Override
      public void removeFilter(PackageScanFilter filter) {
          if (scanFilters != null) {
              scanFilters.remove(filter);
          }
      }
  
      @Override
      public Set<ClassLoader> getClassLoaders() {
          if (classLoaders == null) {
              classLoaders = new HashSet<ClassLoader>();
              ClassLoader ccl = Thread.currentThread().getContextClassLoader();
              if (ccl != null) {
                  log.debug("The thread context class loader: " + ccl + "  is used to load the class");
                  classLoaders.add(ccl);
              }
              classLoaders.add(DefaultPackageScanClassResolver.class.getClassLoader());
          }
          return classLoaders;
      }
  
      @Override
      public void setClassLoaders(Set<ClassLoader> classLoaders) {
          this.classLoaders = classLoaders;
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public Set<Class<?>> findImplementations(Class parent, String... packageNames) {
          if (packageNames == null) {
              return Collections.EMPTY_SET;
          }
  
          log.debug("Searching for implementations of " + parent.getName() + " in packages: "
                  + Arrays.asList(packageNames));
  
          PackageScanFilter test = getCompositeFilter(new AssignableToPackageScanFilter(parent));
          Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
          for (String pkg : packageNames) {
              find(test, pkg, classes);
          }
  
          log.debug("Found: " + classes);
  
          return classes;
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public Set<Class<?>> findByFilter(PackageScanFilter filter, String... packageNames) {
         if (packageNames == null) {
             return Collections.EMPTY_SET;
         }
 
         Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
         for (String pkg : packageNames) {
             find(filter, pkg, classes);
         }
 
         log.debug("Found: " + classes);
 
         return classes;
     }
 
     protected void find(PackageScanFilter test, String packageName, Set<Class<?>> classes) {
         packageName = packageName.replace('.', '/');
 
         Set<ClassLoader> set = getClassLoaders();
 
         for (ClassLoader classLoader : set) {
             find(test, packageName, classLoader, classes);
         }
     }
 
     protected void find(PackageScanFilter test, String packageName, ClassLoader loader, Set<Class<?>> classes) {
         log.debug("Searching for: " + test + " in package: " + packageName + " using classloader: "
                 + loader.getClass().getName());
 
         Enumeration<URL> urls;
         try {
             urls = getResources(loader, packageName);
             if (!urls.hasMoreElements()) {
                 log.debug("No URLs returned by classloader");
             }
         } catch (IOException ioe) {
             log.warning("Cannot read package: " + packageName, ioe);
             return;
         }
 
         while (urls.hasMoreElements()) {
             URL url = null;
             try {
                 url = urls.nextElement();
                 log.debug("URL from classloader: " + url);
 
                 url = customResourceLocator(url);
 
                 String urlPath = url.getFile();
                 String host = null;
                 urlPath = URLDecoder.decode(urlPath, "UTF-8");
 
                 if (url.getProtocol().equals("vfs") && !urlPath.startsWith("vfs")) {
                     urlPath = "vfs:" + urlPath;
                 }
                 if (url.getProtocol().equals("vfszip") && !urlPath.startsWith("vfszip")) {
                     urlPath = "vfszip:" + urlPath;
                 }
 
                 log.debug("Decoded urlPath: " + urlPath + " with protocol: " + url.getProtocol());
 
                 // If it's a file in a directory, trim the stupid file: spec
                 if (urlPath.startsWith("file:")) {
                     // file path can be temporary folder which uses characters that the URLDecoder decodes wrong
                     // for example + being decoded to something else (+ can be used in temp folders on Mac OS)
                     // to remedy this then create new path without using the URLDecoder
                     try {
                         URI uri = new URI(url.getFile());
                         host = uri.getHost();
                         urlPath = uri.getPath();
                     } catch (URISyntaxException e) {
                         // fallback to use as it was given from the URLDecoder
                         // this allows us to work on Windows if users have spaces in paths
                     }
 
                     if (urlPath.startsWith("file:")) {
                         urlPath = urlPath.substring(5);
                     }
                 }
 
                 // osgi bundles should be skipped
                 if (url.toString().startsWith("bundle:") || urlPath.startsWith("bundle:")) {
                     log.debug("It's a virtual osgi bundle, skipping");
                     continue;
                 }
 
                 // Else it's in a JAR, grab the path to the jar
                 if (urlPath.contains(".jar/")) {
                     urlPath = urlPath.replace(".jar/", ".jar!/");
                 }
 
                 if (urlPath.indexOf('!') > 0) {
                     urlPath = urlPath.substring(0, urlPath.indexOf('!'));
                 }
 
                 // If a host component was given prepend it to the decoded path.
                 // This still has its problems as we silently skip user and password
                 // information etc. but it fixes UNC urls on windows.
                 if (host != null) {
                     if (urlPath.startsWith("/")) {
                         urlPath = "//" + host + urlPath;
                     } else {
                         urlPath = "//" + host + "/" + urlPath;
                     }
                 }
 
                 log.debug("Scanning for classes in [" + urlPath + "] matching criteria: " + test);
 
                 File file = new File(urlPath);
                 if (file.isDirectory()) {
                     log.debug("Loading from directory using file: " + file);
                     loadImplementationsInDirectory(test, packageName, file, classes);
                 } else {
                     InputStream stream;
                     if (urlPath.startsWith("http:") || urlPath.startsWith("https:") || urlPath.startsWith("sonicfs:")
                             || urlPath.startsWith("vfs:") || urlPath.startsWith("vfszip:")) {
                         // load resources using http/https
                         // sonic ESB requires to be loaded using a regular URLConnection
                         URL urlStream = new URL(urlPath);
                         log.debug("Loading from jar using " + urlStream.getProtocol() + ": " + urlPath);
                         URLConnection con = urlStream.openConnection();
                         // disable cache mainly to avoid jar file locking on Windows
                         con.setUseCaches(false);
                         stream = con.getInputStream();
                     } else {
                         log.debug("Loading from jar using file: " + file);
                         stream = new FileInputStream(file);
                     }
 
                     loadImplementationsInJar(test, packageName, stream, urlPath, classes);
                 }
             } catch (IOException e) {
                 // use debug logging to avoid being to noisy in logs
                 log.debug("Cannot read entries in url: " + url, e);
             }
         }
     }
 
     // We can override this method to support the custom ResourceLocator
 
     protected URL customResourceLocator(URL url) throws IOException {
         // Do nothing here
         return url;
     }
 
     /**
      * Strategy to get the resources by the given classloader.
      * <p/>
      * Notice that in WebSphere platforms there is a {@link WebSpherePackageScanClassResolver} to take care of
      * WebSphere's odditiy of resource loading.
      * 
      * @param loader
      *            the classloader
      * @param packageName
      *            the packagename for the package to load
      * @return URL's for the given package
      * @throws IOException
      *             is thrown by the classloader
      */
     protected Enumeration<URL> getResources(ClassLoader loader, String packageName) throws IOException {
         log.debug("Getting resource URL for package: " + packageName + " with classloader: " + loader);
 
         // If the URL is a jar, the URLClassloader.getResources() seems to require a trailing slash. The
         // trailing slash is harmless for other URLs
         if (!packageName.endsWith("/")) {
             packageName = packageName + "/";
         }
         return loader.getResources(packageName);
     }
 
     private PackageScanFilter getCompositeFilter(PackageScanFilter filter) {
         if (scanFilters != null) {
             CompositePackageScanFilter composite = new CompositePackageScanFilter(scanFilters);
             composite.addFilter(filter);
             return composite;
         }
         return filter;
     }
 
     /**
      * Finds matches in a physical directory on a filesystem. Examines all files within a directory - if the File object
      * is not a directory, and ends with <i>.class</i> the file is loaded and tested to see if it is acceptable
      * according to the Test. Operates recursively to find classes within a folder structure matching the package
      * structure.
      * 
      * @param test
      *            a Test used to filter the classes that are discovered
      * @param parent
      *            the package name up to this directory in the package hierarchy. E.g. if /classes is in the classpath
      *            and we wish to examine files in /classes/org/apache then the values of <i>parent</i> would be
      *            <i>org/apache</i>
      * @param location
      *            a File object representing a directory
      */
     private void loadImplementationsInDirectory(PackageScanFilter test, String parent, File location,
             Set<Class<?>> classes) {
         File[] files = location.listFiles();
         StringBuilder builder = null;
 
         for (File file : files) {
             builder = new StringBuilder(100);
             String name = file.getName();
             if (name != null) {
                 name = name.trim();
                 builder.append(parent).append("/").append(name);
                 String packageOrClass = parent == null ? name : builder.toString();
 
                 if (file.isDirectory()) {
                     loadImplementationsInDirectory(test, packageOrClass, file, classes);
                 } else if (name.endsWith(".class")) {
                     addIfMatching(test, packageOrClass, classes);
                 }
             }
         }
     }
 
     /**
      * Finds matching classes within a jar files that contains a folder structure matching the package structure. If the
      * File is not a JarFile or does not exist a warning will be logged, but no error will be raised.
      * 
      * @param test
      *            a Test used to filter the classes that are discovered
      * @param parent
      *            the parent package under which classes must be in order to be considered
      * @param stream
      *            the inputstream of the jar file to be examined for classes
      * @param urlPath
      *            the url of the jar file to be examined for classes
      */
     protected void loadImplementationsInJar(PackageScanFilter test, String parent, InputStream stream, String urlPath,
             Set<Class<?>> classes) {
         JarInputStream jarStream = null;
         try {
 
             if (!classesByJarUrl.containsKey(urlPath)) {
                 Set<String> names = new HashSet<String>();
 
                 if (stream instanceof JarInputStream) {
                     jarStream = (JarInputStream) stream;
                 } else {
                     jarStream = new JarInputStream(stream);
                 }
 
                 JarEntry entry;
                 while ((entry = jarStream.getNextJarEntry()) != null) {
                     String name = entry.getName();
                     if (name != null) {
                         name = name.trim();
                         if (!entry.isDirectory() && name.endsWith(".class")) {
                             names.add(name);
                         }
                     }
                 }
 
                 classesByJarUrl.put(urlPath, names);
             }
 
             for (String name : classesByJarUrl.get(urlPath)) {
                 if (name.startsWith(parent)) {
                     addIfMatching(test, name, classes);
                 }
             }
         } catch (IOException ioe) {
             log.warning("Cannot search jar file '" + urlPath + "' for classes matching criteria: " + test
                     + " due to an IOException: " + ioe.getMessage(), ioe);
         } finally {
             try {
                 if (jarStream != null) {
                     jarStream.close();
                 }
             } catch (IOException ignore) {
             }
         }
     }
 
     /**
      * Add the class designated by the fully qualified class name provided to the set of resolved classes if and only if
      * it is approved by the Test supplied.
      * 
      * @param test
      *            the test used to determine if the class matches
      * @param fqn
      *            the fully qualified name of a class
      */
     protected void addIfMatching(PackageScanFilter test, String fqn, Set<Class<?>> classes) {
         try {
             String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
             Set<ClassLoader> set = getClassLoaders();
             boolean found = false;
             for (ClassLoader classLoader : set) {
                 log.debug("Testing that class " + externalName + " matches criteria [" + test + "] using classloader:"
                         + classLoader);
                 try {
                     Class<?> type = classLoader.loadClass(externalName);
                     log.debug("Loaded the class: " + type + " in classloader: " + classLoader);
                     if (test.matches(type)) {
                         log.debug("Found class: " + type + " which matches the filter in classloader: " + classLoader);
                         classes.add(type);
                     }
                     found = true;
                     break;
                 } catch (ClassNotFoundException e) {
                     log.debug("Cannot find class '" + fqn + "' in classloader: " + classLoader + ". Reason: " + e, e);
                 } catch (NoClassDefFoundError e) {
                     log.debug("Cannot find the class definition '" + fqn + "' in classloader: " + classLoader
                             + ". Reason: " + e, e);
                 } catch (Throwable e) {
                     log.severe("Cannot load class '" + fqn + "' in classloader: " + classLoader + ".  Reason: " + e, e);
                 }
             }
             if (!found) {
                 // use debug to avoid being noisy in logs
                 log.debug("Cannot find class '" + fqn + "' in any classloaders: " + set);
             }
         } catch (Exception e) {
             log.warning(
                     "Cannot examine class '" + fqn + "' due to a " + e.getClass().getName() + " with message: "
                             + e.getMessage(), e);
         }
     }
 
 }