/*
 * Copyright (c) 2008-2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2016-04-21 05:45:00 +0000 (Thu, 21 Apr 2016) $' 
 * '$Revision: 34479 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */

package org.kepler;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ResourceBundle;
import java.util.StringTokenizer;

import javax.swing.UIManager;

import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tools.ant.Project;
import org.kepler.build.MakeKars;
import org.kepler.build.modules.Module;
import org.kepler.build.modules.ModuleTree;
import org.kepler.build.project.ProjectLocator;
import org.kepler.build.project.RepositoryLocations;
import org.kepler.configuration.ConfigurationManager;
import org.kepler.configuration.ConfigurationProperty;
import org.kepler.gui.SplashWindow;
import org.kepler.loader.PermissionManager;
import org.kepler.loader.SystemPropertyLoader;
import org.kepler.loader.util.Screenshot;
import org.kepler.module.ModuleHSQLManager;
import org.kepler.module.ModuleInitializer;
import org.kepler.modulemanager.gui.patch.PatchChecker;
import org.kepler.moml.NamedObjId;
import org.kepler.sms.util.OntologyConfiguration;
import org.kepler.util.DotKeplerManager;
import org.kepler.util.FileUtil;
import org.kepler.util.RunnableExecutionQueue;
import org.kepler.util.ShutdownListener;
import org.kepler.util.ShutdownNotifier;
import org.kepler.util.StatusListener;
import org.kepler.util.StatusNotifier;

import ptolemy.actor.injection.ActorModuleInitializer.Initializer;
import ptolemy.actor.injection.PtolemyInjector;
import ptolemy.actor.injection.PtolemyModule;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.moml.filter.BackwardCompatibility;
import ptolemy.util.FileUtilities;
import ptolemy.vergil.VergilApplication;

/**
 * A class to initialize the build system, then start the Kepler GUI or execute
 * workflows from the command line. In the latter case, command line arguments
 * specify different run time configurations.
 * 
 * @author Chad Berkely, Daniel Crawl, David Welker
 * @version $Id: Kepler.java 34479 2016-04-21 05:45:00Z crawl $
 */

public class Kepler {

        public static void restart() {
                main(_args);
        }
        
