package com.waldura.exec;

import java.io.IOException;


/**
 * Represents the execution of an external processes.
 * Descendants will extend this class in order to provide process execution
 * from specific platforms or shell/command-line environments.
 *
 * @author Renaud Waldura
 */

public abstract class Exec
{
	/**
	 * The exit value returned from the <code>getExitValue()</code> method
	 * if the process execution has not yet completed.
	 */
	public static final int NOT_COMPLETED = 255;

	/**
	 * The field of the <code>Command</code> property.
	 *
	 * @see getCommand()
	 */
	private final String[] command;

	/**
	 * The field of the <code>Wait</code> property.
	 *
	 * @see getWait()
	 */
	private boolean wait = true;

	/**
	 * The field of the <code>Verbose</code> property.
	 *
	 * @see getVerbose()
	 */
	private boolean verbose = false;

	/**
	 * The field of the <code>ExitValue</code> proeprty.
	 *
	 * @see ExitValue()
	 */
	private int exitValue = Exec.NOT_COMPLETED;

    /**
     * Private constructor.
     */
    protected Exec(String[] command)
    {
        this.command = command;   
    }
    
	/**
	 * The first item of the array has the name of the executable,
	 * and the remaining items have the arguments to be passed to the running process.
	 */
	public String[] getCommand()
	{
		return command;
	}

	/**
	 * Tells this class whether the <code>execute</code> method should wait for the process
	 * to finish executing or if it should return right away.
	 */
	 public boolean getWait()
	 {
		return wait;
	 }

	/**
	 * Tells this class whether the <code>execute</code> method should redirect
	 * the standard and error outputs of the process to be executed
	 * to the respective outputs of this process (the one that is running the subprocess).
	 */
	public boolean getVerbose()
	{
		return verbose;
	}

	/**
	 * Returns the exit value of the process execution previously spawned.
	 * <p>
	 * It will return the value of the <code>Exec.NOT_COMPLETED</code> constant
	 * if the process has not yet completed.
	 * <p>
	 * If you are not waiting for the process to finish, the exit value might
	 * not be updated with the actual exit value of the process (implementors
	 * do not have to do it).
	 *
	 * @return The exit value of the process execution.
	 */
	public int getExitValue()
	{
		return exitValue;
	}

	/**
	 * The setter of the <code>Wait</code> property.
	 *
	 * @see #getWait()
	 */
	public void setWait(boolean newValue)
	{
		wait = newValue;
	}

	/**
	 * The setter of the <code>Verbose</code> property.
	 *
	 * @see #getVerbose()
	 */
	public void setVerbose(boolean newValue)
	{
		verbose = newValue;
	}

	/**
	 * The setter of the <code>ExitValue</code> property.
	 * <p>
	 * This setter is a protected method because only the descendants of this class should change
	 * this property in the overriden <code>execute()</code> method.
	 *
	 * @see #getExitValue()
	 */
	protected void setExitValue(int newValue)
	{
		exitValue = newValue;
	}

	/**
	 * Executes the process specified by the <code>Command</code> property,
	 * and waits for its completion if the <code>Wait</code> property is
	 * set to <code>true</code>; otherwise, returns right away and leaves the process executing.
	 *
	 * @throws IOException Unable to execute the process or error during the process execution.
	 */
	public abstract void execute() throws IOException;

	/**
	 * Returns an instance of this class prepared to execute the process
	 * specified by the command. Note: if the platform we are
	 * currently running on is unknown to us,  we default to trying
	 * the {@link CertifiedBourneExec CertifiedBourneExec} (the Unix launcher).
	 *
	 * @param command see {@link #getCommand() getCommand}
	 */
	public static Exec newInstance(String command[])
	{
		final Exec exec;

		if (command.length > 0 && command[0].endsWith(".class"))
		{
			exec = new JavaClassExec(command);
		}
		else if (Platform.getCurrent().isWindows())
		{
			exec = new CertifiedExitValExec(command);
		}
		else if (Platform.getCurrent().isMacintosh())
		{
			if (Platform.getCurrent().isMacOSX())
            {
				exec = new MacOSXExec(command);
            }
			else
            {
				exec = new CertifiedExitValExec(command);
            }
		}
		else if (Platform.getCurrent().isUnix())
		{
			exec = new CertifiedBourneExec(command);
		}
		else
		{
			// unknown platform; try the CBE
			exec = new CertifiedBourneExec(command);
		}

		return exec;
	}
}