/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.properties.utils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.NoSuchElementException;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * A class loader that serves classes from the given directories.
   */
  public final class ProjectClassLoader extends AbstractProjectClassLoader
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The list of root directories and Java archive files to search for classes.
     */
    private final List<File> rootDirectories;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param parent the parent class loader.
     * @param rootDirectories the list of root directories to search for classes.
     */
    private ProjectClassLoader(final ClassLoader parent,
        final List<File> rootDirectories)
    {
      super(parent);
      this.rootDirectories = Collections.unmodifiableList(rootDirectories);
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    /**
     * Checks the directories for accessibility as root directories. Any directory
     * that is not accessible is dismissed and a debug message is logged.
     *
     * @param log the logger to use for logging debug messages.
     * @param directoryNames the collection of directory names to analyze.
     * @return the valid directories.
     */
    private static List<File> initDirectories(final Logger log,
        final Collection<String> directoryNames)
    {
      final List<File> directories = new ArrayList<File>(directoryNames.size());
      for (final String directoryName : directoryNames)
      {
        final File directory = new File(directoryName);
        if (directory.canRead()
            && (directory.isDirectory() || directory.isFile()
                                           && isArchive(directoryName)))
        {
          directories.add(directory);
        }
        else
        {
          if (log.isDebugEnabled())
          {
            final String message =
                "Cannot access '" + directoryName
                    + "' as directory or Java archive."
                    + " Ignoring as classpath root.";
            log.debug(message);
         }
       }
     }
     return directories;
   }
 
   /**
    * Checks if the given root refers to an archive or not. Simply the file
    * extension is checked. Accessibility et al. is not considered.
    *
    * @param root the root to check.
    * @return <code>true</code> if root refers to an archive file,
    *         <code>false</code> otherwise.
    * @throws NullPointerException if <code>root</code> is <code>null</code>.
    */
   private static boolean isArchive(final String root)
     throws NullPointerException
   {
     return root.endsWith(".jar") || root.endsWith(".zip");
   }
 
   // --- create ---------------------------------------------------------------
 
   /**
    * Convenience factory method using the
    * <code>Thread.currentThread().getContextClassLoader()</code>.
    *
    * @param rootDirectories the list of root directories to search for classes.
    * @return the requested instance.
    */
   public static ProjectClassLoader create(final List<File> rootDirectories)
   {
     return create(Thread.currentThread().getContextClassLoader(),
         rootDirectories);
   }
 
   /**
    * Convenience factory method to specify the directories as {@link String}s
    * and using the <code>Thread.currentThread().getContextClassLoader()</code>.
    *
    * @param rootDirectoryNames the list of root directory names to search for
    *          classes.
    * @return the requested instance.
    */
   public static ProjectClassLoader createFromNames(
       final Collection<String> rootDirectoryNames)
   {
     return create(initDirectories(
         LoggerFactory.getLogger(ProjectClassLoader.class), rootDirectoryNames));
   }
 
   /**
    * Convenience factory method to specify the directories as {@link String}s.
    *
    * @param parent the parent class loader.
    * @param rootDirectoryNames the list of root directory names to search for
    *          classes.
    * @return the requested instance.
    */
   public static ProjectClassLoader createFromNames(final ClassLoader parent,
       final Collection<String> rootDirectoryNames)
   {
     return new ProjectClassLoader(parent, (List<File>) initDirectories(
         LoggerFactory.getLogger(ProjectClassLoader.class), rootDirectoryNames));
   }
 
   /**
    * Default factory method.
    *
    * @param parent the parent class loader.
    * @param rootDirectories the list of root directories to search for classes.
    * @return the requested instance.
    */
   public static ProjectClassLoader create(final ClassLoader parent,
       final List<File> rootDirectories)
   {
     return new ProjectClassLoader(parent, rootDirectories);
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   @Override
   protected URL findResource(final String name)
   {
     for (File directoryOrArchive : rootDirectories)
     {
       try
       {
         if (directoryOrArchive.isDirectory())
         {
           final File resourceFile = new File(directoryOrArchive, name);
           if (resourceFile.canRead())
           {
             return resourceFile.toURI().toURL();
           }
         }
         else
         {
           String resourceName = name;
           final int index = name.lastIndexOf('.');
           if (index != -1)
           {
             resourceName = name.substring(0, index);
           }
           resourceName = resourceName.replace('/', '.');
           return loadResourceFromLibrary(resourceName, name, directoryOrArchive);
         }
       }
       catch (final IOException e)
       {
         // Ignore this and try the next location...
       }
     }
     return super.findResource(name);
   }
 
   @Override
   protected Enumeration<URL> findResources(final String name)
   {
     return new Enumeration<URL>()
     {
       private URL element = findResource(name);
 
       public boolean hasMoreElements()
       {
         return this.element != null;
       }
 
       public URL nextElement()
       {
         if (this.element != null)
         {
           final URL element = this.element;
           this.element = null;
           return element;
         }
         throw new NoSuchElementException();
       }
     };
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   protected Class<?> findClass(final String name) throws ClassNotFoundException
   {
     for (File directoryOrArchive : rootDirectories)
     {
       try
       {
         final String fileName = name.replace('.', '/') + ".class";
         if (directoryOrArchive.isDirectory())
         {
           final File classFile = new File(directoryOrArchive, fileName);
           if (classFile.canRead())
           {
             return loadClassFile(name, classFile);
           }
         }
         else
         {
           return loadClassFromLibrary(name, fileName, directoryOrArchive);
         }
       }
       catch (final ClassNotFoundException e)
       {
         // Ignore this and try the next location...
       }
     }
     return super.findClass(name);
   }
 
   // --- object basics --------------------------------------------------------
 
 }