        public static void main(String[] args) {
            
                // print status updates to stdout
                StatusNotifier.addStatusListener(new StatusListener() {
                        @Override
                        public void log(String message) {
                                System.out.println(message);
                        }
                });
                
            //System.out.println("java.library.path = " + System.getProperty("java.library.path"));

        // log4j uses the first log4j.properties file found on the classpath. 
        // since kepler's classpath is complicated, it is not always obvious
        // which log4j.properties is used; it may be hidden in a jar file.
        // this prints the log4j.properties file found on the classpath.
        File log4jFile = FileUtilities.nameToFile("$CLASSPATH/log4j.properties", null);
        if(log4jFile == null) {
            System.out.println("log4j.properties not found in CLASSPATH.");
        } else {
            System.out.println("log4j.properties found in CLASSPATH: " + log4jFile);
        }

            
        // run command line arguments module initializers to set command
        // line arguments specific to modules.
        try {
            _initializeCommandLineArguments();
        } catch (Exception e) {
            System.out.println("Error initializing module command line arguments: " + e.getMessage());
            return;
        }

                // Save the args in case they are needed later.
                // long startTime = System.currentTimeMillis();
                _args = args;
                CommandLineArgs.store(args);
                List<String> argList = Arrays.asList(args);
                
                // parse the command line arguments
                if(!parseArgs(args)) {
                    // an error occurred, so exit.
                    return;
                }

                // set the repository location from the module manager configuration file.
                RepositoryLocations
                                .setReleaseLocation(org.kepler.modulemanager.RepositoryLocations
                                                .getReleaseLocation());
                        
                ModuleTree.init();
                
                // use headless mode if kepler is running without a gui.
                // this is necessary since the DISPLAY environment variable
                // may be set to an incorrect value, and by default java does
                // not use headless mode if DISPLAY is set.
                if(!_runWithGui) {
                    System.setProperty("java.awt.headless", "true");
                } else if(UIManager.getLookAndFeel().getName().startsWith("Mac OS")) {
                    System.setProperty("apple.laf.useScreenMenuBar", "true");
                    System.setProperty("com.apple.mrj.application.apple.menu.about.name", "Kepler");
                }


                /* Do not check for patches if running workflows from the command
                 * line since this can occur many times and checking slows down
                 * startup time. 
        
                // if we are executing a workflow from the command line, check now for
                // patches.
                if(_action == Action.RunKAR || _action == Action.RunWf) {
                    // if we are running headless, do not display a dialog if patches
                    // are available
                    if (!_runWithGui || _displayRedirectOutputPath != null) {
                        PatchChecker.check(true);
                    } else {
                        PatchChecker.check(false);
                    }
                // show the splash if the Kepler UI is starting
                } else*/
                if(_action == Action.Kepler && _showSplash) {
                    _showSplash();
                }
                
                ShutdownNotifier.addShutdownListener(new Shutdown());
                try {

                    setJavaPropertiesAndCopyModuleDirectories();
                    
                        // System.out.println("os: " + System.getProperty("os.name"));
                        String OSName = System.getProperty("os.name");

                        // Hashtable properties = getProject().getProperties();
                        ModuleTree moduleTree = ModuleTree.instance();
                        
                        String classpath = System.getProperty("java.class.path");
                        String[] classpathItems = classpath.split(File.pathSeparator);
                        
                        for (Module module : moduleTree) {
                                
                                // XXX since Module dir variables can be wrong, utilizing classpath
                                // to determine module location on disk. Use below line instead when 
                                // that's fixed.
                                //File osextension = new File(module.getModuleInfoDir() + File.separator + "osextension.txt");
                                File osextension = null;
                                String sought = File.separator + module.getName() + File.separator;                             
                                for (String path: classpathItems){
                                        // must check each match since parent path could possibly have a module name
                                        // in it (don't break on first):
                                        if (path.contains(sought)){
                                                int lastIndex = path.lastIndexOf(sought);
                                                String p = path.substring(0, lastIndex);
                                                p = p.concat(sought + "module-info" + 
                                                        File.separator + "osextension.txt");
                                                osextension = new File(p);
                                                if (osextension.exists()){
                                                        break;
                                                }
                                        }
                                }
                                if (osextension == null || !osextension.exists()){
                                        continue;
                                }
                                
                                if(_isDebugging) {
                                    log.debug("Found OS Extension file: "
                                                + osextension.getAbsolutePath());
                                }
                                Hashtable<String, String> properties = readOSExtensionFile(osextension);
                                Enumeration<String> keys = properties.keys();
                                while (keys.hasMoreElements()) {
                                        String extClass = keys.nextElement();
                                        String os = properties.get(extClass);
                                        if (OSName.trim().equals(os.trim())) {
                                                // if we're in an OS that an extension
                                                // needs to be loaded for attempt to load
                                                // the OSExtension via reflection
                                                // and run the addOSExtension method

                                                Class<?> c = Class.forName(extClass);
                                                try {
                                                        OSExtension extension = (OSExtension) c
                                                                        .newInstance();
                                                        extension.addOSExtensions();
                                             if(_isDebugging) {
                                                 log.debug("loading OS extensions for OS "
                                                                        + os + " with class " + extClass);
                                             }
                                                } catch (ClassCastException cce) {
                                                        // System.out.println(extClass +
                                                        // " is not an instance of OSExtension");
                                                }
                                        }
                                }
                        }
                                                
                        Project project = new Project();
                        File projDir = ProjectLocator.getProjectDir();
                        project.setBaseDir(projDir);

                        // set the ProjectLocator ant project if it's not already set.
                        // this prevents ProjectLocator.getAntProject() from returning null
                        if(ProjectLocator.getAntProject() == null) {
                            ProjectLocator.setAntProject(project);
                        }
                                                
                        //_setOntologyIndexFile();
                
                        
                        if (!argList.contains("-runwf")) {
                                // Allow developers to turn off MakeKars by creating
                                // a file called "skipMakeKars" in the project root
                                File skipMakeKars = new File(projDir, "skipMakeKars");
                                if (!skipMakeKars.exists()) {
                                        MakeKars kar = new MakeKars();
                                        kar.setProject(project);
                                        kar.init();
                                        kar.run();
                                }
                        }

                        PermissionManager.makeNativeLibsExecutable();
                        // CreateIntroFileTask createIntroFileTask = new
                        // CreateIntroFileTask();
                        // createIntroFileTask.execute();

                } catch (URISyntaxException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                } catch (Exception e) {
                        e.printStackTrace();
                }

                int rc = runApplication();
                
                if(rc != 0) {
                    System.exit(rc);
                }
                
                // System.exit(0);

                // long endTime = System.currentTimeMillis();
                // System.out.println( (endTime-startTime)/1000.0 );
                
                        
        RunnableExecutionQueue.execute();
        
        }

        public static void setOntologyIndexFile() {
                OntologyConfiguration oc = OntologyConfiguration.instance();
                File f = FileUtil
                                .getHighestRankedFile("configs/ptolemy/configs/kepler/ontologies/ontology_catalog.xml");
                oc.setIndexFile(f);
                oc.initialize();
        }
    
