/*
    * Created on 05.12.2004
    *
    */
   package org.apache.commons.jelly.eclipse.ui;
   
   import java.io.File;
   import java.text.MessageFormat;
   
  import org.eclipse.core.resources.IFile;
  import org.eclipse.core.resources.IResource;
  import org.eclipse.core.resources.ResourcesPlugin;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IPath;
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.core.runtime.Path;
  import org.eclipse.core.variables.VariablesPlugin;
  import org.eclipse.debug.core.ILaunch;
  import org.eclipse.debug.core.ILaunchConfiguration;
  import org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate;
  import org.eclipse.jdt.launching.IVMInstall;
  import org.eclipse.jdt.launching.IVMRunner;
  import org.eclipse.jdt.launching.VMRunnerConfiguration;
  
  /***
   * <p>Standard Eclipse Launch Configuration Delegate class, that's installed by
   * the plugin.</p>
   * <p>Since Jelly is a Java application, the launch process for Jelly is simply the
   * launch of a Java application. Therefore the launch configuration for Jelly contains
   * all attributes, a Java application has in the Eclipse workbench. The only additional
   * attributes are the Jelly script file path and the output file path of the Jelly script.
   * </p>
   * @author Jürgen Mayrbäurl
   * @since 0.9
   * @see JellyLaunchConfigurationConstants
   */
  public class JellyLaunchConfigurationDelegate extends 
  					AbstractJavaLaunchConfigurationDelegate
  {
  	// INTERFACE IMPLEMENTATION
  	
  	/* (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 
  	{
  		// Get and verfiy installed virtual machine
  		IVMInstall vm = verifyVMInstall(configuration);
  		IVMRunner runner = vm.getVMRunner(mode);
  		
  		// Setup the VM Runner configuration by getting the attributes from the configuration
  		VMRunnerConfiguration runConfig = new VMRunnerConfiguration(
  				JellyLauncherPlugin.getResourceString("jelly.launchMainClass"),
  				this.getClasspath(configuration));
  
  		// Get the program arguments as string from the configuration
  		String argsString = this.getProgramArguments(configuration);
  		
  		// Get the file path of the Jelly script file from the configuration
  		String scriptFilePath = this.getScriptFile(configuration).getAbsolutePath();
  
  		// Get the optional file path for the output file of the Jelly script
  		String outConfig = null;
  		File outputFile = this.getOutputFile(configuration);
  		if(outputFile != null) outConfig = outputFile.getAbsolutePath();
  		
  		// Setup the program arguments for Jelly, depending on the configuration setup
  		if( (argsString != null) || (outConfig != null))
  		{
  			if(argsString == null)
  			{
  				// No extra program arguments specified
  				runConfig.setProgramArguments(new String[] {
  						JellyLauncherPlugin.getResourceString("jelly.cmdLine.arg.script"),
  						"\"" + scriptFilePath + "\"",
  						JellyLauncherPlugin.getResourceString("jelly.cmdLine.arg.output"), 
  						"\"" + outConfig + "\"" });
  			} else {
  				// Extra program arguments must be appended
  				runConfig.setProgramArguments(new String[] {
  						JellyLauncherPlugin.getResourceString("jelly.cmdLine.arg.script"),
  						"\"" + scriptFilePath + "\"",
  						JellyLauncherPlugin.getResourceString("jelly.cmdLine.arg.output"), 
  						"\"" + outConfig + "\"",
  						argsString });
  			}
  		} else {
  			// Simple call Jelly with the Script file path
  			runConfig.setProgramArguments(new String[] {scriptFilePath});
  		}
  		
  		// Setup the runtime classpathes
  		getClasspath(configuration);
  		String [] bootpath = getBootpath(configuration);
  		runConfig.setBootClassPath(bootpath);
  		
  		// Get the working directory
  		runConfig.setWorkingDirectory(this.getWorkingDirectory(configuration).getAbsolutePath());
 		
 		// And finally run it
 		runner.run(runConfig, launch, monitor);
 	}
 	
 	// IMPLEMENTATION
 	
 	/***
 	 * Gets and verifies the file path of the Jelly script file from the launch configuration
 	 * @param configuration Eclipse launch configuration object
 	 * @return Jelly script file
 	 * @throws CoreException from Eclipse platform
 	 * @see verifyScriptFile
 	 */
 	public File getScriptFile(ILaunchConfiguration configuration) throws CoreException 
 	{
 		// Get path from configuration and verify it
 		return verifyScriptFile(configuration);
 	}
 	
 	/***
 	 * Gets and verifies the file path of the output file of the Jelly script from the launch configuration
 	 * @param configuration Eclipse launch configuration object
 	 * @return output file for the Jelly script
 	 * @throws CoreException from Eclipse platform
 	 * @see verifyOutputFile
 	 */
 	public File getOutputFile(ILaunchConfiguration configuration) throws CoreException 
 	{
 		// Get path from configuration and verify it
 		return verifyOutputFile(configuration);
 	}
 
 	/***
 	 * Reads the file path of the Jelly script from the launch configuration and 
 	 * verifies that the path exists and is the path of a file. If no Jelly script
 	 * file is specified in the launch configuration or if the script file doesn't
 	 * exist, aborts the launching process.
 	 * @param configuration Eclipse launch configuration object
 	 * @return Jelly script file
 	 * @throws CoreException from Eclipse platform
 	 */
 	protected File verifyScriptFile(ILaunchConfiguration configuration)
 			throws CoreException 
 	{
 		// Get the Eclipse path of the Jelly script file
 		IPath path = getScriptFilePath(configuration);
 		
 		// If we can't get the path to the Jelly script file, simply abort launching
 		// with an appropriate error message
 		if (path == null) {
 			abort(MessageFormat.format(JellyLauncherPlugin.getResourceString("jelly.launch.messages.noscriptfile"), null),
 					null,JellyLaunchConfigurationConstants.ERR_SCRIPT_FILE_NOT_SPECIFIED); 
 		} else {
 			if (path.isAbsolute()) {
 				File scriptfile = new File(path.toOSString());
 				if (scriptfile.isFile()) {
 					return scriptfile;
 				}
 				// This may be a workspace relative path returned by a variable.
 				// However variable paths start with a slash and thus are
 				// thought to
 				// be absolute
 				IResource res = ResourcesPlugin.getWorkspace().getRoot()
 						.findMember(path);
 				if (res instanceof IFile && res.exists()) {
 					return res.getLocation().toFile();
 				}
 				abort(MessageFormat.format(JellyLauncherPlugin.getResourceString("jelly.launch.messages.scriptFileDoesntExist"), new String[] { path.toString() }),
 						null,JellyLaunchConfigurationConstants.ERR_SCRIPT_FILE_DOES_NOT_EXIST); 
 			} else {
 				IResource res = ResourcesPlugin.getWorkspace().getRoot()
 						.findMember(path);
 				if (res instanceof IFile && res.exists()) {
 					return res.getLocation().toFile();
 				}
 				abort(MessageFormat.format(JellyLauncherPlugin.getResourceString("jelly.launch.messages.scriptFileDoesntExist"), new String[] { path.toString() }),
 						null,JellyLaunchConfigurationConstants.ERR_SCRIPT_FILE_DOES_NOT_EXIST); 
 			}
 		}
 		return null;
 	}
 	
 	/***
 	 * Reads the file path of the output file of the Jelly script from the launch configuration and
 	 * verifies that the path exists and is the path of a file
 	 * @param configuration Eclipse launch configuration object
 	 * @return output file of the Jelly script
 	 * @throws CoreException from Eclipse platform
 	 */
 	protected File verifyOutputFile(ILaunchConfiguration configuration)
 		throws CoreException 
 	{
 		// Get the file path of the output file of the launch configuration
 		IPath path = getOutputFilePath(configuration);
 		
 		// Simply stop, if there's no output file (since it's optional)
 		if (path == null) {
 			return null;
 		} else {
 			if (path.isAbsolute()) {
 				File outputfile = new File(path.toOSString());
 				if (outputfile.isFile()) {
 					return outputfile;
 				}
 				// This may be a workspace relative path returned by a variable.
 				// However variable paths start with a slash and thus are
 				// thought to
 				// be absolute
 				IResource res = ResourcesPlugin.getWorkspace().getRoot()
 						.findMember(path);
 				if (res instanceof IFile && res.exists()) {
 					return res.getLocation().toFile();
 				}
 			} else {
 				IResource res = ResourcesPlugin.getWorkspace().getRoot()
 						.findMember(path);
 				if (res instanceof IFile && res.exists()) {
 					return res.getLocation().toFile();
 				}
 			}
 		}
 		return null;
 	}
 	
 	/***
 	 * Returns the path of the Jelly script file in the Eclipse workspace
 	 * @param configuration Eclipse launch configuration object
 	 * @return Eclipse <code>IPath</code> path object for the Jelly script file in the workspace
 	 * @throws CoreException from Eclipse platform
 	 */
 	public IPath getScriptFilePath(ILaunchConfiguration configuration)
 			throws CoreException 
 	{
 		// Get the script file path from the launch configuration
 		String path = configuration.getAttribute(
 				JellyLaunchConfigurationConstants.ATTR_JELLYSCRIPT_PATH,
 				(String) null);
 		
 		// If the file path string contains variables, they must be resolved
 		if (path != null) {
 			path = VariablesPlugin.getDefault().getStringVariableManager()
 					.performStringSubstitution(path);
 			return new Path(path);
 		}
 		return null;
 	}
 
 	/***
 	 * Returns the path of the output file of the Jelly script in the Eclipse workspace
 	 * @param configuration Eclipse launch configuration object
 	 * @return Eclipse <code>IPath</code> path object for the output file of the Jelly script in the workspace
 	 * @throws CoreException from Eclipse platform
 	 */
 	public IPath getOutputFilePath(ILaunchConfiguration configuration)
 			throws CoreException 
 	{
 		// Get the output file path from the launch configuration
 		String path = configuration.getAttribute(
 				JellyLaunchConfigurationConstants.ATTR_OUTPUT_PATH,
 				(String) null);
 		
 		// If the file path string contains variables, they must be resolved
 		if (path != null) {
 			path = VariablesPlugin.getDefault().getStringVariableManager()
 					.performStringSubstitution(path);
 			return new Path(path);
 		}
 		return null;
 	}
 }