/*
 * 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.commons.launcher;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.StringTokenizer;
import org.apache.commons.launcher.types.ArgumentSet;
import org.apache.commons.launcher.types.ConditionalArgument;
import org.apache.commons.launcher.types.ConditionalVariable;
import org.apache.commons.launcher.types.JVMArgumentSet;
import org.apache.commons.launcher.types.SysPropertySet;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;

/**
 * A class that eliminates the need for a batch or shell script to launch a Java
 * class. Some situations where elimination of a batch or shell script may be 
 * desirable are:
 * <ul>
 * <li>You want to avoid having to determining where certain application paths
 *  are e.g. your application's home directory, etc. Determining this
 *  dynamically in a Windows batch scripts is very tricky on some versions of
 *  Windows or when softlinks are used on Unix platforms.
 * <li>You want to avoid having to handle native file and path separators or
 *  native path quoting issues.
 * <li>You need to enforce certain system properties e.g.
 *  <code>java.endorsed.dirs</code> when running with JDK 1.4.
 * <li>You want to allow users to pass in custom JVM arguments or system
 *  properties without having to parse and reorder arguments in your script.
 *  This can be tricky and/or messy in batch and shell scripts.
 * <li>You want to bootstrap system properties from a configuration file instead
 *  hard-coding them in your batch and shell scripts.
 * <li>You want to provide localized error messages which is very tricky to do
 *  in batch and shell scripts.
 * </ul>
 *
 * @author Patrick Luby
 */
public class LaunchTask extends Task {

    //----------------------------------------------------------- Static Fields

    /**
     * The argument property name.
     */
    public final static String ARG_PROP_NAME = "launch.arg.";

    /**
     * The name of this task.
     */
    public final static String TASK_NAME = "launch";

    /**
     * Cached synchronous child processes for all instances of this class.
     */
    private static ArrayList childProcesses = new ArrayList();

    //------------------------------------------------------------------ Fields

    /**
     * Cached appendOutput flag.
     */
    private boolean appendOutput = false;

    /**
     * Cached synchronously executing child process.
     */
    private Process childProc = null;

    /**
     * Cached classpath.
     */
    private Path classpath = null;

    /**
     * Cached debug flag.
     */
    private boolean debug = false;

    /**
     * Cached displayMinimizedWindow flag.
     */
    private boolean displayMinimizedWindow = false;

    /**
     * Cached disposeMinimizedWindow flag.
     */
    private boolean disposeMinimizedWindow = true;

    /**
     * Cached failOnError flag.
     */
    private boolean failOnError = false;

    /**
     * Cached filter instance.
     */
    private LaunchFilter filter = null;

    /**
     * Cached filterClassName.
     */
    private String filterClassName = null;

    /**
     * Cached filterClasspath.
     */
    private Path filterClasspath = null;

    /**
     * Cached main class name.
     */
    private String mainClassName = null;

    /**
     * Cached minimizedWindowIcon.
     */
    private File minimizedWindowIcon = null;

    /**
     * Cached minimizedWindowTitle.
     */
    private String minimizedWindowTitle = null;

    /**
     * Cached output file.
     */
    private File outputFile = null;

    /**
     * Cached print flag.
     */
    private boolean print = false;

    /**
     * Cached redirect flag.
     */
    private boolean redirect = false;

    /**
     * Cached requireTools flag.
     */
    private boolean requireTools = false;

    /**
     * Cached arg elements
     */
    private ArgumentSet taskArgumentSet = new ArgumentSet();

    /**
     * Cached jvmarg elements
     */
    private JVMArgumentSet taskJVMArgumentSet = new JVMArgumentSet();

    /**
     * Cached sysproperty elements
     */
    private SysPropertySet taskSysPropertySet = new SysPropertySet();

    /**
     * Cached useArgs flag.
     */
    private boolean useArgs = true;

    /**
     * Cached useSystemIn flag.
     */
    private boolean useSystemIn = true;

    /**
     * Cached waitForChild flag.
     */
    private boolean waitForChild = true;

