package com.explosion.utilities.classes;
   
   /*
    * =============================================================================
    * 
    * Copyright 2004 Stephen Cowx
    * 
    * 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.
   * 
   * =============================================================================
   */
  
  import java.io.DataInputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.security.SecureClassLoader;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import org.apache.log4j.LogManager;
  import org.apache.log4j.Logger;
  
  import com.explosion.utilities.exception.ExceptionManagerFactory;
  
  public class JarFileClassLoader extends SecureClassLoader
  {
  
      private JarFile jarFile;
  
      private Manifest manifest;
  
      private HashMap classNameIndex = new HashMap();
  
      private HashMap loadedClasses = new HashMap();
  
      private static Logger log = LogManager.getLogger(JarFileClassLoader.class);
  
      public JarFileClassLoader(ClassLoader parent, String jarFilePath) throws IllegalArgumentException, IOException
      {
          super(parent);
          log.debug("Constructing new JarFileCLassLoader");
          if (jarFilePath == null)
              throw new IllegalArgumentException("Null jarfile path");
  
          File file = new File(jarFilePath);
          if (!file.exists())
              throw new IllegalArgumentException("File '" + jarFilePath + "' does not exist.");
  
          if (!file.exists())
              throw new IllegalArgumentException("Path '" + jarFilePath + "' points to a directory and not a jar file.");
  
          this.jarFile = new JarFile(jarFilePath);
  
          manifest = jarFile.getManifest();
  
          buildIndex(jarFilePath);
      }
  
      /***
       * This method builds an index of entries in the jarfile
       * 
       * @param jarFile
       * @throws Exception
       */
      private void buildIndex(String jarFile) throws IOException
      {
          log.debug("Building the entry name index");
          if (jarFile != null)
          {
              JarFile file = new JarFile(jarFile);
              Enumeration en = file.entries();
              while (en.hasMoreElements())
              {
                  JarEntry entry = (JarEntry) en.nextElement();
                  String name = entry.getName();
  
                  int index = name.lastIndexOf(".");
  
                  if (index < 0)
                      index = name.length();
  
                  String key = name.substring(0, index);
                  log.debug("Indexing: Entry " + name + " Key derived " + key);
  
                  if (classNameIndex.get(key) != null)
                     throw new IOException("Duplicate key '" + key + "' found in jar file " + jarFile);
                 else
                     classNameIndex.put(key, entry.getName());
             }
 
         }
     }
 
     /***
      * This method loads a class
      *  
      */
     public Class findClass(String name) throws ClassNotFoundException
     {
         try
         {   
             log.debug("Looking for "+name+" in the store");
             /* First check in our store to see if we have loaded this class before */
             Class c = (Class) loadedClasses.get(name);
             if (c != null)
                 return c;
 
             log.debug("Not found in the store, .loading from disk");
             /* If we haven't then try to load it from the file */
             byte data[] = null;
             data = loadClassData(name);
 
             if (data == null)
                 throw new ClassNotFoundException(name);
             
             log.debug("Found on disk");
             
             try
             {
                 /*  Create a class */
                 c = defineClass(name, data, 0, data.length);
                 log.debug("Defined "+name+".");
                 
                 /* Store it so that we don't reload it again later it */
                 log.debug("Inserting "+name+" into store.");
                 loadedClasses.put(name, c);
 
             } catch (NoClassDefFoundError cnfe)
             {
                 c = null;
             }
 
             /*  */
             if (c == null) { throw new ClassNotFoundException(name); }
 
             return c;
         } catch (IOException e)
         {
             throw new ClassNotFoundException("Error reading file: " + name);
         }
 
     }
 
     /***
      * Looks up the entryname in the index and then loads the class
      * 
      * @param name
      * @param jarFile
      * @return @throws IOException
      */
     private byte[] loadClassData(String name) throws IOException
     {
         log.debug("loadClassData() Loading: " + name);
         JarEntry entry = getEntry(name, jarFile);
         if (entry != null)
         {
             byte buff[] = new byte[(int) entry.getSize()];
             DataInputStream dis = new DataInputStream(jarFile.getInputStream(entry));
             try
             {
                 dis.readFully(buff);
             } finally
             {
                 try
                 {
                     dis.close();
                 } catch (Exception e)
                 {// ignore
                 }
             }
             return buff;
         }
 
         return null;
     }
 
     /***
      * @see java.lang.ClassLoader#getResourceAsStream(java.lang.String)
      * @param name
      * @return
      */
     public InputStream getResourceAsStream(String name)
     {
         log.debug("getResourceAsStream() getting: " + name);
         JarEntry entry = getEntry(name, jarFile);
         if (entry != null)
         {
             try
             {
                 return jarFile.getInputStream(entry);
             } catch (IOException e)
             {
                 ExceptionManagerFactory.getExceptionManager().manageException(e, "Exception caught while obtaingin resource.");
             }
         }
 
         return null;
     }
 
     /***
      * This method looks up a particular entry in the jar file. It performs
      * string manipulation on the name to convert "." to "/" and other things
      * 
      * @param name
      * @param file
      * @return
      */
     private JarEntry getEntry(String name, JarFile file)
     {
         log.debug("getEntry getting entry " + name);
         String entryName = (String) classNameIndex.get(name.replace('.', '/'));
         if (entryName == null && File.separatorChar != '/')
             entryName = (String) classNameIndex.get(name.replace('.', File.separatorChar));
 
         if (entryName == null)
             log.debug("Name " + name + " not found in index.");
         else
             log.debug("Name " + name + " was found in index.  Using corresponding lookup entry '" + entryName + "'.");
 
         return file.getJarEntry(entryName);
     }
 }