        /**
         * Parse the command line arguments and run the appropriate application.
         * @return If true, no error occurred parsing the arguments.
         */
        public static boolean parseArgs(String[] args) {

                try {
                        // parse the switches and remaining arguments
                        for (int i = 0; i < args.length; i++) {
                                if (args[i].equals("-runwf")) {
                                        _action = Action.RunWf;
                                } else if (args[i].equals("-runkar")) {
                                        _action = Action.RunKAR;
                                } else if (args[i].equals("-nogui")) {
                                        _assertRunWF(args[i]);
                                        _runWithGui = false;
                                } else if (args[i].equals("-nocache")) {
                                        _assertRunWF(args[i]);
                                        _runWithCache = false;
                                } else if (args[i].equals("-nosplash")) {
                                        _showSplash = false;
                                } else if (args[i].equals("-noexit")) {
                                    _runThenExitNoGui = false;
                                } else if (args[i].equals("-gui")) {
                                        _assertRunWF(args[i]);
                                        _runWithGui = true;
                                } else if (args[i].equals("-cache")) {
                                        _assertRunWF(args[i]);
                                        _runWithCache = true;
                                } else if (args[i].equals("-vergil")) {
                                        _action = Action.Vergil;
                } else if (args[i].equals("-createActorXML")) {
                    _action = Action.CreateActorXML;
                    _runWithGui = false;
                                } else if (args[i].equals("-hsql")) {
                                    if(_action != Action.Kepler) {
                                        throw new IllegalArgumentException("ERROR: -hsql may not be used with " +
                                            _action.getArg());
                                    }
                                    
                                    i++;
                                    if(i == args.length) {
                        throw new IllegalArgumentException("ERROR: must specify -hsql start or -hsql stop.");                                   
                                    }
                                    
                                    if(args[i].equals("start")) {
                            _action = Action.HSQLStart;                                 
                                    } else if(args[i].equals("stop")) {
                            _action = Action.HSQLStop;
                                    } else {
                                        throw new IllegalArgumentException("ERROR: must specify -hsql start or -hsql stop.");
                                    }
                                } else if (args[i].equals("-force")) {
                                        _forceOpen = true;
                } else if (args[i].equals("-noilwc")) {
                    NamedObjId.incrementLSIDOnWorkflowChange(false);
                } else if (args[i].equals("-updateActorDocs")) {
                        _action = Action.UpdateActorDocs;
                    _runWithGui = false;
                } else if (args[i].equals("-h") || args[i].equals("-help")) {
                                        _showHelp();
                                        return false;
                                }
                // NOTE: -redirectdisplay is kept for backwards-compatibility 
                else if(args[i].equals("-redirectgui") || args[i].equals("-redirectdisplay")){
                                        _assertRunWF(args[i]);
                        _runWithGui = false;
                        if (i >= args.length) {
                                throw new IllegalArgumentException("ERROR: cannot set "
                                        + "redirectgui argument because no redirect dir for display actors is "
                                + "given.");
                        }
                        _displayRedirectOutputPath = new String(args[++i]);
                        if (!(new File(_displayRedirectOutputPath)).isDirectory()){
                                throw new IllegalArgumentException("ERROR: cannot set "
                                        + "redirectdisplay argument because the argument after '-redirectdisplay' is not a directory.");
                        }
                } else if(args[i].equals("-screenshot")) {
                    _action = Action.MakeScreenShot;
                    i++;
                    _parseScreenShotArgs(args, i);
                } else {
                    
                    boolean foundParser = false;
                    for(CommandLineArgument arg: CommandLineArgument.getAll()) {
                        // see if we've already parsed it.
                        if(!arg.wasParsed()) {
                                int next = arg.parseRemainingArgs(args, i);
                                if(next >= 0) {
                                    foundParser = true;
                                    if(arg.isAction()) {
                                        _action = Action.RunCustomAction;
                                        _customActionClass = arg.getActionClass();
                                    _customActionMethod = arg.getActionMethod();
                                    }
                                    // i is next - 1 since the for loop increments i.
                                    i = next - 1;
                                    // see if there are any more arguments left.
                                    if(i >= args.length) {
                                        break;
                                    }
                                }
                        }
                    }
                    
                    if(!foundParser) {
                        _applicationArgsList.add(args[i]);
                    }
                                }
                        }
                } catch (IllegalArgumentException e) {
                        System.out.print(e.getMessage());
                        return false;
                }
                
                return true;
                
        }
        
        /** Parse the command-line arguments for creating screenshots of workflows.
         *  @param args an array of command-line arguments
         *  @param i the index into command-line arguments array that points to the
         *  argument after "-screenshot"
         */
        private static void _parseScreenShotArgs(String[] args, int i) {    
            
            // command-line usage for screenshots is:
            //
        // kepler -screenshot [-type png | jpg | gif] [-force]
            //        [-o output [output2 ...] | -odir directory]
            //        workflow.xml [workflow2.xml ...]");


        while(i < args.length) {

            if(args[i].equals("-type")) {
                i++;
                if(i == args.length) {
                    throw new IllegalArgumentException("ERROR: must specify screen shot image type with -type argument.");
                }
                _screenShotType = args[i];
            } else if(args[i].equals("-force")) {
                _screenShotForce = true;
            } else if(args[i].equals("-odir")) {
                if(_screenShotOutputs != null) {
                    throw new IllegalArgumentException("ERROR: cannot specify both -dir and -o with -screenshot.");
                }
                
                i++;
                if(i == args.length) {
                    throw new IllegalArgumentException("ERROR: must specify output directory with -dir.");
                }
                
                _screenShotOutputDir = args[i];
                
            } else if(args[i].equals("-o")) {
                if(_screenShotOutputDir != null) {
                    throw new IllegalArgumentException("ERROR: cannot specify both -dir and -o with -screenshot.");
                }
                
                i++;
                if(i == args.length) {
                    throw new IllegalArgumentException("ERROR: must specify at least one output name with -o.");
                }
                
                _screenShotOutputs = new LinkedList<String>();
                while(i < args.length && !args[i].startsWith("-") &&
                        // make sure it is not a workflow
                        !args[i].toLowerCase().endsWith(".xml") &&
                        !args[i].toLowerCase().endsWith(".kar")) {
                    _screenShotOutputs.add(args[i]);
                    i++;
                }
                // decrement i since it will be incremented again before
                // the loop restarts.
                i--;
                
            } else {
                String name = args[i];
                File file = new File(name);
                if(!file.exists()) {
                    throw new IllegalArgumentException("ERROR: workflow " + name + " does not exist.");
                }
                _screenShotWorkflows.add(name);
            }
            
            i++;
        }
        
        if(_screenShotWorkflows.isEmpty()) {
            throw new IllegalArgumentException("ERROR: must specify at least one workflow with -screenshot.");
        }
        }
        