    //---------------------------------------------------------- Static Methods

    /**
     * Get the synchronous child processes for all instances of this class.
     *
     * @return the instances of this class.
     */
    public static Process[] getChildProcesses() {

        return (Process[])childProcesses.toArray(new Process[childProcesses.size()]);

    }

    //----------------------------------------------------------------- Methods

    /**
     * Add a nested arg element. Note that Ant will not invoke the specified
     * arg object's setter methods until after Ant invokes this method so
     * processing of the specified arg object is handled in the
     * {@link #execute()} method.
     *
     * @param arg the arg element
     */
    public void addArg(ConditionalArgument arg) {

        taskArgumentSet.addArg(arg);

    }

    /**
     * Add a nested argset element.
     *
     * @param set the argset element
     */
    public void addArgset(ArgumentSet set) {

        taskArgumentSet.addArgset(set);

    }

    /**
     * Add a nested jvmarg element. Note that Ant will not invoke the specified
     * jvmarg object's setter methods until after Ant invokes this method so
     * processing of the specified jvmarg object is handled in the
     * {@link #execute()} method.
     *
     * @param jvmArg the jvmarg element
     */
    public void addJvmarg(ConditionalArgument jvmArg) {

        taskJVMArgumentSet.addJvmarg(jvmArg);

    }

    /**
     * Add a nested jvmargset element.
     *
     * @param set the jvmargset element
     */
    public void addJvmargset(JVMArgumentSet set) {

        taskJVMArgumentSet.addJvmargset(set);

    }

    /**
     * Add a nested sysproperty element. Note that Ant will not invoke the
     * specified sysproperty object's setter methods until after Ant invokes
     * this method so processing of the specified sysproperty object is handled
     * in the {@link #execute()} method.
     *
     * @param var the sysproperty element
     */
    public void addSysproperty(ConditionalVariable var) {

        taskSysPropertySet.addSysproperty(var);

    }

    /**
     * Add a nested syspropertyset element.
     *
     * @param set the syspropertyset element
     */
    public void addSyspropertyset(SysPropertySet set) {

        taskSysPropertySet.addSyspropertyset(set);

    }

    /**
     * Create a nested classpath element.
     *
     * @return the Path object that contains all nested classpath elements
     */
    public Path createClasspath() {

        if (classpath == null)
            classpath = new Path(project);
        return classpath;

    }

    /**
     * Create a nested filter classpath element.
     *
     * @return the Path object that contains all nested filter classpath
     *  elements
     */
    public Path createFilterclasspath() {

        if (filterClasspath == null)
            filterClasspath = new Path(project);
        return filterClasspath;

    }

