/*
 * 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.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;


/**
 * Boostrap loader for Catalina or other java apps. 
 * 
 * This application constructs a class loader
 * for use in loading the Catalina internal classes (by accumulating all of the
 * JAR files found in the "server" directory under "catalina.home"), and
 * starts the regular execution of the container.  The purpose of this
 * roundabout approach is to keep the Catalina internal classes (and any
 * other classes they depend on, such as an XML parser) out of the system
 * class path and therefore not visible to application level classes.
 *
 *
 * Merged with CatalinaProperties:
 * Load a properties file describing the modules and startup sequence.
 * This is responsible for configuration of the loader. 
 * TODO: support jmx-style configuration, including persistence.
 * TODO: better separate legacy config and the new style
 * 
 * The properties file will be named "loader.properties" or 
 * "catalina.properties" ( for backwad compatibility ) and
 * will be searched in:
 *  - TODO 
 * 
 * Properties used:
 *  - TODO
 *
 * loader.* and *.loader properties are used internally by the loader ( 
 *  *.loader is for backward compat with catalina ).
 * All other properties in the config file are set as System properties.
 * 
 * Based on o.a.catalina.bootstrap.CatalinaProperties - utility class to read 
 * the bootstrap Catalina configuration.

 *
 * @author Craig R. McClanahan
 * @author Remy Maucherat
 * @author Costin Manolache
 */ 
public final class Loader  {

    private static final boolean DEBUG=true; //LoaderProperties.getProperty("loader.debug.Loader") != null;
    // If flat, only one loader is created. If false - one loader per jar/dir
    private static final boolean FLAT=false;//LoaderProperties.getProperty("loader.Loader.flat") != null;
    
    // -------------------------------------------------------------- Constants


    private static final String CATALINA_HOME_TOKEN = "${catalina.home}";
    private static final String CATALINA_BASE_TOKEN = "${catalina.base}";


    // ------------------------------------------------------- Static Variables


    /**
     * Daemon object used by main.
     */
    private static Loader daemon = null;

    // one should be enough
    ModuleListener listener;


    // -------------------------------------------------------------- Variables

    protected Repository commonRepository = null;
    protected Repository catalinaRepository = null;
    protected Repository sharedRepository = null;

    protected ClassLoader catalinaLoader = null;
    private String[] args;
    private Hashtable repositories=new Hashtable();
    private ClassLoader parentClassLoader;
    
    private static Properties properties = null;


    private static String propFile;

    // -------------------------------------------------------- Private Methods
    
    /** Set the parent class loader - can be used instead of setParent, 
     * in case this is the top loader and needs to delagate to embedding app.
     * The common loader will delegate to this loader
     * 
     * @param myL
     */
    public void setParentClassLoader(ClassLoader myL) {
        this.parentClassLoader=myL;
    }


    /** Initialize the loader, creating all repositories.
     *  Will create common, server, shared. 
     *  
     *  TODO: create additional repos.
     *
     */
    public void init() {
        try {
            commonRepository = initRepository("common", null, parentClassLoader);
            catalinaRepository = initRepository("server", commonRepository,null);
            catalinaLoader = catalinaRepository.getClassLoader();
            sharedRepository = initRepository("shared", commonRepository,null);
        } catch (Throwable t) {
            log("Class loader creation threw exception", t);
            System.exit(1);
        }
    }

    /** Create a new repository. 
     *  No Module is added ( currently )
     *  TODO: use props to prepopulate, if any is present.
     * 
     * @param name
     * @param parent
     * @return
     */
    public Repository createRepository(String name, Repository parent) {
        Repository lg=new Repository(this);

        lg.setName(name);
       
        lg.setParent( parent );
        
        repositories.put(name, lg);
        
        if( listener != null ) {
            listener.repositoryAdd(lg);
        }
        return lg;
    }

    public Enumeration getRepositoryNames() {
        return repositories.keys();
    }
    