        /** Run the appropriate application based on command line arguments.
         *  @return Returns 0 if success, 1 if there was an error. 
         */
        public static int runApplication() {
            
                try {
                    
                    if(_runWithCache) {
                        setOntologyIndexFile();
                    }
                    
                        // see if we're running the gui editor
                        if (_action == Action.Kepler) {
                                addActorModule("org/kepler/ActorModuleDefault");
                                initialize();
                                _applicationArgsList.addFirst("-kepler");
                                String[] loadArgs = _applicationArgsList.toArray(new String[0]);
                                if(_showSplash) {
                                        VergilApplication.main(loadArgs);
                                SplashWindow.disposeSplash();
                                StatusNotifier.clearStatusListeners();
                                } else {
                                        VergilApplication.main(loadArgs);
                                }
                                                                                
                                // check for patches now that the UI has started.
                                PatchChecker.check(false);
                                
                        } else if (_action == Action.Vergil) {
                                addActorModule("org/kepler/ActorModuleDefault");
                                String[] loadArgs = _applicationArgsList.toArray(new String[0]);
                                VergilApplication.main(loadArgs);
                        } else if (_action == Action.RunWf || _action == Action.RunKAR) {
                                final String className = "org.kepler.KeplerConfigurationApplication";                           

                                // if we are running a workflow from the cmd line and have
                                // the gui enabled, the program does not quit until the user
                                // enters control-c.
                                if(_runWithGui) {
                                        _mustManuallyQuit = true;
                                }
                                addActorModule("org/kepler/ActorModuleDefault");
                                if (_runWithGui && _runWithCache) {
                                                _applicationArgsList.addFirst("-run");
                                                _applicationArgsList.addFirst("ptolemy/configs/kepler/ConfigGUIAndCache.xml");
                                } else if (_runWithGui && !_runWithCache) {
                    _applicationArgsList.addFirst("-run");
                                        _applicationArgsList.addFirst("ptolemy/configs/kepler/ConfigGUINoCache.xml");
                                } else if (!_runWithGui && _runWithCache) {
                                        String spec;
                                        if (_displayRedirectOutputPath != null){
                                                //add display redirection filter
                                                BackwardCompatibility.addFilter(new au.edu.jcu.kepler.hydrant.DisplayRedirectFilter(_displayRedirectOutputPath));
                                                addActorModule("org/kepler/ActorModuleBatch");
                                                spec = "ptolemy/configs/kepler/ConfigRedirectGUIWithCache.xml";
                                        } else {
                                                spec = "ptolemy/configs/kepler/ConfigNoGUIWithCache.xml";
                                        }
                                        if(_runThenExitNoGui) {
                                            _applicationArgsList.addFirst("-runThenExit");
                                        }
                                        _applicationArgsList.addFirst(spec);
                                        // ConfigurationApplication.readConfiguration(ConfigurationApplication.specToURL(spec));
                                } else { // if(!gui && !cache)
                                        String spec;
                                if (_displayRedirectOutputPath != null)                                 
                                //enter into display redirection mode
                                {
                                        BackwardCompatibility.addFilter(
                                                new au.edu.jcu.kepler.hydrant.DisplayRedirectFilter(_displayRedirectOutputPath));
                                        addActorModule("org/kepler/ActorModuleBatch");
//                                      DisplayRediectClassChanges.classChanges();
//                                      BackwardCompatibility.addFilter(new DisplayRedirectFilter(outputPath));                                         
                                                spec = "ptolemy/configs/kepler/ConfigRedirectGUINoCache.xml";

                                } else {
                                        spec = "ptolemy/configs/kepler/ConfigNoGUINoCache.xml";
                                }
                                    if(_runThenExitNoGui) {
                                        _applicationArgsList.addFirst("-runThenExit");
                                    }
                                        _applicationArgsList.addFirst(spec);
//                                              else{
//                                                      className = "ptolemy.moml.MoMLCommandLineApplication";
//                                              }
                                }

                                if (className != null) {
                                        // initialize and run the class.
                                        String[] loadArgs = _applicationArgsList.toArray(new String[0]);
                                        load(className, loadArgs);
                                }
            } else if (_action == Action.CreateActorXML) {
                String[] loadArgs = _applicationArgsList.toArray(new String[0]);
                load("org.kepler.loader.util.UpdateActorTreeFiles", "buildXMLs", loadArgs);
            } else if (_action == Action.UpdateActorDocs) {
                String[] loadArgs = _applicationArgsList.toArray(new String[0]);
                load("org.kepler.loader.util.UpdateActorTreeFiles", "updateKarXMLDocsForFile", loadArgs);
                        } else if (_action == Action.HSQLStart) {
                            System.out.println("going to start hsql servers.");
                _runHSQLServers(true);
                        } else if (_action == Action.HSQLStop) {
                System.out.println("going to stop hsql servers.");              
                _runHSQLServers(false);
                        } else if (_action == Action.MakeScreenShot) {
                            initialize();
                        Screenshot.makeScreenshot(_screenShotWorkflows, _screenShotType, _screenShotOutputs,
                                _screenShotOutputDir, _screenShotForce);
                        shutdown();
                        // TODO: why is System.exit() necessary?
                        System.exit(0);
                        } else if(_action == Action.RunCustomAction) {
                            load(_customActionClass, _customActionMethod, null);
                        } else {
                            System.err.println("Unknown execution action: " + _action);
                        }
                } catch (IllegalArgumentException e) {
                        System.out.print(e.getMessage());
                        return 1;
                } catch (Exception e) {
                        System.out.println(e.getClass() + ": " + e.getMessage());
                        e.printStackTrace();
                        return 1;
                }
                
                if(!_runWithGui && !_runThenExitNoGui) {
                    System.out.println("Ctrl-c to exit.");
                }

                return 0;
        }