    /**
     * Construct a Java command and execute it using the settings that Ant
     * parsed from the Launcher's XML file. This method is called by the Ant
     * classes.
     *
     * @throws BuildException if there is a configuration or other error
     */
    public void execute() throws BuildException {

        try {

            // Check that the Launcher class was used to start Ant as this
            // task is not designed to use in a standalone Ant installation
            if (!Launcher.isStarted())
                throw new BuildException(Launcher.getLocalizedString("no.run.standalone", this.getClass().getName()));

            // Don't do anything if the launching process has been stopped
            if (Launcher.isStopped())
                throw new BuildException();

            if (mainClassName == null)
                throw new BuildException(Launcher.getLocalizedString("classname.null", this.getClass().getName()));

            // Copy all of the nested jvmarg elements into the jvmArgs object
            ArrayList taskJVMArgs = taskJVMArgumentSet.getList();
            ArrayList jvmArgs = new ArrayList(taskJVMArgs.size());
            for (int i = 0; i < taskJVMArgs.size(); i++) {
                ConditionalArgument value = (ConditionalArgument)taskJVMArgs.get(i);
                // Test "if" and "unless" conditions
                if (testIfCondition(value.getIf()) && testUnlessCondition(value.getUnless())) {
                    String[] list = value.getParts();
                    for (int j = 0; j < list.length; j++)
                        jvmArgs.add(list[j]);
                }
            }

            // Copy all of the nested sysproperty elements into the sysProps
            // object
            ArrayList taskSysProps = taskSysPropertySet.getList();
            HashMap sysProps = new HashMap(taskSysProps.size());
            for (int i = 0; i < taskSysProps.size(); i++) {
                ConditionalVariable variable = (ConditionalVariable)taskSysProps.get(i);
                // Test "if" and "unless" conditions
                if (testIfCondition(variable.getIf()) && testUnlessCondition(variable.getUnless()))
                    sysProps.put(variable.getKey(), variable.getValue());
            }

            // Copy all of the nested arg elements into the appArgs object
            ArrayList taskArgs = taskArgumentSet.getList();
            ArrayList appArgs = new ArrayList(taskArgs.size());
            for (int i = 0; i < taskArgs.size(); i++) {
                ConditionalArgument value = (ConditionalArgument)taskArgs.get(i);
                // Test "if" and "unless" conditions
                if (testIfCondition(value.getIf()) && testUnlessCondition(value.getUnless())) {
                    String[] list = value.getParts();
                    for (int j = 0; j < list.length; j++)
                        appArgs.add(list[j]);
                }
            }

            // Add the Launcher's command line arguments to the appArgs object
            if (useArgs) {
                int currentArg = 0;
                String arg = null;
                while ((arg = project.getUserProperty(LaunchTask.ARG_PROP_NAME + Integer.toString(currentArg++))) != null)
                    appArgs.add(arg);
            }

            // Make working copies of some of the flags since they may get
            // changed by a filter class
            String filteredClasspath = null;
            if (classpath != null)
                filteredClasspath = classpath.toString();
            String filteredMainClassName = mainClassName;
            boolean filteredRedirect = redirect;
            File filteredOutputFile = outputFile;
            boolean filteredAppendOutput = appendOutput;
            boolean filteredDebug = debug;
            boolean filteredDisplayMinimizedWindow = displayMinimizedWindow;
            boolean filteredDisposeMinimizedWindow = disposeMinimizedWindow;
            boolean filteredFailOnError = failOnError;
            String filteredMinimizedWindowTitle = minimizedWindowTitle;
            File filteredMinimizedWindowIcon = minimizedWindowIcon;
            boolean filteredPrint = print;
            boolean filteredRequireTools = requireTools;
            boolean filteredUseSystemIn = useSystemIn;
            boolean filteredWaitForChild = waitForChild;

            // If there is a filter in the filterclassname attribute, let it
            // evaluate and edit the attributes and nested elements before we
            // start evaluating them
            if (filterClassName != null) {
                 if (filter == null) {
                     try {
                         ClassLoader loader = this.getClass().getClassLoader();
                         if (filterClasspath != null) {
                             // Construct a class loader to load the class
                             String[] fileList = filterClasspath.list();
                             URL[] urls = new URL[fileList.length];
                             for (int i = 0; i < fileList.length; i++)
                                 urls[i] = new File(fileList[i]).toURL();
                             loader = new URLClassLoader(urls, loader);
                         }
                         Class filterClass = loader.loadClass(filterClassName);
                         filter = (LaunchFilter)filterClass.newInstance();
                         // Execute filter and save any changes
                         LaunchCommand command = new LaunchCommand();
                         command.setJvmargs(jvmArgs);
                         command.setSysproperties(sysProps);
                         command.setArgs(appArgs);
                         command.setClasspath(filteredClasspath);
                         command.setClassname(filteredMainClassName);
                         command.setRedirectoutput(filteredRedirect);
                         command.setOutput(filteredOutputFile);
                         command.setAppendoutput(filteredAppendOutput);
                         command.setDebug(filteredDebug);
                         command.setDisplayminimizedwindow(filteredDisplayMinimizedWindow);
                         command.setDisposeminimizedwindow(filteredDisposeMinimizedWindow);
                         command.setFailonerror(filteredFailOnError);
                         command.setMinimizedwindowtitle(filteredMinimizedWindowTitle);
                         command.setMinimizedwindowicon(filteredMinimizedWindowIcon);
                         command.setPrint(filteredPrint);
                         command.setRequiretools(filteredRequireTools);
                         command.setUsesystemin(filteredUseSystemIn);
                         command.setWaitforchild(filteredWaitForChild);
                         filter.filter(command);
                         jvmArgs = command.getJvmargs();
                         sysProps = command.getSysproperties();
                         appArgs = command.getArgs();
                         filteredClasspath = command.getClasspath();
                         filteredMainClassName = command.getClassname();
                         filteredRedirect = command.getRedirectoutput();
                         filteredOutputFile = command.getOutput();
                         filteredAppendOutput = command.getAppendoutput();
                         filteredDebug = command.getDebug();
                         filteredDisplayMinimizedWindow = command.getDisplayminimizedwindow();
                         filteredDisposeMinimizedWindow = command.getDisposeminimizedwindow();
                         filteredFailOnError = command.getFailonerror();
                         filteredMinimizedWindowTitle = command.getMinimizedwindowtitle();
                         filteredMinimizedWindowIcon = command.getMinimizedwindowicon();
                         filteredPrint = command.getPrint();
                         filteredRequireTools = command.getRequiretools();
                         filteredUseSystemIn = command.getUsesystemin();
                         filteredWaitForChild = command.getWaitforchild();
                         // Check changes
                         if (filteredMainClassName == null)
                             throw new BuildException(Launcher.getLocalizedString("classname.null", this.getClass().getName()));
                         if (jvmArgs == null)
                             jvmArgs = new ArrayList();
                         if (sysProps == null)
                             sysProps = new HashMap();
                         if (appArgs == null)
                             appArgs = new ArrayList();
                     } catch (BuildException be) {
                         throw new BuildException(filterClassName + " " + Launcher.getLocalizedString("filter.exception", this.getClass().getName()), be);
                     } catch (ClassCastException cce) {
                         throw new BuildException(filterClassName + " " + Launcher.getLocalizedString("filter.not.filter", this.getClass().getName()));
                     } catch (Exception e) {
                         throw new BuildException(e);
                     }
                 }
            }

            // Force child JVM into foreground if running using JDB
            if (filteredDebug) {
                filteredWaitForChild = true;
                filteredUseSystemIn = true;
            }

            // Prepend standard paths to classpath
            StringBuffer fullClasspath = new StringBuffer(Launcher.getBootstrapFile().getPath());
            if (filteredRequireTools) {
                fullClasspath.append(File.pathSeparator);
                fullClasspath.append(Launcher.getToolsClasspath());
            }
            if (filteredClasspath != null) {
                fullClasspath.append(File.pathSeparator);
                fullClasspath.append(filteredClasspath);
            }

            // Set ChildMain.WAIT_FOR_CHILD_PROP_NAME property for child JVM
            sysProps.remove(ChildMain.WAIT_FOR_CHILD_PROP_NAME);
            if (filteredWaitForChild)
                sysProps.put(ChildMain.WAIT_FOR_CHILD_PROP_NAME, "");

            // Set minimized window properties for child JVM
            sysProps.remove(ChildMain.DISPLAY_MINIMIZED_WINDOW_PROP_NAME);
            sysProps.remove(ChildMain.MINIMIZED_WINDOW_TITLE_PROP_NAME);
            sysProps.remove(ChildMain.MINIMIZED_WINDOW_ICON_PROP_NAME);
            sysProps.remove(ChildMain.DISPOSE_MINIMIZED_WINDOW_PROP_NAME);
            if (!filteredWaitForChild && filteredDisplayMinimizedWindow) {
                sysProps.put(ChildMain.DISPLAY_MINIMIZED_WINDOW_PROP_NAME, "");
                if (filteredMinimizedWindowTitle != null)
                    sysProps.put(ChildMain.MINIMIZED_WINDOW_TITLE_PROP_NAME, filteredMinimizedWindowTitle);
                else
                    sysProps.put(ChildMain.MINIMIZED_WINDOW_TITLE_PROP_NAME, getOwningTarget().getName());
                if (filteredMinimizedWindowIcon != null)
                    sysProps.put(ChildMain.MINIMIZED_WINDOW_ICON_PROP_NAME, filteredMinimizedWindowIcon.getCanonicalPath());
                // Set ChildMain.DISPOSE_MINIMIZED_WINDOW_PROP_NAME property
                if (filteredDisposeMinimizedWindow)
                    sysProps.put(ChildMain.DISPOSE_MINIMIZED_WINDOW_PROP_NAME, "");
            }

            // Set ChildMain.OUTPUT_FILE_PROP_NAME property for child JVM
            sysProps.remove(ChildMain.OUTPUT_FILE_PROP_NAME);
            if (!filteredWaitForChild && filteredRedirect) {
                if (filteredOutputFile != null) {
                    String outputFilePath = filteredOutputFile.getCanonicalPath();
                    // Verify that we can write to the output file
                    try {
                        File parentFile = new File(filteredOutputFile.getParent());
                        // To take care of non-existent log directories
                        if ( !parentFile.exists() ) {
                            //Trying to create non-existent parent directories
                            parentFile.mkdirs();
                            //If this fails createNewFile also fails
                            //We can give more exact error message, if we choose
                        }
                        filteredOutputFile.createNewFile();
                    } catch (IOException ioe) {
                        throw new BuildException(outputFilePath + " " + Launcher.getLocalizedString("output.file.not.creatable", this.getClass().getName()));
                    }
                    if (!filteredOutputFile.canWrite())
                        throw new BuildException(outputFilePath + " " + Launcher.getLocalizedString("output.file.not.writable", this.getClass().getName()));
                    sysProps.put(ChildMain.OUTPUT_FILE_PROP_NAME, outputFilePath);
                    if (filteredAppendOutput)
                        sysProps.put(ChildMain.APPEND_OUTPUT_PROP_NAME, "");
                    Launcher.getLog().println(Launcher.getLocalizedString("redirect.notice", this.getClass().getName()) + " " + outputFilePath);
                } else {
                    throw new BuildException(Launcher.getLocalizedString("output.file.null", this.getClass().getName()));
                }
            }

            // Create the heartbeatFile. This file is needed by the
            // ParentListener class on Windows since the entire child JVM
            // process will block on Windows machines using some versions of
            // Unix shells such as MKS, etc.
            File heartbeatFile = null;
            FileOutputStream heartbeatOutputStream = null;
            if (filteredWaitForChild) {
                File tmpDir = null;
                String tmpDirName = (String)sysProps.get("java.io.tmpdir");
                if (tmpDirName != null)
                    tmpDir = new File(tmpDirName);
                heartbeatFile = File.createTempFile(ChildMain.HEARTBEAT_FILE_PROP_NAME + ".", "", tmpDir);
                // Open the heartbeat file for writing so that it the child JVM
                // will not be able to delete it while this process is running
                heartbeatOutputStream = new FileOutputStream(heartbeatFile);
                sysProps.put(ChildMain.HEARTBEAT_FILE_PROP_NAME, heartbeatFile.getCanonicalPath());
            }

            // Assemble child command
            String[] cmd = new String[5 + jvmArgs.size() + sysProps.size() + appArgs.size()];
            int nextCmdArg = 0;
            if (filteredDebug)
                cmd[nextCmdArg++] = Launcher.getJDBCommand();
            else
                cmd[nextCmdArg++] = Launcher.getJavaCommand();
            // Add jvmArgs to command
            for (int i = 0; i < jvmArgs.size(); i++)
                cmd[nextCmdArg++] = (String)jvmArgs.get(i);
            // Add properties to command
            Iterator sysPropsKeys = sysProps.keySet().iterator();
            while (sysPropsKeys.hasNext()) {
                String key = (String)sysPropsKeys.next();
                if (key == null)
                    continue;
                String value = (String)sysProps.get(key);
                if (value == null)
                    value = "";
                cmd[nextCmdArg++] = "-D" + key + "=" + value;
            }
            // Add classpath to command. Note that it is after the jvmArgs
            // and system properties to prevent the user from sneaking in an
            // alterate classpath through the jvmArgs.
            cmd[nextCmdArg++] = "-classpath";
            cmd[nextCmdArg++] = fullClasspath.toString();
            // Add main class to command
            int mainClassArg = nextCmdArg;
            cmd[nextCmdArg++] = ChildMain.class.getName();
            cmd[nextCmdArg++] = filteredMainClassName;
            // Add args to command
            for (int i = 0; i < appArgs.size(); i++)
            {
                cmd[nextCmdArg++] = (String)appArgs.get(i);
            }
            // Print command
            if (filteredPrint) {
                // Quote the command arguments
                String osname = System.getProperty("os.name").toLowerCase();
                StringBuffer buf = new StringBuffer(cmd.length * 100);
                String quote = null;
                String replaceQuote = null;
                if (osname.indexOf("windows") >= 0) {
                    // Use double-quotes to quote on Windows
                    quote = "\"";
                    replaceQuote = quote + quote + quote;
                } else {
                    // Use single-quotes to quote on Unix
                    quote = "'";
                    replaceQuote = quote + "\\" + quote + quote;
                }
                for (int i = 0; i < cmd.length; i++) {
                    // Pull ChildMain out of command as we want to print the
                    // real JVM command that can be executed by the user
                    if (i == mainClassArg)
                        continue;
                    if (i > 0)
                        buf.append(" ");
                    buf.append(quote);
                    StringTokenizer tokenizer = new StringTokenizer(cmd[i], quote, true);
                    while (tokenizer.hasMoreTokens()) {
                        String token = tokenizer.nextToken();
                        if (quote.equals(token))
                            buf.append(replaceQuote);
                        else
                            buf.append(token);
                    }
                    buf.append(quote);
                }
                // Print the quoted command
                System.err.println(Launcher.getLocalizedString("executing.child.command", this.getClass().getName()) + ":");
                System.err.println(buf.toString());
            }

            // Create a child JVM
            if (Launcher.isStopped())
                throw new BuildException();
            Process proc = null;
            synchronized (LaunchTask.childProcesses) {
                proc = Runtime.getRuntime().exec(cmd);
                // Add the synchronous child process
                if (filteredWaitForChild) {
                    childProc = proc;
                    LaunchTask.childProcesses.add(proc);
                }
            }
            if (filteredWaitForChild) {
                StreamConnector stdout =
                    new StreamConnector(proc.getInputStream(), System.out);
                StreamConnector stderr =
                    new StreamConnector(proc.getErrorStream(), System.err);
                stdout.start();
                stderr.start();
                if (filteredUseSystemIn) {
                    StreamConnector stdin =
                        new StreamConnector(System.in, proc.getOutputStream());
                    stdin.start();
                }
                proc.waitFor();
                // Let threads flush any unflushed output
                stdout.join();
                stderr.join();
                if (heartbeatOutputStream != null)
                    heartbeatOutputStream.close();
                if (heartbeatFile != null)
                    heartbeatFile.delete();
                int exitValue = proc.exitValue();
                if (filteredFailOnError && exitValue != 0)
                    throw new BuildException(Launcher.getLocalizedString("child.failed", this.getClass().getName()) + " " + exitValue);
            }
            // Need to check if the launching process has stopped because
            // processes don't throw exceptions when they are terminated
            if (Launcher.isStopped())
                throw new BuildException();

        } catch (BuildException be) {
            throw be;
        } catch (Exception e) {
            if (Launcher.isStopped())
                throw new BuildException(Launcher.getLocalizedString("launch.task.stopped", this.getClass().getName()));
            else 
                throw new BuildException(e);
        }

    }

