/*
    * $HeadURL: https://mindtreeinsight.svn.sourceforge.net/svnroot/mindtreeinsight/releng/maven-jsmooth-plugin/trunk/src/main/java/com/mindtree/techworks/insight/releng/mvn/jsmooth/JSmoothCompileMojo.java $
    * 
    * Copyright (c) 2007 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight  Release Engineering Tools.
    * 
    * Insight  Release Engineering Tools is free software: you can redistribute it 
    * and/or modify it under the terms of the GNU General Public License as 
   * published by the Free Software Foundation, either version 3 of the License, 
   * or (at your option) any later version.
   * 
   * Insight  Release Engineering Tools is distributed in the hope that it will be 
   * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight  Release Engineering Tools. If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight.releng.mvn.jsmooth;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.security.CodeSource;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.zip.ZipFile;
  
  import net.charabia.jsmoothgen.application.ExeCompiler;
  import net.charabia.jsmoothgen.application.JSmoothModelBean;
  import net.charabia.jsmoothgen.application.JSmoothModelPersistency;
  import net.charabia.jsmoothgen.skeleton.SkeletonBean;
  import net.charabia.jsmoothgen.skeleton.SkeletonList;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectHelper;
  
  /**
   * This is the entry class for the maven plugin to compile a Jsmooth file.
   * 
   * <br/> The following tasks are accomplished in order:
   * <ol>
   * <li>Create a temporary folder under 'target'</li>
   * <li>Copy the jsmooth file to the target folder</li>
   * <li>Apply any filters required to the .jsmooth file</li>
   * <li>Call Jsmooth's {@link ExeCompiler}</li>
   * </ol>
   * 
   * @see AbstractMojo
   * 
   * @author <a href="mailto:bindul_bhowmik@mindtree.com">Bindul Bhowmik</a>
   * @version $Revision: 171 $ $Date: 2008-04-17 02:16:43 -0600 (Thu, 17 Apr 2008) $
   * 
   * @goal jsmoothcompile
   * @requiresDependencyResolution test
   * @requiresDependencyResolution compile
   * @requiresDependencyResolution runtime
   * @description Compiles the Jsmooth executable for the project
   */
  public class JSmoothCompileMojo extends AbstractMojo {
  
  	/**
  	 * Flag to allow one or more executions of the build to skip the compile
  	 * 
  	 * @parameter default-value="false"
  	 */
  	private boolean skipJSmooth;
  
  	/**
  	 * The relative location of the jsmooth file
  	 * 
  	 * @parameter
  	 * @required
  	 */
  	private String jsmoothFile;
  
  	/**
  	 * The location of the icon file
  	 * 
  	 * @parameter
  	 */
  	private String iconLocation;
  
  	/**
  	 * Flag to indicate if the exe name generated in the build process is to be
  	 * replaced in the jsmooth file
  	 * 
  	 * @parameter default-value="false"
  	 */
 	private boolean setExeName;
 
 	/**
 	 * Flag to indicate if the jar name generated in the build process is to be
 	 * replaced in the jsmooth file
 	 * 
 	 * @parameter default-value="true"
 	 */
 	private boolean setJarName;
 
 	/**
 	 * If dependencies are to be set from a base directory, the name of the base
 	 * directory
 	 * 
 	 * @parameter
 	 */
 	private String dependencyBaseDir;
 
 	/**
 	 * Flag to indicate if dependencies are to be included
 	 * 
 	 * @parameter default-value="true"
 	 */
 	private boolean includeDependencies;
 
 	/**
 	 * The optional parameter to indicate the scope of dependencies to include.
 	 * The allowed values are runtime, compile and test.
 	 * 
 	 * @parameter default-value="runtime"
 	 */
 	private String dependencyScope;
 
 	/**
 	 * The maven project we are working in
 	 * 
 	 * @parameter default-value="${project}"
 	 * @required
 	 * @readonly
 	 */
 	private MavenProject project;
 	
 	/**
      * Maven ProjectHelper.
      *
      * @component
      */
     private MavenProjectHelper projectHelper;
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.apache.maven.plugin.Mojo#execute()
 	 */
 	public void execute() throws MojoExecutionException, MojoFailureException {
 		if (skipJSmooth) {
 			getLog()
 					.info(
 							"Skipping JSmooth Compile, as skipJSmooth flag is set to false");
 		}
 
 		// Resolve the Jsmooth file path
 		File jSmthFile = resolveFile(jsmoothFile);
 		getLog().info("Using jsmooth file... " + jSmthFile.getAbsolutePath());
 
 		// Load the jsmooth file
 		JSmoothModelBean jsmoothModel = null;
 		try {
 			jsmoothModel = JSmoothModelPersistency.load(jSmthFile);
 		} catch (IOException e) {
 			getLog().error("IOException while reading jsmooth file", e);
 			throw new MojoFailureException(this,
 					"IOException reading jsmooth file", e.getMessage());
 		}
 
 		// Modify stuff
 		manipulateModelFile(jsmoothModel);
 
 		// Create the temporary directory
 		File jsmoothTmpDir = createTemporaryDirectory();
 
 		// Write the modified jsmooth file for debugging
 		writeJsmoothFile(jsmoothTmpDir, jsmoothModel);
 
 		// Write out the skeletons
 		File skeletonDir = writeSkeletons(jsmoothTmpDir);
 
 		// Compile stuff
 		File compiledFile = compileJSmooth(skeletonDir, jsmoothModel);
 		
 		projectHelper.attachArtifact(project, "exe", compiledFile);
 	}
 
 	private File compileJSmooth(File skeletonRoot, JSmoothModelBean model) throws MojoExecutionException {
 		try {
 			SkeletonList skelList = new SkeletonList(skeletonRoot);
 
 			File out = new File(project.getBuild().getDirectory(), model
 					.getExecutableName());
 			SkeletonBean skel = skelList.getSkeleton(model.getSkeletonName());
 			File skelroot = skelList.getDirectory(skel);
 
 			final ExeCompiler compiler = new ExeCompiler();
 			compiler.addListener(new ExeCompiler.StepListener() {
 
 				public void complete() {
 					getLog().info("JSmooth generation complete");
 				}
 
 				public void failed() {
 					getLog().error("JSmooth generation failed");
 				}
 
 				public void setNewState(int percentComplete, String state) {
 
 					getLog().debug(
 							"jsmooth: " + state + " ( " + percentComplete
 									+ "%)");
 				}
 			});
 
 			if (compiler.compile(skelroot, skel, new File(project.getBuild()
 					.getDirectory()), model, out)) {
 				getLog().info(
 						"Java application wrapped in "
 								+ model.getExecutableName());
 			} else {
 				getLog().error("jsmoothgen failed: " + compiler.getErrors());
 				throw new MojoExecutionException(this, "jsmoothgen failed: ", compiler.getErrors().toString());
 			}
 			
 			return out;
 		} catch (MojoExecutionException exc) {
 			throw exc;
 		} catch (Exception exc) {
 			throw new MojoExecutionException(this, "Error building the jsmooth wrapper", exc.getMessage());
 		}
 
 	}
 
 	/**
 	 * Writes the jsmooth skeletons to the specified directory
 	 * 
 	 * @param jsmoothTmpDir
 	 *            The temporary directory under which to create the skeletons
 	 *            directory
 	 * @return The file reference to the skeleton directory
 	 * @throws MojoFailureException
 	 *             If there is a failure is extracting the skeletons
 	 * @throws MojoExecutionException
 	 *             Error copying skeleton directory
 	 */
 	private File writeSkeletons(File jsmoothTmpDir)
 			throws MojoFailureException, MojoExecutionException {
 		// Get the code source and get to the jar file
 		CodeSource cs = getClass().getProtectionDomain().getCodeSource();
 		if (null == cs) {
 			// Can't proceed
 			throw new MojoFailureException(
 					"Unable to determine the source of this jar and hence cannot extract skeletons");
 		}
 		URL baseUrl = cs.getLocation();
 		getLog().debug("Determined code source location: " + baseUrl.toExternalForm());
 		File destinationDir = new File(jsmoothTmpDir + File.separator
 				+ "skeletons");
 		try {
 			// Determine the File object. This has been modified from the 
 			// previous implementation to handle illegal characters in URLs.
 			File basePath = null;
 			try {
 				basePath = new File(baseUrl.toURI());
 			} catch (URISyntaxException e) {
 				getLog().debug("Failed the URI method.. faling back to path");
 				basePath = new File(baseUrl.getPath());
 			}
 			getLog().debug(
 					"Attempting extraction from" + basePath.getAbsolutePath());
 
 			// Check extraction from zip
 			if (basePath.getAbsolutePath().endsWith(".jar")
 					|| basePath.getAbsolutePath().endsWith(".zip")) {
 				ZipFile sourceFile = new ZipFile(basePath);
 				FileUtils.extractZipDirectories(sourceFile, destinationDir,
 						"skeletons", true, getLog());
 			} else {
 				File skeletonDir = new File(basePath.getAbsolutePath()
 						+ File.separator + "skeletons");
 				if (skeletonDir.exists()) {
 					FileUtils.copyDirectory(skeletonDir, destinationDir);
 				} else {
 					throw new MojoFailureException(
 							"Unable to determine the source of this jar and hence cannot extract skeletons");
 				}
 			}
 		} catch (IOException e) {
 			// Error copying file
 			throw new MojoExecutionException(this,
 					"Error copying skeleton files", e.getMessage());
 		}
 		return destinationDir;
 	}
 
 	/**
 	 * Writes the jsmooth file to the specified directory
 	 * 
 	 * @param jsmoothTmpDir
 	 *            The directory to which to write to
 	 * @param jsmoothModel
 	 *            The model to write
 	 */
 	private void writeJsmoothFile(File jsmoothTmpDir,
 			JSmoothModelBean jsmoothModel) {
 		File tmpFileNm = new File(jsmoothFile);
 		String tempJSmoothFileName = jsmoothTmpDir.getAbsolutePath()
 				+ File.separator + tmpFileNm.getName();
 		try {
 			JSmoothModelPersistency.save(new File(tempJSmoothFileName),
 					jsmoothModel);
 		} catch (IOException e) {
 			getLog().warn("IOException writing jsmooth file", e);
 			// This is not a fatal error
 		}
 	}
 
 	/**
 	 * Creates the temporary directory for use
 	 * 
 	 * @return The file reference to the temporary directory
 	 * @throws MojoExecutionException
 	 *             If the temporary directory cannot be written
 	 */
 	private File createTemporaryDirectory() throws MojoExecutionException {
 		String jsmoothTmpDirPath = project.getBuild().getDirectory()
 				+ File.separator + "jsmooth-temp";
 		File jsmoothTmpDir = new File(jsmoothTmpDirPath);
 		if (!jsmoothTmpDir.exists()) {
 			if (!jsmoothTmpDir.mkdir()) {
 				throw new MojoExecutionException(
 						"Cannot create temporary directory");
 			}
 		}
 
 		return jsmoothTmpDir;
 	}
 
 	/**
 	 * Modifies the parametes of the jsmooth model file
 	 * 
 	 * @param jsmoothModel
 	 *            The jsmooth model
 	 * @throws MojoExecutionException
 	 *             If the required file cannot be used.
 	 */
 	private void manipulateModelFile(JSmoothModelBean jsmoothModel)
 			throws MojoExecutionException {
 
 		// Set the icon location
 		if (null != iconLocation && iconLocation.trim().length() > 0) {
 			File iconFileLoc = resolveFile(iconLocation);
 			getLog().info(
 					"Setting Icon location to : "
 							+ iconFileLoc.getAbsolutePath());
 			jsmoothModel.setIconLocation(iconFileLoc.getAbsolutePath());
 		}
 
 		String finalBuildName = project.getBuild().getFinalName();
 
 		if (setExeName) {
 			getLog().info(
 					"Setting final output name to :" + finalBuildName + ".exe");
 			jsmoothModel.setExecutableName(finalBuildName + ".exe");
 		}
 
 		if (setJarName) {
 			// Set the jar file name
 			getLog().info("Setting jar name to :" + finalBuildName + ".jar");
 			jsmoothModel.setJarLocation(finalBuildName + ".jar");
 		}
 
 		if (includeDependencies) {
 			getLog().debug(
 					"Including dependencies with base scope: "
 							+ dependencyScope);
 			List impliedScopes = getImpliedScopes(dependencyScope);
 			Set dependencyArtifacts = project.getArtifacts();
 			ArrayList dependentArtifacts = new ArrayList(dependencyArtifacts
 					.size());
 
 			String baseDir = "";
 			if (null != dependencyBaseDir) {
 				baseDir = dependencyBaseDir.trim();
 				if (!baseDir.endsWith("/") || !baseDir.endsWith(File.separator)) {
 					baseDir = baseDir + File.separator;
 				}
 			}
 
 			for (Iterator dependencyItr = dependencyArtifacts.iterator(); dependencyItr
 					.hasNext();) {
 				Artifact dependencyArtifact = (Artifact) dependencyItr.next();
 				if (impliedScopes.contains(dependencyArtifact.getScope())) {
 					getLog().debug(
 							"Including dependency: "
 									+ dependencyArtifact.getId());
 					String dependencyPath = baseDir
 							+ dependencyArtifact.getFile().getName();
 					getLog().debug("Inluding dependency as: " + dependencyPath);
 					dependentArtifacts.add(dependencyPath);
 				}
 			}
 
 			if (!dependentArtifacts.isEmpty()) {
 				String[] existingClasspath = jsmoothModel.getClassPath();
 				if (null != existingClasspath && existingClasspath.length > 0) {
 					Collections.addAll(dependentArtifacts, existingClasspath);
 				}
 
 				jsmoothModel.setClassPath((String[]) dependentArtifacts
 						.toArray(new String[dependentArtifacts.size()]));
 			}
 		}
 	}
 
 	/**
 	 * Gets the list of implied scopes for a a given scope. The scope tree used
 	 * for this resolution is:
 	 * <ol>
 	 * <li>compile</li>
 	 * <li>runtime</li>
 	 * <li>test</li>
 	 * </ol>
 	 * 
 	 * @param scope
 	 * @return
 	 */
 	private List getImpliedScopes(String scope) {
 		List resolvedScopeList = new ArrayList();
 
 		if (Artifact.SCOPE_COMPILE.equals(scope)) {
 			resolvedScopeList.add(Artifact.SCOPE_COMPILE);
 		} else if (Artifact.SCOPE_RUNTIME.equals(scope)) {
 			resolvedScopeList.add(Artifact.SCOPE_COMPILE);
 			resolvedScopeList.add(Artifact.SCOPE_RUNTIME);
 		} else if (Artifact.SCOPE_TEST.equals(scope)) {
 			resolvedScopeList.add(Artifact.SCOPE_COMPILE);
 			resolvedScopeList.add(Artifact.SCOPE_RUNTIME);
 			resolvedScopeList.add(Artifact.SCOPE_TEST);
 		}
 
 		return resolvedScopeList;
 	}
 
 	/**
 	 * Gets the Jsmooth file being used. This method assumes the file indicated
 	 * by jsmoothfile is an absolute file, and then tries to resolve it as a
 	 * relative path to the project base directory.
 	 * 
 	 * @return The file location of the jsmooth file
 	 * @throws MojoExecutionException
 	 *             If the file is not found.
 	 */
 	private File resolveFile(String path) throws MojoExecutionException {
 
 		getLog().debug("Resolving path: " + path);
 
 		// Check for empty value
 		if (null == path || path.trim().length() == 0) {
 			throw new MojoExecutionException("The path location is required.");
 		}
 
 		// Assume absolute file location
 		File fileLoc = new File(path);
 		if (fileLoc.exists() && fileLoc.canRead() && fileLoc.isFile()) {
 			return fileLoc;
 		}
 
 		// If we are here, then the file must be relative
 		File baseDir = project.getBasedir();
 		getLog().debug(
 				"Using base directory path : " + baseDir.getAbsolutePath());
 		String finalFilePath = baseDir.getAbsolutePath() + File.separatorChar
 				+ path;
 		getLog().debug("Computed file path : " + finalFilePath);
 		fileLoc = new File(finalFilePath);
 		if (fileLoc.exists() && fileLoc.canRead() && fileLoc.isFile()) {
 			return fileLoc;
 		}
 
 		// If we are here, then the file does not exist at all!
 		throw new MojoExecutionException("The file specified [" + path
 				+ "] either does not exist, or cannot be resolved "
 				+ "or cannot be read.");
 	}
 
 	/**
 	 * @return the skipJSmooth
 	 */
 	public boolean isSkipJSmooth() {
 		return skipJSmooth;
 	}
 
 	/**
 	 * @param skipJSmooth
 	 *            the skipJSmooth to set
 	 */
 	public void setSkipJSmooth(boolean skipJSmooth) {
 		this.skipJSmooth = skipJSmooth;
 	}
 
 	/**
 	 * @return the jsmoothFile
 	 */
 	public String getJsmoothFile() {
 		return jsmoothFile;
 	}
 
 	/**
 	 * @param jsmoothFile
 	 *            the jsmoothFile to set
 	 */
 	public void setJsmoothFile(String jsmoothFile) {
 		this.jsmoothFile = jsmoothFile;
 	}
 
 	/**
 	 * @return the project
 	 */
 	public MavenProject getProject() {
 		return project;
 	}
 
 	/**
 	 * @return the iconLocation
 	 */
 	public String getIconLocation() {
 		return iconLocation;
 	}
 
 	/**
 	 * @param iconLocation
 	 *            the iconLocation to set
 	 */
 	public void setIconLocation(String iconLocation) {
 		this.iconLocation = iconLocation;
 	}
 
 	/**
 	 * @return the setExeName
 	 */
 	public boolean isSetExeName() {
 		return setExeName;
 	}
 
 	/**
 	 * @param setExeName
 	 *            the setExeName to set
 	 */
 	public void setSetExeName(boolean setExeName) {
 		this.setExeName = setExeName;
 	}
 
 	/**
 	 * @return the setJarName
 	 */
 	public boolean isSetJarName() {
 		return setJarName;
 	}
 
 	/**
 	 * @param setJarName
 	 *            the setJarName to set
 	 */
 	public void setSetJarName(boolean setJarName) {
 		this.setJarName = setJarName;
 	}
 
 	/**
 	 * @return the includeDependencies
 	 */
 	public boolean isIncludeDependencies() {
 		return includeDependencies;
 	}
 
 	/**
 	 * @param includeDependencies
 	 *            the includeDependencies to set
 	 */
 	public void setIncludeDependencies(boolean includeDependencies) {
 		this.includeDependencies = includeDependencies;
 	}
 
 	/**
 	 * @return the dependencyBaseDir
 	 */
 	public String getDependencyBaseDir() {
 		return dependencyBaseDir;
 	}
 
 	/**
 	 * @param dependencyBaseDir
 	 *            the dependencyBaseDir to set
 	 */
 	public void setDependencyBaseDir(String dependencyBaseDir) {
 		this.dependencyBaseDir = dependencyBaseDir;
 	}
 
 	/**
 	 * @return the dependencyScope
 	 */
 	public String getDependencyScope() {
 		return dependencyScope;
 	}
 
 	/**
 	 * @param dependencyScope
 	 *            the dependencyScope to set
 	 */
 	public void setDependencyScope(String dependencyScope) {
 		this.dependencyScope = dependencyScope;
 	}
 
 }