        /** Show the splash screen and start the kepler GUI. */
        private static void _showSplash() {
                try {

                        ConfigurationProperty commonProperty = ConfigurationManager
                                        .getInstance().getProperty(
                                                        ConfigurationManager.getModule("common"));
                        ConfigurationProperty splashscreenProp = commonProperty
                                        .getProperty("splash.image");
                        String splashname = splashscreenProp.getValue();

                        final URL splashURL = ClassLoader.getSystemClassLoader()
                                        .getResource(splashname);

                        SplashWindow.splash(splashURL);
                        
                } catch (Exception ex) {
                        System.err.println("Failed to find splash screen image."
                                        + "Ignoring, use the Java coffee cup");
                        ex.printStackTrace();
                }
        }

        /**
         * This method provides a generic loader. It first updates the classpath
         * with all the jars in $KEPLER/lib/jar, and then uses reflection to invoke
         * the method. NOTE: the method must be static.
         */
        public static void load(String className, String methodName, String[] args)
                        throws IllegalActionException {
                // sanity checks
                if (className == null || className.equals("")) {
                        throw new IllegalActionException("Must supply class to load.");
                } else if (methodName == null || methodName.equals("")) {
                        throw new IllegalActionException("Must supply method to invoke.");
                }

                try {
                    initialize();
                    
                        if (className.equals("ptolemy.actor.gui.PtExecuteApplication")) {
                                ptolemy.actor.gui.PtExecuteApplication application = new ptolemy.actor.gui.PtExecuteApplication(
                                                args);
                                application.runModels();
                                application.waitForFinish();
                        } else if(className.equals("org.kepler.KeplerConfigurationApplication")) {
                                KeplerConfigurationApplication application = new KeplerConfigurationApplication(args);
                                application.waitForFinish();
                        } else {
                                System.out.print("loading: " + className);
                                if(args != null) {
                                    System.out.println(" args: ");
                                for (String arg : args) {
                                        System.out.print(arg + " ");
                                }
                                }
                                System.out.println();

                                // invoke the class's method
                                Class<?> cl = Class.forName(className);
                                Method mthd = cl.getMethod(methodName, String[].class);
                                System.out.println("invoking: " + className + "." + methodName);
                                mthd.invoke(null, new Object[] { args });
                        }
                                                
                        if (_mustManuallyQuit) {
                                System.out.println("Done.");
                                System.out.println("Ctrl-c to exit.");
                        }
                        
                        // clean up modules unless we ran KeplerConfigurationApplication
                        // since that class calls shutdown() after the models have been
                        // executed.
                        if(!className.equals("org.kepler.KeplerConfigurationApplication")) {
                            _initializeModules(false);
                        }

                } catch (ClassNotFoundException e) {
                        throw new IllegalActionException("ERROR: could not find start-up class: "
                                        + className);
                } catch (NoSuchMethodException e) {
                    throw new IllegalActionException("ERROR: class " + className
                                        + " does not have a method called " + methodName);
                } catch (Throwable throwable) {
                    throw new IllegalActionException("Unable to start application: " +
                            ExceptionUtils.getStackTrace(throwable));
                }
        }

        /** Load classes and invoke "main" method. */
        public static void load(String className, String[] args)
                        throws IllegalActionException {
                load(className, "main", args);
        }

        /** Perform initialization. */
        public static void initialize() throws Exception {
        _initializeCommandLineArguments();
                if (!_haveInitialized) {
                        _initializeModules(true);
                }
        }
        
        /** Perform module cleanup. */
        public static void shutdown() {
            _initializeModules(false);
        }

        /** Returns true if -force was specified on the command line. */
        public static boolean getForceOpen() {
                return _forceOpen;
        }

        /** Returns true if -nogui was specified on the command line. */
        public static boolean getRunWithGUI() {
                return _runWithGui;
        }