    /**
     * Set the useArgs flag. Setting this flag to true will cause this
     * task to append all of the command line arguments used to start the
     * {@link Launcher#start(String[])} method to the arguments
     * passed to the child JVM.
     *
     * @param useArgs the useArgs flag
     */
    public void setUseargs(boolean useArgs) {

        this.useArgs = useArgs;

    }

    /**
     * Set the useSystemIn flag. Setting this flag to false will cause this 
     * task to not read System.in. This will cause the child JVM to never
     * receive any bytes when it reads System.in. Setting this flag to false
     * is useful in some Unix environments where processes cannot be put in
     * the background when they read System.in.
     *
     * @param useSystemIn the useSystemIn flag
     */
    public void setUsesystemin(boolean useSystemIn) {

        this.useSystemIn = useSystemIn;

    }

    /**
     * Set the waitForChild flag. Setting this flag to true will cause this
     * task to wait for the child JVM to finish executing before the task
     * completes. Setting this flag to false will cause this task to complete
     * immediately after it starts the execution of the child JVM. Setting it
     * false emulates the "&" background operator in most Unix shells and is
     * most of set to false when launching server or GUI applications.
     *
     * @param waitForChild the waitForChild flag
     */
    public void setWaitforchild(boolean waitForChild) {

        this.waitForChild = waitForChild;

    }

