/*
   *
   * Distributable under LGPL license.
   * See terms of license at gnu.org.
   */
   package org.backsource.utils.lang;
   
   import java.net.URL;
   import java.net.URLClassLoader;
  import java.util.Enumeration;
  import java.util.Vector;
  /***
   * <p>A URLClassLoader wrapper that loads classes and resouces first from the
   leafs of the classloader tree, and not from the root as is the case with
   the sun classloader.
   
   <p>It is important to understand that all classes are loaded into the classloader wrapper and the new wrapper it created around its parent.
   
   <p>It is also important to know that if a URLClassLoader has a parent that is not a URLClassLoader, the normal classloading and resource finding mechanisms will be used.
  
   <p>May be really handy if you want to override a resource (or class) in 
   a component loaded in leaf classloader, as is often the case in JBoss and Tomcat for example.
   *
   *
   * @author Peter Antman
   * @version $Revision: 1.1.1.1 $
   */
  
  public class ReverseClassLoader  extends URLClassLoader{
      ClassLoader  wrappedClassLoader= null;
      
      /***
       * <p>Wrap a URLClassLoader.
       *
       * <p>The all URLs the classloader wikk be search first, and lodaded
       * in this classloader, and not in the wrapped one.
       */
      public ReverseClassLoader(URLClassLoader wrappedClassLoader) {
  	super(wrappedClassLoader.getURLs(), wrappedClassLoader.getParent());
  	this.wrappedClassLoader = wrappedClassLoader;
      }
  
      public ClassLoader getWrappedClassLoader() {
  	return wrappedClassLoader;
      }
  
      /***
       * Get resource through a bottom up search. I.e try find the resource
       * in the wrapped loader before proceding to the parent.
       */
      public URL getResource(String name) {
  	return getResource(this,name);
      }
  
      /***
       * Try find the resource in the classloader, if not proced to parent.
       * If parent is null, call getResource on the cl.
       */
      private URL getResource(ReverseClassLoader cl, String name) {
  	URL url = cl.findResource(name);
  	if (url != null)
  	    return url;
  	else {
  	    // Go to parent, wrap it in reverse to get protected methods to work
  	    ClassLoader parent = cl.getParent();
  
  	    if (parent !=null) {
  		if(parent instanceof URLClassLoader) {
  		    // Wrap it and continue
  		    ReverseClassLoader wrap = new ReverseClassLoader((URLClassLoader)parent);
  		    return getResource(wrap,name);
  		}else {
  		    // Can't wrap ordinary cl, let it do its jobb.
  		    return parent.getResource(name);
  		}
  	    } else {
  		// We are at the top, call get on the cl and let it call,
  		// System CL if it wants
  		return cl.getWrappedClassLoader().getResource(name);
  	    }
  	}
      }
  
      public URL findResource(String name) {
  	return super.findResource(name);
      }
      /*
       * Try find the resources and list them in reverse order compared to
       whats normal. This is a heavy waigth operation.
       */
      
      //public Enumeration getResources(String name) throws IOException {
  	// this bugger is final, lets see if this works.
      //	return reverseEnumeration(super.getResources(name));
      //}
      /***
       * Try find the resurce in the classloader, if not proced to parent.
       * If parent is null, call getResource on the cl.
       *
      */
     private Enumeration reverseEnumeration(Enumeration enum) {
 	Vector v = new Vector();
 	while(enum.hasMoreElements()) {
 	    v.add(enum.nextElement());
 	}
 	Vector rev = new Vector();
 	for(int i = v.size(); i > 0; i--) {
 	    rev.add(v.elementAt(i-1));
 	}
 	return rev.elements();
     }
 
     /***
      * <p>Load a class by looking in this classloader and searching upwards as
      * long as the parent classloaders are URLClassloader.
      *
      * <p>It is important to notice that the classes will be loaded in this
      * classloader or in any of its contsucted parents (also ReverseClassLoader) and not in the wrapped classloader.
      */
     public Class loadClass(String name) throws ClassNotFoundException {
 	return loadClass(this,name);
     }
 
     /* Protected so cant use it on final loader
     protected synchronized Class loadClass(String name, boolean resolve)
         throws ClassNotFoundException
     {
 	return loadClass(this,name,resolve);
     }
     */
     protected Class loadClass(ReverseClassLoader cl, String name)
         throws ClassNotFoundException
     {
         // First, check if the class has already been loaded
         Class c = cl.findLoadedClass(name);
         if (c == null) {
 	    // try find
 	    try {
 		c = cl.findClass(name);
 	    }catch(ClassNotFoundException e) {
 		// Class not found procede to parent
 		ClassLoader parent = cl.getParent();
 		if (parent !=null) {
 		    if (parent instanceof URLClassLoader) {
 			ReverseClassLoader wrap = new ReverseClassLoader((URLClassLoader)parent);
 			return loadClass(wrap,name);
 		    }else {
 			return parent.loadClass(name);
 		    }
 		} else {
 		    // We are at the top, call get on the cl and let it call,
 		    // System CL if it wants
 		    return cl.getWrappedClassLoader().loadClass(name);
 		    //return cl.loadClassParent(name,resolve);
 		}
 	    }
 	    
         }
 	return c;
     }
 
 
     
 
 
 } // ReverseClassLoader