        /** Set Kepler java properties and copy the module directories into KeplerData/. */
        public static void setJavaPropertiesAndCopyModuleDirectories() throws URISyntaxException, IOException {
        
                StatusNotifier.log("Setting Java Properties.");
                
            SystemPropertyLoader.load();
        System.setProperty("KEPLER", ProjectLocator.getProjectDir()
                .getAbsolutePath());
        String persistentDir = DotKeplerManager.getInstance()
                .getPersistentDirString();
        System.setProperty("KEPLERDATA", persistentDir);

        String dotKepler = DotKeplerManager.getDotKeplerPath();
        System.setProperty(".kepler", dotKepler);

        String keplerUserData = DotKeplerManager.getInstance()
                .getPersistentUserDataDirString();
        System.setProperty("KEPLERUSERDATA", keplerUserData);

        String personalModuleWorkflowDirStr = DotKeplerManager
                .getInstance().getPersistentModuleWorkflowsDirString();
        String docDirStr = DotKeplerManager.getInstance()
                .getPersistentDocumentationDirString();

        StatusNotifier.log("Copying Module Files.");

        List<Module> modules = ModuleTree.instance().getModuleList();
        Iterator<Module> moduleItr = modules.iterator();
        while (moduleItr.hasNext()) {
            Module m = moduleItr.next();
            File applicationModuleWorkflowsDir = m.getWorkflowsDir();
            File applicationModuleDocDir = m.getDocumentationDir();
            // we want the full name, use getName not getStemName:
            File moduleWorkflowDir = new File(personalModuleWorkflowDirStr
                    + File.separator + m.getName());
            File personalModuleDocDir = new File(docDirStr + File.separator
                    + m.getName());

            System.setProperty(m.getStemName() + ".workflowdir",
                    moduleWorkflowDir.toString() + File.separator);

            if (applicationModuleWorkflowsDir.exists()) {
                FileUtil.copyDirectory(applicationModuleWorkflowsDir,
                        moduleWorkflowDir, false);
            } else {
                log.debug(m + " workflow dir does not exist.");
            }

            if (applicationModuleDocDir.exists()) {
                if (!personalModuleDocDir.exists()) {
                    log.warn(personalModuleDocDir + " does not exist.");
                    log.warn("copy(" + applicationModuleDocDir + ","
                            + personalModuleDocDir + ")");
                    FileUtil.copyDirectory(applicationModuleDocDir,
                            personalModuleDocDir, false);
                }
            }
        
        }
        }

    /** Set the class and method to invoke instead of starting Kepler. */
        public static void setRunApplication(String className, String method) {
            _action = Action.RunCustomAction;
            _customActionClass = className;
            _customActionMethod = method;
        }
        
        // ////////////////////////////////////////////////////////////////////
        // // private methods ////

        /** Make sure that -runwf was specified. */
        private static void _assertRunWF(String arg)
                        throws IllegalArgumentException {
                if (_action != Action.RunWf && _action != Action.RunKAR) {
                        throw new IllegalArgumentException("ERROR: " + arg
                                        + " may only be used with -runwf");
                }
        }

        /** Run Kepler startup or shutdown module intializers. */
        private static void _initializeModules(boolean start) {
            _runModuleInitializers(start,
            start ? "Initialize" : "Shutdown",
            start ? "initializeModule" : "shutdownModule");

            // update whether we initialized or shut down.
        _haveInitialized = start;
        }
        
        /** Initialize command line arguments. */
        private static void _initializeCommandLineArguments() {
            if(!_haveInitializedCommandLineArguments) {
            _runModuleInitializers(true, "CommandLineArguments",
                    "initializeCommandLineArguments");
            _haveInitializedCommandLineArguments = true;
            }
        }
        
        /** Run any module initializers with specific class and method names.
         * @param start If true, the modules are called starting from the bottom
         * of the suite. 
         * @param className The name of the module initializer class to run.
         * @param methodName The name of the method in the class to invoke.
         */
        private static void _runModuleInitializers(boolean start, String className, String methodName) {
                ModuleTree tree = ModuleTree.instance();

                Iterable<Module> moduleList = null;
                
                // on startup, call initializers starting at lowest dependency,
                // i.e., at the bottom of modules.txt.
                // on shutdown, start at top of modules.txt
                if(start) {
                    moduleList = tree.reverse();
                } else {
                    moduleList = tree;
                }
                
                for (Module module : moduleList) {
                        String name = module.getName();
                        name = module.getStemName();

                        // construct the class name
                        
                        // dashes and periods are illegal characters in package names
                        name = name.replaceAll("-", "");
                        name = name.replaceAll("\\.", "");
                        String fullClassName = "org.kepler.module." + name + "." + className;
                        //System.out.println("looking for class: " + fullClassName);

                        try {
                                // attempt to find and instantiate it
                                Class<?> moduleClass = Class.forName(fullClassName);
                                
                // call the initializer
                                Object instance = moduleClass.newInstance();
                                
                if (className.equals("Initialize")) {
                    StatusNotifier.log("Initializing Module: " + name + ".");
                    ((ModuleInitializer)instance).initializeModule();
                    
                    if(_isDebugging) {
                        log.debug("Ran additional initialization for module "
                            + name + " from class " + fullClassName);
                    }
                } else {
                    Method method = moduleClass.getMethod(methodName);
                    method.invoke(instance);
                }
                                
                        } catch (ClassNotFoundException e) {
                                // it's not required that every module have an initializer.
                                // System.out.println("initializer class not found for " +
                                // module);
                        } catch (InstantiationException e) {
                                System.out.println("ERROR instantiating " + fullClassName + ": "
                                                + e.getMessage());
                        } catch (IllegalAccessException e) {
                                System.out.println(e.getMessage());
                        } catch(NoSuchMethodException | InvocationTargetException e) {
                            System.out.println(e.getMessage());
                        }
                }               
        }