    /**
     * Set the class name.
     *
     * @param mainClassName the class to execute <code>main(String[])</code>
     */
    public void setClassname(String mainClassName) {

        this.mainClassName = mainClassName;

    }

    /**
     * Set the classpath.
     *
     * @param classpath the classpath
     */
    public void setClasspath(Path classpath) {

        createClasspath().append(classpath);

    }

    /**
     * Adds a reference to a classpath defined elsewhere.
     *
     * @param ref reference to the classpath
     */
    public void setClasspathref(Reference ref) {

        createClasspath().setRefid(ref);

    }

    /**
     * Set the debug flag. Setting this flag to true will cause this
     * task to run the child JVM using the JDB debugger.
     *
     * @param debug the debug flag
     */
    public void setDebug(boolean debug) {

        this.debug = debug;

    }

    /**
     * Set the displayMinimizedWindow flag. Note that this flag has no effect
     * on non-Windows platforms. On Windows platform, setting this flag to true
     * will cause a minimized window to be displayed in the Windows task bar
     * while the child process is executing. This flag is usually set to true
     * for server applications that also have their "waitForChild" attribute
     * set to false via the {@link #setWaitforchild(boolean)} method.
     *
     * @param displayMinimizedWindow true if a minimized window should be
     *  displayed in the Windows task bar while the child process is executing 
     */
    public void setDisplayminimizedwindow(boolean displayMinimizedWindow) {

        this.displayMinimizedWindow = displayMinimizedWindow;

    }

