/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.tomcat.util.loader;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;
import java.util.Vector;

/*
 * Initially, I started with WebappClassLoader attempting to clean up and
 * refactor it. Because of complexity and very weird ( and likely buggy ) 
 * behavior, I moved the other way, starting with URLClassLoader and adding
 * the functionality from WebappClassLoader. 
 * 
 * The current version has a lot of unimplemented WebappClassLoader features and
 * TODOs - all of them are needed in order to support a single/consistent loader
 * for webapps and server/modules. 
 * 
 * - all ordering options and tricks
 * - local loading - in case it can be made more efficient than URLCL
 * - hook to plugin JNDI finder
 * - ability to add extra permissions to loaded classes
 * - ability to use work dir for anti-jar locking and generated classes ( incl getURLs)
 * 
 * 
 * Things better kept out:
 *  - negative cache - it'll waste space with little benefit, most not found classes
 *  will not be asked multiple times, and most will be in other loaders
 *  - binaryContent cache - it's unlikely same resource will be loaded multiple
 * times, and some may be large  
 * 
 */

/**
 * Simple module class loader. Will search the repository if the class is not
 * found locally.
 * 
 * TODO: findResources() - merge all responses from the repo and parent. 
 *
 * Based on StandardClassLoader and WebappClassLoader.
 *   
 * @author Costin Manolache
 * @author Remy Maucherat
 * @author Craig R. McClanahan
 */
