/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc. 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    rfrost@bea.com
 *    tyip@bea.com
 *    
 *    Based on GenericServerLaunchConfigurationDelegate by Gorkem Ercan
 *******************************************************************************/

package org.eclipse.jst.server.generic.core.internal;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.tools.ant.taskdefs.Execute;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.RuntimeProcess;
import org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.wst.server.core.IServer;
import org.eclipse.wst.server.core.ServerUtil;
import org.eclipse.wst.server.core.model.ServerBehaviourDelegate;

/**
 * <p>Extension of <code>AbstractJavaLaunchConfigurationDelegate</code> that supports 
 * servers which are started/stopped via external executables (e.g. scripts).</p>
 * 
 * <p>Note: <code>AbstractJavaLaunchConfigurationDelegate</code> is extended simply to take advantage
 * of a set of useful code that is not directly related to launching a JVM-based app.</p>
 */
public class ExternalLaunchConfigurationDelegate extends AbstractJavaLaunchConfigurationDelegate {

	/**
	 * Identifier for the executable server configuration type
	 * (value <code>"org.eclipse.jst.server.generic.core.ExternalLaunchConfigurationType"</code>).
	 */
	public static final String ID_EXTERNAL_LAUNCH_TYPE = CorePlugin.PLUGIN_ID + ".ExternalLaunchConfigurationType"; //$NON-NLS-1$

	/**
	 * Name of the launch configuration attribute that holds the external executable commandline.
	 */
	public static final String COMMANDLINE = CorePlugin.PLUGIN_ID  + ".COMMANDLINE"; //$NON-NLS-1$

	/**
	 * Name of the launch configuration attribute that holds a descriptive name for the external executable.
	 */
	public static final String EXECUTABLE_NAME = CorePlugin.PLUGIN_ID + ".EXECUTABLE_NAME"; //$NON-NLS-1$

	/**
	 * Name of the launch configuration attribute that holds the debug port.
	 */
	public static final String DEBUG_PORT = CorePlugin.PLUGIN_ID + ".DEBUG_PORT"; //$NON-NLS-1$
	/**
	 * Name of the launch configuration attribute that holds the host for remote debugging.
	 */
	public static final String HOST = CorePlugin.PLUGIN_ID + ".HOST"; //$NON-NLS-1$
	
	/**
	 * Default value for the descriptive name for the external executable.
	 */
	public static final String DEFAULT_EXECUTABLE_NAME = "External Generic Server"; //$NON-NLS-1$
	
	/**
	 * Debugging launch configuration delegate.
	 */
	private static ExternalDebugLaunchConfigurationDelegate debuggingDelegate =
        new ExternalDebugLaunchConfigurationDelegate();
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.ILaunchConfigurationDelegate#launch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String, org.eclipse.debug.core.ILaunch, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void launch(ILaunchConfiguration configuration, 
			       String mode,
			       ILaunch launch, 
			       IProgressMonitor monitor) throws CoreException {
		IServer server = ServerUtil.getServer(configuration);
		if (server == null) {
		    abort(GenericServerCoreMessages.missingServer, null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);
		}	

		ExternalServerBehaviour serverBehavior = (ExternalServerBehaviour) server.loadAdapter(ServerBehaviourDelegate.class, null);
		
		// initialize the server, check the ports and start the PingThread that will check 
		// server state
		serverBehavior.setupLaunch(launch, mode, monitor);

		// get the "external" command
		String commandline = configuration.getAttribute(COMMANDLINE, (String) null);
		if (commandline == null || commandline.length() == 0) {
			abort(GenericServerCoreMessages.commandlineUnspecified, null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);			
		}
		
		// parse the "external" command into multiple args
		String[] cmdArgs = DebugPlugin.parseArguments(commandline);
		// get the "programArguments", parsed into multiple args
		String[] pgmArgs = DebugPlugin.parseArguments(getProgramArguments(configuration));
		
		// Create the full array of cmds
		String[] cmds = new String[cmdArgs.length + pgmArgs.length];
		System.arraycopy(cmdArgs, 0, cmds, 0, cmdArgs.length);
		System.arraycopy(pgmArgs, 0, cmds, cmdArgs.length, pgmArgs.length);
		
		// get a descriptive name for the executable
		String executableName = configuration.getAttribute(EXECUTABLE_NAME, DEFAULT_EXECUTABLE_NAME);
		
		// get the executable environment
		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
		String[] env = manager.getEnvironment(configuration);
		
		// get the working directory
		File workingDir = verifyWorkingDirectory(configuration);
		if (workingDir == null) {
			abort(GenericServerCoreMessages.workingdirUnspecified, null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);			
		}
		
		// Launch the executable for the configuration using the Ant Execute class
		try {
			Process process = Execute.launch(null, cmds, env, workingDir, true);
			serverBehavior.startPingThread();
			IProcess runtimeProcess = new RuntimeProcess(launch, process, executableName, null);
			launch.addProcess(runtimeProcess);
			serverBehavior.setProcess(runtimeProcess);
		} catch (IOException ioe) {
			abort(GenericServerCoreMessages.errorLaunchingExecutable, ioe,  IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);
		}

		if (mode.equals("debug")) { //$NON-NLS-1$
			ILaunchConfigurationWorkingCopy wc = createDebuggingConfig(configuration);
			// if we're launching the debugging we need to wait for the config to start
			// before launching the debugging session
			serverBehavior.setDebuggingConfig(wc, mode, launch, monitor);
		}
	}

	private ILaunchConfigurationWorkingCopy createDebuggingConfig(ILaunchConfiguration configuration) 
	throws CoreException {
        ILaunchConfigurationWorkingCopy wc = configuration.getWorkingCopy();
        String port = configuration.getAttribute(DEBUG_PORT, (String) null);
        if (port==null || port.length()==0) {
        	abort(GenericServerCoreMessages.debugPortUnspecified, null, IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR);
        }
        setDebugArgument(wc, IJavaLaunchConfigurationConstants.ATTR_CONNECT_MAP, "port", port); //$NON-NLS-1$
        setDebugArgument(wc, IJavaLaunchConfigurationConstants.ATTR_CONNECT_MAP, "hostname",  //$NON-NLS-1$
        		configuration.getAttribute(HOST, "localhost"));  //$NON-NLS-1$
        return wc;
	}
	
	/**
	 * Starts the debugging session
	 */
	protected static void startDebugging(ILaunchConfigurationWorkingCopy wc,
			       						 String mode,
			       						 ILaunch launch, 
			       						 IProgressMonitor monitor) throws CoreException {
		Trace.trace(Trace.FINEST, "Starting debugging"); //$NON-NLS-1$
		debuggingDelegate.launch(wc, mode, launch, monitor);
	}
	  
    private void setDebugArgument(ILaunchConfigurationWorkingCopy config, String attribKey, String key, String arg) {
        try {
            Map args = config.getAttribute(attribKey, (Map)null);
            if (args!=null) {
                args = new HashMap(args);
            } else {
                args = new HashMap();
            }
            args.put(key, String.valueOf(arg));
            config.setAttribute(attribKey, args);
        } catch (CoreException ce) {
            // ignore
        }        
    }
	
	/**
	 * Throws a core exception with the given message and optional
	 * exception. The exception's status code will indicate an error.
	 * 
	 * @param message error message
	 * @param exception cause of the error, or <code>null</code>
	 * @exception CoreException with the given message and underlying
	 *  exception
	 */
	protected void abort(String message, Throwable exception, int code) throws CoreException {
		throw new CoreException(new Status(IStatus.ERROR, CorePlugin.getDefault().getBundle().getSymbolicName(), code, message, exception));
	}
}