package org.codehaus.classloader;

import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;

/**
 * This class loader will delegate to the ClassLoaderManager object when a class or resource
 * is not found within the realm of itself.
 * <p>
 * @author Ben Yu
 * Aug 2, 2006 9:53:38 PM
 */
public class ManagedURLClassLoader extends URLClassLoader implements ClassProvider{
  private final ClassLoaderManager man;
  
  private final ThreadLocal current_manager = new ThreadLocal(){
    protected Object initialValue() {
      return getManager();
    }
  };
  /*
  private final HashMap cache = new HashMap();
  private Class getCachedClass(String name){
    synchronized(cache){
      final WeakReference ref = (WeakReference)cache.get(name);
      if(ref==null)
        return null;
      return (Class)ref.get();
    }
  }
  private void cacheClass(String name, Class cls){
    synchronized(cache){
      cache.put(name, new WeakReference(cls));
    }
  }
  */
  private ClassLoaderManager getCurrentManager() {
    return (ClassLoaderManager)current_manager.get();
  }
  private void resetCurrentManager(){
    current_manager.set(man);
  }
  private void clearCurrentManager(){
    current_manager.set(NilClassLoaderManager.instance());
  }
  
  public ClassLoaderManager getManager(){
    return man;
  }

  public ManagedURLClassLoader(ClassLoaderManager man, URL[] urls, ClassLoader parent) {
    super(urls, parent);
    this.man = man;
  }

  public ManagedURLClassLoader(ClassLoaderManager man, URL[] urls) {
    super(urls);
    this.man = man;
  }
  protected Class loadClass(String name, boolean resolve)
      throws ClassNotFoundException {
    //System.out.println("loading "+name+" by "+this);
    /*final Class cached = getCachedClass(name);
    if(cached!=null){
      //System.out.println("cache hit");
      return cached;
    }*/
    try{
      return super.loadClass(name, resolve);
    }
    catch(ClassNotFoundException e){
      final Class cls = getCurrentManager().lookupClass(this, name);
      //cacheClass(name, cls);
      //System.out.println("save in cache");
      return cls;
    }
  }
  public URL getResource(String name) {
    URL url = super.getResource(name);
    if(url==null)
      url = getCurrentManager().lookupResource(this, name);
    return url;
  }

  /*
   * more ideal to override getResources in order to avoid super class calls back down.
   * But getResources() is final below 1.4. So have to use findResources and utilize thread local
   * to temporarily disable looking up for when the super class looks back down.
   */
  public Enumeration findResources(String name) throws IOException {
    return new ConcatEnumeration(super.findResources(name), getCurrentManager().lookupResources(this, name));
  }

/*
  protected Package getPackage(String name) {
    Package pkg = super.getPackage(name);
    if(pkg==null){
      pkg = getCurrentManager().lookupPackage(this, name);
    }
    return pkg;
  }

  protected Package[] getPackages() {
    final ArrayList buf = new ArrayList();
    buf.addAll(Arrays.asList(super.getPackages()));
    buf.addAll(Arrays.asList(getCurrentManager().lookupPackages(this)));
    final Package[] result = new Package[buf.size()];
    buf.toArray(result);
    return result;
  }
*/
  protected String findLibrary(String libname) {
    String result = super.findLibrary(libname);
    if(result==null){
      result = getCurrentManager().lookupLibrary(this, libname);
    }
    return result;
  }

  public Class provideClass(String name) throws ClassNotFoundException {
    return super.loadClass(name, false);
    /*
    clearCurrentManager();
    try{
      return super.loadClass(name, false);
    }
    finally{
      resetCurrentManager();
    }*/
  }

  public String provideLibrary(String libname) {
    clearCurrentManager();
    try{
      return super.findLibrary(libname);
    }
    finally{
      resetCurrentManager();
    }
  }
/*
  public Package[] providePackages() {
    clearCurrentManager();
    try{
      return super.getPackages();
    }
    finally{
      resetCurrentManager();
    }
  }

  public Package providePackage(String name) {
    clearCurrentManager();
    try{
      return super.getPackage(name);
    }
    finally{
      resetCurrentManager();
    }
  }
*/
  public URL provideResource(String name) {
    clearCurrentManager();
    try{
      return super.getResource(name);
    }
    finally{
      resetCurrentManager();
    }
  }

  public Enumeration provideResources(String name) throws IOException {
    clearCurrentManager();
    try{
      return super.getResources(name);
    }
    finally{
      resetCurrentManager();
    }
  }
  public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append(getClass().getName());
    buf.append(" - [");
    URL[] urls = super.getURLs();
    for(int i=0; i<urls.length; i++){
      if(i>0)
        buf.append(";");
      buf.append(urls[i]);
    }
    buf.append("]");
    return buf.toString();
  }

}