    /**
     * read the osextension.txt file and return a hashtable of the properties
     * 
     * NOTE this method is duplicated in CompileModules.java. Change both if you
     * change one.
     */
    private static Hashtable<String, String> readOSExtensionFile(File f)
            throws Exception {
        // String newline = System.getProperty("line.separator");
        Hashtable<String, String> properties = new Hashtable<String, String>();
        FileReader fr = new FileReader(f);
        StringBuffer sb = new StringBuffer();
        char[] c = new char[1024];
        int numread = fr.read(c, 0, 1024);
        while (numread != -1) {
            sb.append(c, 0, numread);
            numread = fr.read(c, 0, 1024);
        }
        fr.close();
    
        String propertiesStr = sb.toString();
        // String[] props = propertiesStr.split(newline);
        String[] props = propertiesStr.split(";");
        for (int i = 0; i < props.length; i++) {
            String token1 = props[i];
            StringTokenizer st2 = new StringTokenizer(token1, ",");
            String key = st2.nextToken();
            String val = st2.nextToken();
            properties.put(key, val);
        }
    
        return properties;
    }   

    /** Start or stop any module HSQL servers. */
    private static void _runHSQLServers(boolean start) {
        
        org.kepler.util.sql.HSQL.setForkServers(true);              

        ModuleTree tree = ModuleTree.instance();

        Iterable<Module> moduleList = null;
        
        // if start, call at lowest dependency, i.e., at the bottom of modules.txt.
        // if stop, call at top of modules.txt
        if(start) {
            moduleList = tree.reverse();
        } else {
            moduleList = tree;
        }
        
        for (Module module : moduleList) {
            String name = module.getName();
            name = module.getStemName();

            // construct the class name
            if (name.indexOf("-") != -1) { // dashes are illegal characters in
                                            // package names so we need to
                                            // remove them
                name = name.replaceAll("-", "");
            }
            String fullClassName = "org.kepler.module." + name + ".HSQLManager";
            //System.out.println("looking for class: " + className);

            try {
                // attempt to find and instantiate it
                Class<?> moduleClass = Class.forName(fullClassName);
                ModuleHSQLManager manager = (ModuleHSQLManager) moduleClass.newInstance();
                
                if (start) {
                    manager.start();
                } else {
                    manager.stop();
                }
                
            } catch (ClassNotFoundException e) {
                // it's not required that every module have an hsql manager.
            } catch (InstantiationException e) {
                System.out.println("ERROR instantiating " + fullClassName + ": "
                        + e.getMessage());
            } catch (IllegalAccessException e) {
                System.out.println(e.getMessage());
            }
        }
    }

    /** Add the display related actor implementation information, different ActorModule properties 
     * file specify different display implementation.
     * The two ActorModule files in Kepler are located at display-redirect/src/org/kepler/.
     * The ActorModule file in ptolemy is located at ptolemy/src/ptolemy/actor/.
     * More info can be found at ptolemy.actor.injection.ActorModuleInitializer 
     */
    private static void addActorModule(String bundleFile){
                final ArrayList<PtolemyModule> actorModules = new ArrayList<PtolemyModule>();
            actorModules.add(new PtolemyModule(ResourceBundle
                        .getBundle(bundleFile)));
                Initializer _defaultInitializer = new Initializer() {
                @Override
            public void initialize() {
                    PtolemyInjector.createInjector(actorModules);
                }
                };
                ptolemy.actor.injection.ActorModuleInitializer.setInitializer(_defaultInitializer);
    }
    