    /** Create a module using the NAME.loader property to construct the 
     *  classpath.
     * 
     * @param name
     * @param parent
     * @return
     * @throws Exception
     */
    private Repository initRepository(String name, Repository parent, ClassLoader pcl)
        throws Exception 
    {
        String value = getProperty(name + ".loader");

        Repository lg=createRepository(name, parent );
        if( pcl != null )
            lg.setParentClassLoader( pcl );
        if( DEBUG ) log( "Creating loading group " + name + " - " + value + " " + pcl);
        
        if ((value == null) || (value.equals("")))
            return lg;

        ArrayList unpackedList = new ArrayList();
        ArrayList packedList = new ArrayList();
        ArrayList urlList = new ArrayList();

        Vector repo=split( value );
        Enumeration elems=repo.elements();
        while (elems.hasMoreElements()) {
            String repository = (String)elems.nextElement();

            // Local repository
            boolean packed = false;
            
            if (repository.startsWith(CATALINA_HOME_TOKEN)) {
                repository = getCatalinaHome()
                    + repository.substring(CATALINA_HOME_TOKEN.length());
            } else if (repository.startsWith(CATALINA_BASE_TOKEN)) {
                repository = getCatalinaBase()
                    + repository.substring(CATALINA_BASE_TOKEN.length());
            }

            // Check for a JAR URL repository
            try {
                urlList.add(new URL(repository));
                continue;
            } catch (MalformedURLException e) {
                // Ignore
            }

            if (repository.endsWith("*.jar")) {
                packed = true;
                repository = repository.substring
                    (0, repository.length() - "*.jar".length());
            }
            if (packed) {
                packedList.add(new File(repository));
            } else {
                unpackedList.add(new File(repository));
            }
        }

        File[] unpacked = (File[]) unpackedList.toArray(new File[0]);
        File[] packed = (File[]) packedList.toArray(new File[0]);
        URL[] urls = (URL[]) urlList.toArray(new URL[0]);

        // previously: ClassLoaderFactory.createClassLoader
        initRepository(lg, unpacked, packed, urls, parent); //new ModuleGroup();
        
        
        // TODO: JMX registration for the group loader 
        /*
        // Register the server classloader
        ObjectName objectName =
            new ObjectName("Catalina:type=ServerClassLoader,name=" + name);
        mBeanServer.registerMBean(classLoader, objectName);
        */
        
        return lg; // classLoader;

    }

    /** Small hack to allow a loader.properties file to be passed in CLI, to
     * allow a more convenient method to start with different params from 
     * explorer/kde/etc.
     * 
     * If the first arg ends with ".loader", it is used as loader.properties
     * file and removed from args[].  
     */
    private void processCLI() {
        if( args!=null && args.length > 0 &&
                (args[0].toLowerCase().endsWith(".tomcat") ||
                        args[0].toLowerCase().endsWith(".loader") ||
                        args[0].toLowerCase().endsWith("loader.properties") )) {
            String props=args[0];
            String args2[]=new String[args.length-1];
            System.arraycopy(args, 1, args2, 0, args2.length);
            args=args2;
            setPropertiesFile(props);
        } else {
            loadProperties();
        }
    }
    
    /**
     * Initialize:
     *  - detect the home/base directories
     *  - init the loaders / modules
     *  - instantiate the "startup" class(es)
     * 
     */
    public void main()
        throws Exception
    {
        processCLI();
        
        // Set Catalina path
        setCatalinaHome();
        setCatalinaBase();

        init();
        
        Thread.currentThread().setContextClassLoader(catalinaLoader);

        securityPreload(catalinaLoader);

        autostart();
    }

    private void autostart() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        // Load our startup classes and call its process() method
        /* Why multiple classes ? 
         * - maybe you want to start more "servers" ( tomcat ,something else )
         * - easy hook for other load on startup modules ( like a jmx hook )
         * - maybe split the loader-specific code from catalina 
         */
        String startupClasses=getProperty("loader.auto-startup",
                "org.apache.catalina.startup.CatalinaModuleListener");
        Vector v=split( startupClasses ); 
        