    /**
     * Set the disposeMinimizedWindow flag. Note that this flag has no effect
     * on non-Windows platforms. On Windows platform, setting this flag to true
     * will cause any minimized window that is display by setting the
     * "displayMinimizedWindow" attribute to true via the
     * {@link #setDisplayminimizedwindow(boolean)} to be automatically
     * disposed of when the child JVM's <code>main(String[])</code> returns.
     * This flag is normally used for applications that don't explicitly call
     * {@link System#exit(int)}. If an application does not explicitly call
     * {@link System#exit(int)}, an minimized windows need to be disposed of
     * for the child JVM to exit.
     *
     * @param disposeMinimizedWindow true if a minimized window in the Windows
     *  taskbar should be automatically disposed of after the child JVM's
     *  <code>main(String[])</code> returns
     */
    public void setDisposeminimizedwindow(boolean disposeMinimizedWindow) {

        this.disposeMinimizedWindow = disposeMinimizedWindow;

    }

    /**
     * Set the failOnError flag.
     *
     * @param failOnError true if the launch process should stop if the child
     *  JVM returns an exit value other than 0
     */
    public void setFailonerror(boolean failOnError) {

        this.failOnError = failOnError;

    }
    /**
     * Set the filter class name.
     *
     * @param filterClassName the class that implements the
     *  {@link LaunchFilter} interface
     */
    public void setFilterclassname(String filterClassName) {

        this.filterClassName = filterClassName;

    }