        /** Print usage and exit. */
        private static void _showHelp() {
        System.out.println("USAGE:");
        System.out.println();
        System.out.println("To run the Kepler GUI:");
        System.out.println("kepler [-nosplash] [workflow.xml | workflow.kar]");
        System.out.println("-nosplash               start without showing splash screen.");
        System.out.println();
        System.out.println("To run the Ptolemy GUI:");
        System.out.println("kepler -vergil [workflow.xml]");
        System.out.println();
        System.out.println("To run a workflow XML from the command line:");
        System.out.println("kepler -runwf [-nogui | -redirectgui dir] [-nocache] [-noilwc] "
                + "[-paramFile file] [-param1 value1 ...] workflow.xml");
        System.out.println("-nogui                  run without GUI support.");
        System.out.println("-nocache                run without kepler cache.");
        System.out.println("-noilwc                 run without incrementing LSIDs when the workflow changes.");
        System.out.println("-noexit                 do not exit after execution when running with -nogui");
        System.out.println("-paramFile file         read parameters from file.");
        System.out.println("-redirectgui dir        redirect the contents of GUI actors to the specified directory.");
        System.out.println();
        System.out.println("To run a workflow KAR from the command line:");
        System.out.println("kepler -runkar [-nogui | -redirectgui dir] [-force] [-paramFile file] [-param1 value1 ...] workflow.kar");
        System.out.println("-force                  attempt to run ignoring missing module dependencies.");
        System.out.println("-nogui                  run without GUI support.");
        System.out.println("-paramFile file         read parameters from file.");
        System.out.println("-redirectgui dir        redirect the contents of GUI actors to the specified directory.");
        System.out.println();
        System.out.println("To start or stop the HSQL database servers:");
        System.out.println("kepler -hsql start");
        System.out.println("kepler -hsql stop");
        System.out.println();
        System.out.println("To create a workflow screen shot:");
        System.out.println("kepler -screenshot [-type png | jpg | gif] [-force] [-o output [output2 [...]] | -odir directory] workflow.xml [workflow2.xml [...]]");
        System.out.println("-force                      if true, always create the screenshot.");
        System.out.println("-o output [output2 [...]]   the output file name(s).");
        System.out.println("-odir dir                   the output directory.");
        System.out.println("-type png|jpg|gif           the image type.");
        System.out.println();
        System.out.println("The following options are for actor developers:");
        System.out.println();
        System.out.println("To create XML file(s) describing an actor using either the source file or class name:");
        System.out.println("kepler -createActorXML file1.java|class1 [file2.java|class2 ...]");
        System.out.println();
        System.out.println("To create the documentation for an item in the actor tree:");
        System.out.println("kepler -updateActorDocs [-overwrite] file1.xml [file2.xml ...]");
        System.out.println("-overwrite              overwrite any existing documentation.");
        
        Collection<CommandLineArgument> args = CommandLineArgument.getAll();
        if(!args.isEmpty()) {
            System.out.println();
            System.out.println("Additional command-line arguments:");
            System.out.println();
            for(CommandLineArgument arg: args) {
                System.out.println(arg.getUsage());
            }
        }
        }

        ////////////////////////////////////////////////////////////////////
    // private classes                                              ////

        /** A class that implements ShutdownListener. The class 
         *  org.kepler.Kepler cannot be used since it is never
         *  instantiated.
         */
        private static class Shutdown implements ShutdownListener
        {
        /** Perform any module cleanup tasks. */
        @Override
        public void shutdown() {
            Kepler._initializeModules(false);
        }
        }
        
        ////////////////////////////////////////////////////////////////////
        // private variables                                            ////

        /** The types of actions. */
        private enum Action {
                Kepler(""),
                RunWf("-runwf"),
                RunKAR("-runkar"),
        CreateActorXML("-createActorXML"),
                Vergil("-vergil"),
                HSQLStart("-hsql"),
                HSQLStop("-hsql"),
                UpdateActorDocs("-updateActorDocs"),
                MakeScreenShot("-screenshot"),
                RunCustomAction("");
                
                Action(String arg) {
                    _arg = arg;
                }
                
                public String getArg() {
                    return _arg;
                }
                
                private String _arg;
        };

        /** The action to perform. By default, start kepler GUI. */
        private static Action _action = Action.Kepler;

        /** Boolean to see if we've initialized. */
        private static boolean _haveInitialized = false;

        /** A copy of the command line arguments. */
        private static String[] _args;

        /** Logging. */
        private final static Log log = LogFactory.getLog(Kepler.class);
        
        /** True if log level is set to DEBUG. */
        private final static boolean _isDebugging = log.isDebugEnabled();
        
        /** If true, the program must be manually quit by the user. */
        private static boolean _mustManuallyQuit = false;

        /** If true, -nogui was specified on the command line. */
        private static boolean _runWithGui = true;
        
        /** If true, start the Kepler cache. If -nocache specified on
         *  the command line, this is false.
         */
    private static boolean _runWithCache = true;
        
    /** If true, show the splash screen. */
    private static boolean _showSplash = true;
    
    /** The output path for redirectdisplay option. */
    private static String _displayRedirectOutputPath = null;

        /** If true, -force was specified on the command line. */
        private static boolean _forceOpen = false;
        
    private static LinkedList<String> _applicationArgsList = new LinkedList<String>();

    /** The image type for the screenshot.*/
    private static String _screenShotType;
    
    /** A set of output screenshot file names. */ 
    private static  List<String> _screenShotOutputs;
    
    /** The output directory for screenshots. */
    private static String _screenShotOutputDir;
    
    /** If true, always create screenshots. Otherwise, screenshots are only taken if
     *  either the screenshot image does not exist or is older than the workflow.
     */
    private static boolean _screenShotForce = false;
    
    /** A set of workflows to take screenshots of. */
    private static List<String> _screenShotWorkflows = new LinkedList<String>();

    /** If true, then call System.exit() after running with no gui. */
    private static boolean _runThenExitNoGui = true;

    /** The class name containing _customActionMethod to run instead of starting Kepler. */
    private static String _customActionClass;

    /** The method in _customActionClass to run instead of starting Kepler. */
    private static String _customActionMethod;
    
    /** If true, command line arguments have been initialized. */
    private static boolean _haveInitializedCommandLineArguments = false;
    
}