/*
    * Created on 10.12.2004 by Juergen Mayrbaeurl
    *
    */
   package org.apache.commons.jelly.eclipse.ui;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URL;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Vector;
  import java.util.jar.JarFile;
  
  import org.eclipse.core.resources.IFile;
  import org.eclipse.core.resources.IProject;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IPath;
  import org.eclipse.core.runtime.Path;
  import org.eclipse.core.runtime.Platform;
  import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
  import org.eclipse.jdt.core.IJavaProject;
  import org.eclipse.jdt.core.JavaCore;
  import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
  import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
  import org.eclipse.jdt.launching.JavaRuntime;
  import org.osgi.framework.Bundle;
  
  /***
   * Utility class with static methods for launch support of Jelly
   * @author Juergen Mayrbaeurl
   * @since 0.9
   */
  public class JellyLaunchUtils 
  {
  	/***
  	 * Tries to find the libary folder of the base Jelly Plugin (org.apache.jelly)
  	 * and returns the absolute path to the library
  	 * @return the absolute path to the library directory of the base Jelly Plugin, can be null if not found
  	 */
  	static public String getJellyPlugInLibDir()
  	{
  		String result = null;
  		
  		// Get the plugin
  		Bundle baseBundle = Platform.getBundle(
  				JellyLauncherPlugin.getResourceString("jelly.basePlugInName"));
  		
  		// If the base Jelly PlugIn is installed, continue
  		if( baseBundle != null)
  		{
  			// Get the URL of the library directory of the base Jelly PlugIn
  			URL libURL = baseBundle.getEntry(JellyLauncherPlugin.
  									getResourceString("jelly.basePlugInLibPath"));
  			if(libURL != null)
  			{
  				String libDirFilename = null;
  				try {
  					libDirFilename = Platform.resolve(libURL).getFile();
  				} catch (IOException e) {
  					e.printStackTrace();
  					return null;
  				}
  				
  				// Finally check, if the found path is a directory
  				if(libDirFilename != null)
  				{
  					File libDir = new File(libDirFilename);
  					if( (libDir != null) && libDir.isDirectory())
  					{
  						result = libDirFilename;
  					}
  				}
  			}
  		}
  
  		return result;
  	}
  	
  	/***
  	 * Tries to find the Jelly jar library in the library directory of the base
  	 * Jelly PlugIn and returns the absolute path to the jar library file
  	 * @return absolute path to the jar file, that contains the main class of Jelly (may be null)
  	 */
  	static public String getJellyPlugInLibMainClassJar()
  	{
  		String result = null;
  		
  		// First get the libary directory of the base Jelly PlugIn
  		String libDirFilename = JellyLaunchUtils.getJellyPlugInLibDir();
  		if(libDirFilename != null)
  		{
  			File libdir = new File(libDirFilename);
  			File[] jellyLibs = libdir.listFiles();
  			if(jellyLibs != null)
  			{
  				// Iterate over the entries in the library directory
  				for(int i = 0; i < jellyLibs.length; i++)
 				{
 					// Only files, no directories and deep searches
 					if(jellyLibs[i].isFile() && jellyLibs[i].getName().endsWith(".jar"))
 					{
 						JarFile aJar = null;
 						
 						try {
 							aJar = new JarFile(jellyLibs[i]);
 						} catch (IOException e) {
 							e.printStackTrace();
 							// No jar file or no access, just skip it
 							continue;
 						}
 						
 						// if the jar library contains the 'Jelly' class, we're done
 						if( (aJar != null) && 
 								(aJar.getJarEntry("org/apache/commons/jelly/Jelly.class")!= null))
 						{
 							result = jellyLibs[i].getAbsolutePath();
 							break;
 						}
 					}
 				}
 			}
 		}
 		
 		return result;
 	}
 	
 	/***
 	 * Returns the list of jar libraries, currently installed in the library directory
 	 * of the base Jelly PlugIn
 	 * @return the list of Jelly libraries (all tag libraries and the jelly main library)
 	 */
 	static public List getJellyPlugInLibs()
 	{
 		Vector resultVector = new Vector();
 		
 		String libDirFilename = getJellyPlugInLibDir();
 		if(libDirFilename != null)
 		{
 			File libdir = new File(libDirFilename);
 			File[] jellyLibs = libdir.listFiles();
 			if(jellyLibs != null)
 			{
 				for(int i = 0; i < jellyLibs.length; i++)
 				{
 					if(jellyLibs[i].isFile() && jellyLibs[i].getName().endsWith(".jar"))
 					{
 						JarFile aJar = null;
 						
 						try {
 							aJar = new JarFile(jellyLibs[i]);
 						} catch (IOException e) {
 							// Simple skip in the case of an exception
 							continue;
 						}
 						
 						if(aJar != null)
 							resultVector.add(jellyLibs[i].getAbsolutePath());
 					}
 				}
 			}
 		}
 		
 		return resultVector;
 	}
 	
 	/***
 	 * Sets the defaults of the launch configuration by initalizing the classpath 
 	 * (including jar libraries of the base Jelly plugin) and setting the working
 	 * directory to the <code>scriptFile</code> eclipse project
 	 * @param config the working copy of the launch configuration, must not be null
 	 * @param scriptFile the Jelly script file, may be null
 	 */
 	public static void setDefaults(ILaunchConfigurationWorkingCopy config, 
 				IFile scriptFile) throws CoreException
 	{
 //		 Don't do anything, if have no launch configuration object
 		if(config == null)
 			return;
 		
 		// Initialize the classpath
 		JellyLaunchUtils.initializeClasspath(config, scriptFile);
 		
 		// Get the jar library file of the main class
 		JellyLaunchUtils.initializeJellyInstallpath(config, scriptFile);
 		
 		// Initialize the working directory
 		JellyLaunchUtils.initializeWorkingDir(config, scriptFile);
 	}
 	
 
 	/***
 	 * Initializes the runtime classpath by adding all jar libraries of the library
 	 * directory of the base Jelly PlugIn, the default JRE, the working directory and
 	 * the class path entries of the project of the <code>scriptFile</code> (if not null)
 	 * @param config working copy of the launch configuration
 	 * @param scriptFile Jelly script file as member of a project
 	 * @throws CoreException if no Java Runtime can't be found
 	 */
 	public static void initializeClasspath(ILaunchConfigurationWorkingCopy config, 
 											IFile scriptFile) throws CoreException
 	{
 		// Don't do anything, if have no launch configuration object
 		if(config == null)
 			return; 
 		
 		// First get the list of libraries of the base Jelly PlugIn libary directory
 		List libs = JellyLaunchUtils.getJellyPlugInLibs();
 		if( (libs != null) && (libs.size() > 0))
 		{
 			List classpath = new ArrayList();
 			Iterator iter = libs.iterator();
 			
 			// Add the base JellyPlugIn libraries to the classpath as user classes
 			while(iter.hasNext())
 			{
 				IRuntimeClasspathEntry libEntry = 
 					JavaRuntime.newArchiveRuntimeClasspathEntry(new Path((String)iter.next()));
 				libEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES);
 				try {
 					classpath.add(libEntry.getMemento());
 				} catch (CoreException e) {
 					// If the runtime classpath entry can't be added, just skip it
 					continue;
 				}
 			}
 			
 			// Next add the JRE libraries to the classpath
 			IRuntimeClasspathEntry stdLibs = JavaRuntime.newRuntimeContainerClasspathEntry(
 												new Path(JavaRuntime.JRE_CONTAINER),
 												IRuntimeClasspathEntry.STANDARD_CLASSES);
 			classpath.add(stdLibs.getMemento());
 						
 			// If we're doing this for a Jelly script file (as member of a project),
 			// add the class path entries of the owning project
 			if(JellyLauncherPlugin.getDefault().isDoAddProjectClassPathEntries())
 			{
 				if(scriptFile != null)
 					addUserClassPathOfProject(scriptFile.getProject(), classpath);
 				else
 					addUserClassPathOfProject(null, classpath);
 			}
 			
 			// Set the attributes in the launch configuration
 			config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, classpath);
 			config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, false);
 		}
 	}
 	
 	/***
 	 * Initializes the attribute in the launch configuration, that stores the absolute
 	 * path to the Jelly runtime jar library
 	 * @param config working copy of the launch configuration
 	 * @param scriptFile Jelly script file (as project member)
 	 */
 	protected static void initializeJellyInstallpath(ILaunchConfigurationWorkingCopy config
 														, IFile scriptFile)
 	{
 		// Don't do anything, if have no launch configuration object
 		if(config != null)
 		{
 			String mainJar = JellyLaunchUtils.getJellyPlugInLibMainClassJar();
 			if(mainJar != null)
 				config.setAttribute(JellyLaunchConfigurationConstants.ATTR_JELLYINSTALL_PATH, mainJar);		
 			else
 				config.setAttribute(JellyLaunchConfigurationConstants.ATTR_JELLYINSTALL_PATH, "");		
 		}
 	}
 
 	/***
 	 * Initalizes the working directory setup in the launch configuration, by setting
 	 * the working directory to the project's working directory the <code>scriptFile</code>
 	 * belongs to
 	 * @param config working copy of the launch configuration
 	 * @param scriptFile Jelly script file (as project member)
 	 */
 	public static void initializeWorkingDir(ILaunchConfigurationWorkingCopy config
 			, IFile scriptFile)
 	{
 		// Don't do anything, if have no launch configuration object or script File
 		if( (scriptFile == null) || (config == null) )
 			return;
 		
 		// if the scriptFile doesn't belong to a project, don't continue
 		IProject scriptsProject = scriptFile.getProject();
 		if(scriptsProject == null)
 			return;
 		
 		// Set the working directory in the launch configuration attribute
 		String workDirPath = scriptsProject.getLocation().toString();
 		if(workDirPath != null)
 			config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY,
 										workDirPath);
 	}
 	
 	/***
 	 * Returns the full path of the project, the <code>aFile</code> is owned
 	 * @param aFile a file owned by a project
 	 * @return the <code>IPath</code> object of the project (can be null)
 	 */
 	public static IPath getFilesProjectPath(IFile aFile)
 	{
 		if(aFile == null)
 			return null;
 		
 		IProject theProj = aFile.getProject();
 		if(theProj != null)
 			return theProj.getFullPath();
 		else
 			return null;
 	}
 	
 	/***
 	 * Adds the user class path entries of a Java project or the working directory
 	 * of a non Java project to the list of class path entries, stored in <code> classPathEntryList</code>
 	 * @param theProject the project
 	 * @param classPathEntryList the list of class path entries
 	 */
 	public static void addUserClassPathOfProject(IProject theProject, 
 														List classPathEntryList)
 	{
 		// If we don't have a collection for the class path entries or a project,
 		// don't do anything
 		if( (classPathEntryList == null) || (theProject == null) )
 			return;
 		
 		// Check, if the 'theProject' is a Java project
 		IJavaProject javaProject = JavaCore.create(theProject);
 		if(javaProject == null)
 		{
 			// It's not a Java project. Simply add the working directory of the project
 			IPath workDirPath = theProject.getFullPath();
 			if(workDirPath != null)
 			{
 				IRuntimeClasspathEntry stdLibs = JavaRuntime.newArchiveRuntimeClasspathEntry(workDirPath);
 				try {
 					classPathEntryList.add(stdLibs.getMemento());
 				} catch (CoreException e) {
 					// However, we can't add the working directory of the owning project
 				}
 			}
 		} else {
 			// It's a Java project. Add all runtime class path entries of the Java project
 			try {
 				IRuntimeClasspathEntry[] entries = JavaRuntime.computeUnresolvedRuntimeClasspath(javaProject);
 				if( (entries != null) && (entries.length > 0))
 				{
 					for(int i = 0; i < entries.length; i++)
 					{
 						// Only add the user class path entries of the Java project
 						if(entries[i].getClasspathProperty() == 
 									IRuntimeClasspathEntry.USER_CLASSES)
 						{
 							try {
 								IRuntimeClasspathEntry[] resolvedEntries = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], javaProject);
 								if(resolvedEntries != null)
 								{
 									for(int j = 0; j < resolvedEntries.length; j++)
 									{
 										classPathEntryList.add(resolvedEntries[j].getMemento());
 									}
 								}
 							} catch (CoreException e1) {
 								continue;
 							}
 						}
 					}
 				}
 			} catch (CoreException e) {
 				// However
 			}
 		}
 	}
 }