    /**
     * Set the filter class' classpath.
     *
     * @param filterClasspath the classpath for the filter class
     */
    public void setFilterclasspath(Path filterClasspath) {

        createFilterclasspath().append(filterClasspath);

    }

    /**
     * Set the title for the minimized window that will be displayed in the
     * Windows taskbar. Note that this property has no effect on non-Windows
     * platforms.
     *
     * @param minimizedWindowTitle the title to set for any minimized window
     *  that is displayed in the Windows taskbar
     */
    public void setMinimizedwindowtitle(String minimizedWindowTitle) {

        this.minimizedWindowTitle = minimizedWindowTitle;

    }

    /**
     * Set the icon file for the minimized window that will be displayed in the
     * Windows taskbar. Note that this property has no effect on non-Windows
     * platforms.
     *
     * @param minimizedWindowIcon the icon file to use for any minimized window
     *  that is displayed in the Windows taskbar
     */
    public void setMinimizedwindowicon(File minimizedWindowIcon) {

        this.minimizedWindowIcon = minimizedWindowIcon;

    }

    /**
     * Set the file that the child JVM's System.out and System.err will be
     * redirected to. Output will only be redirected if the redirect flag
     * is set to true via the {@link #setRedirectoutput(boolean)} method.
     *
     * @param outputFile a File to redirect System.out and System.err to
     */
    public void setOutput(File outputFile) {

        this.outputFile = outputFile;

    }