public class ModuleClassLoader
    extends URLClassLoader
{
    // Don't use commons logging or configs to debug loading - logging is dependent
    // on loaders and drags a lot of stuff in the classpath 
    //
    private static final boolean DEBUG=false; //LoaderProperties.getProperty("loader.debug.ModuleClassLoader") != null;
    private static final boolean DEBUGNF=false;//LoaderProperties.getProperty("loader.debug.ModuleClassLoaderNF") != null;
    
    // ----------------------------------------------------------- Constructors


    public ModuleClassLoader(URL repositories[], ClassLoader parent) {
        super(repositories, parent);
        if(DEBUG) log( "NEW ModuleClassLoader  " + parent + " " + repositories.length);
        updateStamp();
    }
    

    public ModuleClassLoader(URL repositories[]) {
        super(repositories);
        if(DEBUG) log( "NEW ModuleClassLoader  -null-"+ " " + repositories.length);
        updateStamp();
    }


    // ----------------------------------------------------- Instance Variables

    protected Repository repository;

    /**
     * Should this class loader delegate to the parent class loader
     * <strong>before</strong> searching its own repositories (i.e. the
     * usual Java2 delegation model)?  If set to <code>false</code>,
     * this class loader will search its own repositories first, and
     * delegate to the parent only if the class or resource is not
     * found locally.
     */
    protected boolean delegate = false;

    /**
     * Last time a JAR was accessed. 
     * TODO: change to last time the loader was accessed
     */
    protected long lastJarAccessed = 0L;

    protected long lastModified=0L;
    
    /**
     * Has this component been started?
     */
    protected boolean started = false;

    protected Module module;

    // ------------------------------------------------------------- Properties

    /**
     * Set the "delegate first" flag for this class loader.
     *
     * @param delegate The new "delegate first" flag
     */
    void setDelegate(boolean delegate) {
        this.delegate = delegate;
    }

    void setRepository(Repository lg ) {
        this.repository=lg;
    }

    void setModule(Module webappLoader) {
        this.module=webappLoader;
    }

    /** Not public - his can only be called from package.
     *  To get the module from a ClassLoader you need access to the Loader
     * instance.
     * 
     * @return
     */
    Module getModule() {
        return module;
    }

    void setWorkDir(File s) {
        // TODO
    }

    /**
     * Add a new repository to the set of places this ClassLoader can look for
     * classes to be loaded.
     *
     * @param repository Name of a source of classes to be loaded, such as a
     *  directory pathname, a JAR file pathname, or a ZIP file pathname
     *
     * @exception IllegalArgumentException if the specified repository is
     *  invalid or does not exist
     */
    void addRepository(String repository) {
        // Add this repository to our underlying class loader
        try {
            boolean mod=modified();
            URL url = new URL(repository);
            super.addURL(url);
            if( ! mod ) {
                // don't check if it is modified, so it works
                updateStamp();
            }
        } catch (MalformedURLException e) {
            IllegalArgumentException iae = new IllegalArgumentException
                ("Invalid repository: " + repository); 
            iae.initCause(e);
            //jdkCompat.chainException(iae, e);
            throw iae;
        }
    }

    void updateStamp() {
        URL cp[]=super.getURLs();
        if (cp != null ) {
            for (int i = 0; i <cp.length; i++) {
                File f=new File(cp[i].getFile());
                long lm=f.lastModified();
                if( lm > lastModified ) lastModified=lm;
            }
        }
    }
    
    private boolean dirCheck(File dir ) {
        //log("Checking " + dir );
        File subd[]=dir.listFiles();
        for( int i=0; i< subd.length; i++ ) {
            long lm=subd[i].lastModified();
            if( lm > lastModified ) {
                log("Modified file: " + dir + " " + subd[i] + " " + lm + " " + lastModified);
                return true;
            }
            if( subd[i].isDirectory() ) {
                return  dirCheck(subd[i]);
            }
        }
        return false;
    }
    
    /**
     * Have one or more classes or resources been modified so that a reload
     * is appropriate?
     * 
     * Not public - call it via Module
     */
    boolean modified() {
        URL cp[]=super.getURLs();
        if (cp != null ) {
            for (int i = 0; i <cp.length; i++) {
                File f=new File(cp[i].getFile());
                long lm=f.lastModified();
                if( lm > lastModified ) {
                    log( "Modified file: " + f + " " + lm + " " + lastModified);
                    return true;
                }
                // assume dirs are used only for debug and small
                if( f.isDirectory() ) {
                    return dirCheck(f);
                }
            }
        }

        if (DEBUG)
            log("modified() false");

        // TODO - check at least the jars 
        return (false);
    }

    // ---------------------------------------------------- ClassLoader Methods


    /**
     * Find the specified class in our local repositories, if possible.  If
     * not found, throw <code>ClassNotFoundException</code>.
     *
     * @param name Name of the class to be loaded
     *
     * @exception ClassNotFoundException if the class was not found
     */
    public Class findClass(String name) throws ClassNotFoundException {
        return findClass2(name, true);
    }
    
    public Class findClass2(String name, boolean del2repo) throws ClassNotFoundException {
        if( del2repo ) {
            return ((RepositoryClassLoader)repository.getClassLoader()).findClass(name);            
        } // else 
 
        Class clazz = null;
            
        try {
            clazz = super.findClass(name);
        } catch (RuntimeException e) {
            if (DEBUG)
                log("findClass() -->RuntimeException " + name, e);
            throw e;
        } catch( ClassNotFoundException ex ) {
            URL cp[]=this.getURLs();
            if (DEBUGNF)
                log("findClass() NOTFOUND  " + name + " " + (( cp.length > 0 ) ? cp[0].toString() : "") );
            throw ex;
        }
            
        if (clazz == null) { // does it ever happen ? 
            if (DEBUGNF)
                log("findClass() NOTFOUND throw CNFE " + name);
            throw new ClassNotFoundException(name);
        }

        // Return the class we have located
        if (DEBUG) {
            if( clazz.getClassLoader() != this ) 
                log("findClass() FOUND " + clazz + " Loaded by " + clazz.getClassLoader());
            else 
                log("findClass() FOUND " + clazz );
        }
        return (clazz);
    }
    
    /** Same as findClass, but also checks if the class has been previously 
     * loaded.
     * 
     * In most implementations, findClass() doesn't check with findLoadedClass().
     * In order to implement repository, we need to ask each loader in the group
     * to load only from it's local resources - however this will lead to errors
     * ( duplicated definition ) if findClass() is used.
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    public Class findLocalClass(String name) throws ClassNotFoundException
    {
        Class clazz = findLoadedClass(name);
        if (clazz != null) {
            if (DEBUG)
                log("findLocalClass() - FOUND " + name);
            return (clazz);
        }
        
        return findClass(name);
    }


    /**
     * Find the specified resource in our local repository, and return a
     * <code>URL</code> refering to it, or <code>null</code> if this resource
     * cannot be found.
     *
     * @param name Name of the resource to be found
     */
    public URL findResource(final String name) {
        return findResource2( name, true);
    }
        
    public URL findResource2(final String name, boolean del2repo ) {
        if( del2repo ) {
            return ((RepositoryClassLoader)repository.getClassLoader()).findResource(name);
        } // else:

        URL url = null;

        url = super.findResource(name);
        
        if(url==null) {
            // try the repository
            // TODO
        }
        
        if (url==null && DEBUG) {
            if (DEBUGNF) log("findResource() NOTFOUND " + name );
            return null;
        }

        if (DEBUG) log("findResource() found " + name + " " + url );
        return (url);
    }


    /**
     * Return an enumeration of <code>URLs</code> representing all of the
     * resources with the given name.  If no resources with this name are
     * found, return an empty enumeration.
     *
     * @param name Name of the resources to be found
     *
     * @exception IOException if an input/output error occurs
     */
    public Enumeration findResources(String name) throws IOException {
        return findResources2(name, true);
    }
    
    Enumeration findResources2(String name, boolean del2repo) throws IOException {
        if( del2repo ) {
            return ((RepositoryClassLoader)repository.getClassLoader()).findResources(name);
        } else {
            return super.findResources(name);
        }
    }

    // Next methods implement the search alghoritm - parent, repo, delegation, etc 

    /** getResource() - modified to implement the search alghoritm 
     * 
     */
    public URL getResource(String name) {
        return getResource2( name, null, true);
    }

    /** getResource() - same thing, but don't delegate to repo if called 
     * from repo 
     * 
     */
    URL getResource2(String name, ClassLoader originator, boolean delegate2repo ) {

        URL url = null;

        // (1) Delegate to parent if requested
        if (delegate) {
            url=getResourceParentDelegate(name);
            if(url!=null ) return url;
        }

        // (2) Search local repositories
        url = findResource(name);
        if (url != null) {
            // TODO: antijar locking - WebappClassLoader is making a copy ( is it ??)
            if (DEBUG)
                log("getResource() found locally " + delegate + " " + name + " " + url);
            return (url);
        }

        // Finally, try the group loaders ( via super() in StandardClassLoader ).
        // not found using normal loading mechanism. load from one of the classes in the group
        if( delegate2repo && repository!=null ) {
            url=repository.findResource(this, name);
            if(url!=null ) {
                if( DEBUG )
                    log("getResource() FOUND from group " + repository.getName() + " " + name + " " + url);
                return url;
            }
        }

        // (3) Delegate to parent unconditionally if not already attempted
        if( !delegate ) {
            url=getResourceParentDelegate(name);
            if(url!=null ) return url;
        }

        
        // (4) Resource was not found
        if (DEBUGNF)
            log("getResource() NOTFOUND  " + delegate + " " + name + " " + url);
        return (null);

    }

    
    // to avoid duplication - get resource from parent, when delegating
    private URL getResourceParentDelegate(String name) {
        URL url=null;
        ClassLoader loader = getParent();
        
        if (loader == null) {
            loader = getSystemClassLoader();
            if (url != null) {
                if (DEBUG)
                    log("getResource() found by system " +  delegate + " " + name + " " + url);
                return (url);
            }
        } else {
            url = loader.getResource(name);
            if (url != null) {
                if (DEBUG)
                    log("getResource() found by parent " +  delegate + " " + name + " " + url);
                return (url);
            }
        }
        if( DEBUG ) log("getResource not found by parent " + loader);

        return url;
    }
    
    /**
     * Load the class with the specified name, searching using the following
     * algorithm until it finds and returns the class.  If the class cannot
     * be found, returns <code>ClassNotFoundException</code>.
     * <ul>
     * <li>Call <code>findLoadedClass(String)</code> to check if the
     *     class has already been loaded.  If it has, the same
     *     <code>Class</code> object is returned.</li>
     * <li>If the <code>delegate</code> property is set to <code>true</code>,
     *     call the <code>loadClass()</code> method of the parent class
     *     loader, if any.</li>
     * <li>Call <code>findClass()</code> to find this class in our locally
     *     defined repositories.</li>
     * <li>Call the <code>loadClass()</code> method of our parent
     *     class loader, if any.</li>
     * </ul>
     * If the class was found using the above steps, and the
     * <code>resolve</code> flag is <code>true</code>, this method will then
     * call <code>resolveClass(Class)</code> on the resulting Class object.
     *
     * @param name Name of the class to be loaded
     * @param resolve If <code>true</code> then resolve the class
     *
     * @exception ClassNotFoundException if the class was not found
     */
    public Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        return loadClass2( name, resolve, true );
    }
    
    public Class loadClass2(String name, boolean resolve, boolean del2repo)
        throws ClassNotFoundException
    {

        Class clazz = null;

        // Don't load classes if class loader is stopped
        if (!started) {
            log("Not started " + this + " " + module);
            //throw new ThreadDeath();
            start();
        }

        // (0) Check our previously loaded local class cache
        clazz = findLoadedClass(name);
        if (clazz != null) {
            if (DEBUG)
                log("loadClass() FOUND findLoadedClass " + name + " , " + resolve);
            if (resolve) resolveClass(clazz);
            return (clazz);
        }

        // (0.2) Try loading the class with the system class loader, to prevent
        //       the webapp from overriding J2SE classes
        try {
            clazz = getSystemClassLoader().loadClass(name);
            if (clazz != null) {
                // enabling this can result in ClassCircularityException
//                if (DEBUG)
//                    log("loadClass() FOUND system " + name + " , " + resolve);
                if (resolve) resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            // Ignore
        }

        // TODO: delegate based on filter
        boolean delegateLoad = delegate;// || filter(name);

        // (1) Delegate to our parent if requested
        if (delegateLoad) {

            ClassLoader loader = getParent();
            if( loader != null ) {
                try {
                    clazz = loader.loadClass(name);
                    if (clazz != null) {
                        if (DEBUG)
                            log("loadClass() FOUND by parent " + delegate + " " + name + " , " + resolve);
                        if (resolve)
                            resolveClass(clazz);
                        return (clazz);
                    }
                } catch (ClassNotFoundException e) {
                    ;
                }
            }
        }

        // (2) Search local repositories
        try {
            clazz = findClass(name);
            if (clazz != null) {
                if (DEBUG)
                    log("loadClass - FOUND findClass " + delegate + " " + name + " , " + resolve);
                if (resolve) resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            ;
        }

        // Finally, try the group loaders ( via super() in StandardClassLoader ).
        // not found using normal loading mechanism. load from one of the classes in the group
        if( del2repo && repository!=null ) {
            Class cls=repository.findClass(this, name);
            if(cls!=null ) {
                if( DEBUG )
                    log("loadClass(): FOUND from group " + repository.getName() + " " + name);
                if (resolve) resolveClass(clazz);
                return cls;
            }
        }

        // (3) Delegate to parent unconditionally
        if (!delegateLoad) {
            ClassLoader loader = getParent();
            if( loader != null ) {
                try {
                    clazz = loader.loadClass(name);
                    if (clazz != null) {
                        if (DEBUG)
                            log("loadClass() FOUND parent " + delegate + " " + name + " , " + resolve);
                        if (resolve) resolveClass(clazz);
                        return (clazz);
                    }
                } catch (ClassNotFoundException e) {
                    ;
                }
            }
        }

        if( DEBUGNF ) log("loadClass(): NOTFOUND " + name + " xxx " + getParent() +  " " + repository.getName() );
        throw new ClassNotFoundException(name);
    }


    // ------------------------------------------------------ Lifecycle Methods


    /**
     * Start the class loader.
     *
     * @exception LifecycleException if a lifecycle error occurs
     */
    void start()  {

        started = true;

    }

    /** Support for "disabled" state.
    *
    * @return
    */
    boolean isStarted() {
        return started;
    }


    /**
     * Stop the class loader.
     *
     * @exception LifecycleException if a lifecycle error occurs
     */
    void stop() {

        started = false;

    }


    /**
     * Validate a classname. As per SRV.9.7.2, we must restict loading of 
     * classes from J2SE (java.*) and classes of the servlet API 
     * (javax.servlet.*). That should enhance robustness and prevent a number
     * of user error (where an older version of servlet.jar would be present
     * in /WEB-INF/lib).
     * 
     * @param name class name
     * @return true if the name is valid
     */
    protected boolean validate(String name) {

        if (name == null)
            return false;
        if (name.startsWith("java."))
            return false;

        return true;

    }


    // ------------------ Local methods ------------------------

    private void log(String s ) {
        System.err.println("ModuleClassLoader: " + s);
    }
    private void log(String s, Throwable t ) {
        System.err.println("ModuleClassLoader: " + s);
        t.printStackTrace();
    }
    
    Object debugObj=new Object();

    /**
     * Render a String representation of this object.
     */
    public String toString() {

        StringBuffer sb = new StringBuffer("ModuleCL ");
        sb.append(debugObj).append(" delegate: ");
        sb.append(delegate);
        //sb.append("\r\n");
        sb.append(" cp: ");
        URL cp[]=super.getURLs();
        if (cp != null ) {
            for (int i = 0; i <cp.length; i++) {
                sb.append("  ");
                sb.append(cp[i].getFile());
            }
        }
        if (getParent() != null) {
            sb.append("\r\n----------> Parent: ");
            sb.append(getParent().toString());
            sb.append("\r\n");
        }
        return (sb.toString());
    }
}