        for( int i=0; i<v.size(); i++ ) {
            String startupCls=(String)v.elementAt(i);
        
            if (DEBUG)
                log("Loading startup class " + startupCls);
            
            Class startupClass =
                catalinaLoader.loadClass(startupCls);
            
            Object startupInstance = startupClass.newInstance();
            
            if( startupInstance instanceof ModuleListener ) {
                addModuleListener((ModuleListener)startupInstance);

                // it can get args[] and properties from Loader
                listener.setLoader(this);
                
                // all arg processing moved there. Maybe we can make it consistent
                // for all startup schemes
                listener.start();
            } else if ( startupInstance instanceof Runnable ) {
                ((Runnable)startupInstance).run();
            } else {
                Class paramTypes[] = new Class[0];
                Object paramValues[] = new Object[0];
                Method method =
                    startupInstance.getClass().getMethod("execute", paramTypes);
                if( method==null ) 
                    method = startupInstance.getClass().getMethod("start", paramTypes);
                if( method!=null )
                    method.invoke(startupInstance, paramValues);
            }

        }
    }

    /** Returns one of the repositories. 
     * 
     *  Typically at startup we create at least: "common", "shared" and "server", with 
     *  same meaning as in tomcat. 
     * 
     * @param name
     * @return
     */
    public Repository getRepository( String name ) {
        return (Repository)repositories.get(name);
    }
    
    private  static void securityPreload(ClassLoader loader)
        throws Exception {

        if( System.getSecurityManager() == null ){
            return;
        }

        String value=getProperty("security.preload");
        Vector repo=split( value );
        Enumeration elems=repo.elements();
        while (elems.hasMoreElements()) {
            String classN = (String)elems.nextElement();
            try {
                loader.loadClass( classN);
            } catch( Throwable t ) {
                // ignore
            }
        }
    }


    // ----------------------------------------------------------- Main Program

    /** Access to the command line arguments, when Loader is used to launc an app.
     */
    public String[] getArgs() {
        return args;
    }

    /**
     * Main method.
     *
     * @param args Command line arguments to be processed
     */
    public static void main(String args[]) {
        
        try {
            if (daemon == null) {
                daemon = new Loader();
                daemon.args=args;

                try {
                    daemon.main();
                } catch (Throwable t) {
                    t.printStackTrace();
                    return;
                }
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }

    }


    /**
     * Initialize the loader properties explicitely. 
     * 
     * TODO: add setPropertiesRes
     * 
     * @param props
     */
    public void setPropertiesFile(String props) {
        propFile=props;
        loadProperties();
    }

    /**
     * Return specified property value.
     */
    static String getProperty(String name) {
        if( properties==null ) loadProperties();
        return properties.getProperty(name);
    }


    /**
     * Return specified property value.
     */
    static String getProperty(String name, String defaultValue) {
        if( properties==null ) loadProperties();
        return properties.getProperty(name, defaultValue);
    }

    /**
     * Load properties.
     * Will try: 
     * - "catalina.config" system property ( a URL )
     * - "catalina.base", "catalina.home", "user.dir" system properties +
     *    "/conf/" "../conf" "/" +  "loader.properties" or "catalina.properties"
     * - /org/apache/catalina/startup/catalina.properties
     * 
     * Properties will be loaded as system properties. 
     * 
     * loader.properties was added to allow coexistence with bootstrap.jar ( the 
     * current scheme ), since the classpaths are slightly different. 
     */
    static void loadProperties() {
        properties = new Properties();
        
        InputStream is = null;
        Throwable error = null;

        // TODO: paste the code to do ${} substitution 
        // TODO: add the code to detect where tomcat-properties is loaded from
        if( propFile != null ) {
            try {
                File properties = new File(propFile);
                is = new FileInputStream(properties);
                if( is!=null && DEBUG ) {
                    log("Loaded from loader.properties " + properties );
                }
            } catch( Throwable t) {
                System.err.println("Can't find " + propFile);
                return;
            }
        }
        
        if( is == null ) {
            try {
                // "catalina.config" system property
                String configUrl = System.getProperty("catalina.config");
                if (configUrl != null) {
                    is = (new URL(configUrl)).openStream();
                    if( is!=null && DEBUG ) {
                        log("Loaded from catalina.config " + configUrl );
                    }
                }
            } catch (Throwable t) {
                // Ignore
            }
        }

        if( is == null ) {
            try {
                // "loader.config" system property
                String configUrl = System.getProperty("loader.config");
                if (configUrl != null) {
                    is = (new URL(configUrl)).openStream();
                    if( is!=null && DEBUG ) {
                        log("Loaded from catalina.config " + configUrl );
                    }
                }
            } catch (Throwable t) {
                // Ignore
            }
        }

        if (is == null) {
            try {
                setCatalinaBase(); // use system properties, then user.dir
                File home = new File(getCatalinaBase());
                File conf = new File(home, "conf");
                
                // use conf if exists, or the base directory otherwise
                if( ! conf.exists() ) conf = new File(home, "../conf");
                if( ! conf.exists() ) conf = home;
                File propertiesF=null;
                if(  conf.exists() )  
                     propertiesF= new File(conf, "loader.properties");
                if( ! propertiesF.exists() ) {
                    propertiesF= new File( home, "loader.properties");
                }
                if( propertiesF.exists() )
                    is = new FileInputStream(propertiesF);
                if( is!=null && DEBUG ) {
                    log("Loaded from loader.properties " + properties );
                }
            } catch (Throwable t) {
                // Ignore
            }
        }

        if (is == null) {
            try {
                File home = new File(getCatalinaBase());
                File conf = new File(home, "conf");
                File properties = new File(conf, "catalina.properties");
                is = new FileInputStream(properties);
                if( is!=null && DEBUG ) {
                    log("Loaded from catalina.properties " + properties );
                }
            } catch (Throwable t) {
                // Ignore
            }
        }

        if (is == null) {
            try {
                is = Loader.class.getResourceAsStream
                    ("/org/apache/catalina/startup/catalina.properties");
                if( is!=null && DEBUG ) {
                    log("Loaded from o/a/c/startup/catalina.properties " );
                }

            } catch (Throwable t) {
                // Ignore
            }
        }

        if (is == null) {
            try {
                is = Loader.class.getResourceAsStream
                    ("loader.properties");
                if( is!=null && DEBUG ) {
                    log("Loaded from res loader.properties " );
                }
            } catch (Throwable t) {
                // Ignore
            }
        }
        
        if (is != null) {
            try {
                properties.load(is);
                is.close();
            } catch (Throwable t) {
                error = t;
            }
        }

//        if ((is == null) || (error != null)) {
//            // Do something
//            log("Error: no properties found !!!");
//        }

        // Register the _unused_ properties as system properties
        if( properties != null ) {
            Enumeration enumeration = properties.propertyNames();
            while (enumeration.hasMoreElements()) {
                String name = (String) enumeration.nextElement();
                String value = properties.getProperty(name);
                if( "security.preload".equals( name )) continue;
                if( "package.access".equals( name )) continue;
                if( "package.definition".equals( name )) continue;
                if( name.endsWith(".loader")) continue;
                if( name.startsWith("loader.")) continue;
                if (value != null) {
                    System.setProperty(name, value);
                }
            }
        }

    }

    static void setCatalinaHome(String s) {
        System.setProperty( "catalina.home", s );
    }

    static void setCatalinaBase(String s) {
        System.setProperty( "catalina.base", s );
    }


    /**
     * Get the value of the catalina.home environment variable.
     * 
     * @deprecated
     */
    static String getCatalinaHome() {
        if( properties==null ) loadProperties();
        return System.getProperty("catalina.home",
                                  System.getProperty("user.dir"));
    }
    
    
    /**
     * Get the value of the catalina.base environment variable.
     * 
     * @deprecated
     */
    static String getCatalinaBase() {
        if( properties==null ) loadProperties();
        return System.getProperty("catalina.base", getCatalinaHome());
    }

    
    /**
     * Set the <code>catalina.base</code> System property to the current
     * working directory if it has not been set.
     */
    static void setCatalinaBase() {
        if( properties==null ) loadProperties();

        if (System.getProperty("catalina.base") != null)
            return;
        if (System.getProperty("catalina.home") != null)
            System.setProperty("catalina.base",
                               System.getProperty("catalina.home"));
        else
            System.setProperty("catalina.base",
                               System.getProperty("user.dir"));

    }


    /**
     * Set the <code>catalina.home</code> System property to the current
     * working directory if it has not been set.
     */
    static void setCatalinaHome() {

        if (System.getProperty("catalina.home") != null)
            return;
        File bootstrapJar = 
            new File(System.getProperty("user.dir"), "bootstrap.jar");
        File tloaderJar = 
            new File(System.getProperty("user.dir"), "tomcat-loader.jar");
        if (bootstrapJar.exists() || tloaderJar.exists()) {
            try {
                System.setProperty
                    ("catalina.home", 
                     (new File(System.getProperty("user.dir"), ".."))
                     .getCanonicalPath());
            } catch (Exception e) {
                // Ignore
                System.setProperty("catalina.home",
                                   System.getProperty("user.dir"));
            }
        } else {
            System.setProperty("catalina.home",
                               System.getProperty("user.dir"));
        }

    }


    /**
     * Get the module from the classloader. Works only for classloaders created by
     * this package - or extending ModuleClassLoader.
     * 
     * This shold be the only public method that allows this - Loader acts as a 
     * guard, only if you have the loader instance you can access the internals.
     * 
     * 
     * @param cl
     * @return
     */
    public Module getModule(ClassLoader cl ) {
        if( cl instanceof ModuleClassLoader ) {
            return ((ModuleClassLoader)cl).getModule();
        }
        return null;
    }
    
    /**
     * Create and return a new class loader, based on the configuration
     * defaults and the specified directory paths:
     *
     * @param unpacked Array of pathnames to unpacked directories that should
     *  be added to the repositories of the class loader, or <code>null</code> 
     * for no unpacked directories to be considered
     * @param packed Array of pathnames to directories containing JAR files
     *  that should be added to the repositories of the class loader, 
     * or <code>null</code> for no directories of JAR files to be considered
     * @param urls Array of URLs to remote repositories, designing either JAR 
     *  resources or uncompressed directories that should be added to 
     *  the repositories of the class loader, or <code>null</code> for no 
     *  directories of JAR files to be considered
     * @param parent Parent class loader for the new class loader, or
     *  <code>null</code> for the system class loader.
     *
     * @exception Exception if an error occurs constructing the class loader
     */
    private void initRepository(Repository lg, File unpacked[],
            File packed[],  URL urls[],  Repository parent)
        throws Exception 
    {
        StringBuffer sb=new StringBuffer();

        // Construct the "class path" for this class loader
        ArrayList list = new ArrayList();
        
        // Add unpacked directories
        if (unpacked != null) {
            for (int i = 0; i < unpacked.length; i++)  {
                File file = unpacked[i];
                if (!file.exists() || !file.canRead()) {
                    if (DEBUG)
                        log("  Not found:  "+ file.getAbsolutePath());
                    continue;
                }
//                String cPath=file.getCanonicalPath();
//                URL url=null;
//                
//                if( cPath.toLowerCase().endsWith(".jar") ||
//                        cPath.toLowerCase().endsWith(".zip") ) {
//                    url = new URL("file", null, cPath);
//                } else {
//                    url = new URL("file", null, cPath + File.separator);
//                }
                URL url=file.toURL();
                if (DEBUG)
                    sb.append(" : "+ url);
                if( ! FLAT ) {
                    addLoader(lg, parent, new URL[] { url });
                } else {
                    list.add(url);
                }
            }
        }
        
        // Add packed directory JAR files
        if (packed != null) {
            for (int i = 0; i < packed.length; i++) {
                File directory = packed[i];
                if (!directory.isDirectory() || !directory.exists() ||
                        !directory.canRead()) {
                    if (DEBUG)
                        log("  Not found:  "+ directory.getAbsolutePath());
                    continue;
                }
                String filenames[] = directory.list();
                for (int j = 0; j < filenames.length; j++) {
                    String filename = filenames[j].toLowerCase();
                    if (!filename.endsWith(".jar"))
                        continue;
                    File file = new File(directory, filenames[j]);
//                    if (DEBUG)
//                        sb.append(" [pak]="+ file.getCanonicalPath());
//                    URL url = new URL("file", null,
//                            file.getCanonicalPath());
                    URL url=file.toURL();
                    if (DEBUG)
                        sb.append(" pk="+ url);

                    if( ! FLAT ) {
                        addLoader(lg, parent, new URL[] { url });
                    } else {
                        list.add(url);
                    }
                }
            }
        }
        
        // Add URLs
        if (urls != null) {
            for (int i = 0; i < urls.length; i++) {
                if( ! FLAT ) {
                    addLoader(lg, parent, new URL[] { urls[i] });
                } else {
                    list.add(urls[i]);
                }
                if (DEBUG)
                    sb.append(" "+ urls[i]);
            }
        }
        
        // Construct the class loader itself
        
        // TODO: experiment with loading each jar in a separate loader.
        if (DEBUG)
            log("Creating new class loader " + lg.getName() + " " + sb.toString());
        
        
        URL[] array = (URL[]) list.toArray(new URL[list.size()]);
        if( array.length > 0 ) {
            addLoader(lg, parent, array);
        }
    }
    
    /**
     * @param lg
     * @param parent
     * @param list
     */
    private void addLoader(Repository lg, Repository parent, URL array[]) 
        throws Exception
    {
        Module module=new Module();
        
        module.setParent( parent );
        module.setClasspath( array );
        
        lg.addModule(module);
        
    }

    private static Vector split( String value ) {
        Vector result=new Vector();
        StringTokenizer tokenizer = new StringTokenizer(value, ",");
        while (tokenizer.hasMoreElements()) {
            String repository = tokenizer.nextToken();
            repository.trim();
            if( ! "".equals(repository) )
                result.addElement(repository);
        }
        return result;
    }

    void notifyModuleStart(Module module) {
        if(listener!=null) listener.moduleStart(module);
    }

    void notifyModuleStop(Module module) {
        if( listener!=null ) listener.moduleStop(module);
    }
    
    /** Add a module listener. 
     * 
     * To keep the dependencies minimal, the loader package only implements the
     * basic class loading mechanism - but any advanced feature ( management, 
     * policy, etc ) should be implemented by a module.
     * 
     * @param listener
     */
    public void addModuleListener(ModuleListener listener) {
        this.listener=listener;
    }

    private static void log(String s) {
        System.err.println("Main: " + s);
    }
    
    private static void log( String msg, Throwable t ) {
        System.err.println("Main: " + msg);
        t.printStackTrace();
    }

}