    /**
     * Set the print flag. Setting this flag to true will cause the full child
     * JVM command to be printed to {@link System#out}.
     *
     * @param print the print flag
     */
    public void setPrint(boolean print) {

        this.print = print;

    }

    /**
     * Set the appendOutput flag. Setting this flag to true will cause the child
     * JVM to append System.out and System.err to the file specified by the
     * {@link #setOutput(File)} method. Setting this flag to false will cause
     * the child to overwrite the file.
     *
     * @param appendOutput true if output should be appended to the output file
     */
    public void setAppendoutput(boolean appendOutput) {

        this.appendOutput = appendOutput;

    }

    /**
     * Set the redirect flag. Setting this flag to true will cause the child
     * JVM's System.out and System.err to be redirected to file set using the
     * {@link #setOutput(File)} method. Setting this flag to false will
     * cause no redirection.
     *
     * @param redirect true if System.out and System.err should be redirected
     */
    public void setRedirectoutput(boolean redirect) {

        this.redirect = redirect;

    }

    /**
     * Set the requireTools flag. Setting this flag to true will cause the
     * JVM's tools.jar to be added to the child JVM's classpath. This
     * sets an explicit requirement that the user use a JDK instead of a
     * JRE. Setting this flag to false explicitly allows the user to use
     * a JRE.
     *
     * @param requireTools true if a JDK is required and false if only a JRE
     *  is required
     */
    public void setRequiretools(boolean requireTools) {

        this.requireTools = requireTools;

    }

    /**
     * Determine if the "if" condition flag for a nested element meets all
     * criteria for use.
     *
     * @param ifCondition the "if" condition flag for a nested element
     * @return true if the nested element should be process and false if it
     *  should be ignored
     */
    private boolean testIfCondition(String ifCondition) {

        if (ifCondition == null || "".equals(ifCondition))
            return true;
        return project.getProperty(ifCondition) != null;

    }

    /**
     * Determine if the "unless" condition flag for a nested element meets all
     * criteria for use.
     *
     * @param unlessCondition the "unless" condition flag for a nested element
     * @return true if the nested element should be process and false if it
     *  should be ignored
     */
    private boolean testUnlessCondition(String unlessCondition) {

        if (unlessCondition == null || "".equals(unlessCondition))
            return true;
        return project.getProperty(unlessCondition) == null;

    }

}