package net.sf.jpkgmk;
   
   import java.io.File;
   import java.io.IOException;
   
   import net.sf.jpkgmk.pkgmap.PkgMapBuilder;
   import net.sf.jpkgmk.prototype.Prototype;
   import net.sf.jpkgmk.prototype.PrototypeParser;
   import net.sf.jpkgmk.util.FileUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * <p>
   * Pure java implementation of the <code>pkgmk</code> command. Should be a 1:1 port so that it can be used as a drop-in replacement.
   * For the code that was ported see:
   * <a href="http://cvs.opensolaris.org/source/xref/caiman/slim_source/usr/src/cmd/pkgcmds/pkgmk">pkgmk of opensolaris</a> and
   * <a href="http://prdownloads.sourceforge.net/pkgbuild/">pkgbuild on sourceforge</a>
   * </p>
   * 
   * <p>
   * This implementation should be useful if you want to create your solaris packages regardless on which platform
   * you are currently developing. Additionally it has the advantage that it can be used with maven/ant without the need of native platform calls.
   * </p>
   * 
   * <p>
   * The original solaris package providing this functionality has the name <code>SUNWpkgcmdsu</code>.
   * </p>
   * <p>
   * Some further docs about packaging can be found at
   * <a href="http://www.ibiblio.org/pub/packages/solaris/sparc/html/creating.solaris.packages.html">creating solaris packages</a>
   * and <a href="http://blogs.sun.com/thaniwa/page/SolarisEn">solaris pkgmk tools</a>
   * </p>
   * 
   * @author gommma (gommma AT users.sourceforge.net)
   * @author Last changed by: $Author: gommma $
   * @version $Revision: 2 $ $Date: 2008-08-20 21:14:19 +0200 (Mi, 20 Aug 2008) $
   * @since 1.0
   */
  public class PkgMk
  {
  
  	private Log log = LogFactory.getLog(PkgMk.class);
  	
  	/**
  	 * flag to use GZIP command. Is set to <code>true</code> by default.
  	 */ 
  	private boolean gzip = true;
  	
  	private PkgInfo packageInfo;
  	private Prototype prototype;
  
  	private File baseSourceDir;
  	private File baseTargetDir;
  	private String targetFileName;
  	private boolean overwriteIfExists=true;
  
  	/**
  	 * The result file of the package creation
  	 */
  	private File gzipFile;
  	
  	
  	/**
  	 * @param baseSourceDir The base source directory for searching all required packaging files
  	 */
  	public PkgMk(File baseSourceDir)
  	{
  		this(baseSourceDir, null, null, null, null);
  	}
  
  	/**
  	 * @param baseSourceDir The base source directory for searching all required packaging files
  	 * @param baseTargetDir The base directory in which the whole new package should be created. Can be null
  	 */
  	public PkgMk(File baseSourceDir, File baseTargetDir)
  	{
  		this(baseSourceDir, baseTargetDir, null, null, null);
  	}
  
  	/**
  	 * @param baseSourceDir The base source directory for searching all required packaging files
  	 * @param baseTargetDir The base directory in which the whole new package should be created. Can be null
  	 * @param packageInfo The pkginfo object. Can be null if the file exists in the given source dir
       * @param prototype The prototype object. Can be null if the file exists in the given source dir
  	 */
  	public PkgMk(File baseSourceDir, File baseTargetDir, PkgInfo packageInfo, Prototype prototype)
  	{
  		this(baseSourceDir, baseTargetDir, null, packageInfo, prototype);
  	}
  	
  	/**
  	 * @param baseSourceDir The base source directory for searching all required packaging files
  	 * @param baseTargetDir The base directory in which the whole new package should be created. Can be null
  	 * @param targetFileName The name to be used for the created tar.gz file. Can be null
  	 * @param packageInfo The pkginfo object. Can be null if the file exists in the given source directory
       * @param prototype The prototype object. Can be null if the file exists in the given source directory
  	 */
 	public PkgMk(File baseSourceDir, File baseTargetDir, String targetFileName, PkgInfo packageInfo, Prototype prototype)
 	{
 		super();
 
 		this.baseSourceDir = baseSourceDir;
 		
 		if(packageInfo == null) {
 			this.packageInfo = resolvePackageInfo(this.baseSourceDir);
 		}
 		else {
 			this.packageInfo = packageInfo;
 		}
 
 		if(targetFileName == null) {
 			this.targetFileName = autoCreatePackageFilename(this.packageInfo);			
 		}
 		else {
 			this.targetFileName = targetFileName;
 		}
 		
 		if(prototype == null) {
 			this.prototype = resolvePrototype(this.baseSourceDir);
 		}
 		else {
 			this.prototype = prototype;
 		}
 		
 		if(baseTargetDir == null) {
 			this.baseTargetDir = new File(System.getProperty("java.io.tmpdir"), this.packageInfo.getPkg());
 			log.info("No target directory specified. Defaulting to "+ this.baseTargetDir);
 		}
 		else {
 			if(baseTargetDir.exists()) {
 				throw new IllegalArgumentException("The given target directory already exists - please specify a non existing target directory. " + baseTargetDir);
 			}
 			this.baseTargetDir = baseTargetDir;
 		}
 		
 		String packageName = this.packageInfo.getPkg();
 		File pkgFile = new File(packageName);
 		if(pkgFile.exists()) {
 			throw new IllegalArgumentException("The file or directory " + pkgFile.getAbsolutePath() + " already exists. Operation terminated...");
 		}
 
 		// Validate this object
 		validate();
 	}
 
 	private void validate() {
 		if(this.prototype == null) {
 			throw new IllegalStateException("No prototype found - please define a prototype file");
 		}
 		if(this.packageInfo == null) {
 			throw new IllegalStateException("No pkginfo found - please define a pkginfo file");
 		}
 		if(this.baseSourceDir == null) {
 			throw new IllegalStateException("The field 'baseSourceDir' is not set");
 		}
 		if(this.baseTargetDir == null) {
 			throw new IllegalStateException("The field 'baseTargetDir' is not set");
 		}
 		
 	}
 
 
 	private PkgInfo resolvePackageInfo(File basedir) {
         // Search prototype file in baseSourceDir
         File pkgInfoFile = findPkgInfo(basedir);
 		try {
 			PkgInfo packageInfo = new PkgInfoParser().parse(pkgInfoFile);
 			return packageInfo;
 		} catch (IOException e) {
 			throw new PackageException("Exception while reading pkginfo file '" + pkgInfoFile + "'", e);
 		}
 	}
 
 	private Prototype resolvePrototype(File basedir) {
 		// Search prototype file in baseSourceDir
 		File prototypeFile = findPrototype(basedir);
 		try {
 			Prototype proto = new PrototypeParser().parse(prototypeFile);
 			return proto;
 		} catch (IOException e) {
 			throw new PackageException("Exception while reading prototype file '" + prototypeFile + "'", e);
 		}
 	}
 
 	private File findPrototype(File basedir2) {
 		File prototype = new File(basedir2, "prototype");
 		File prototype2 = new File(basedir2, "Prototype");
 		if(prototype.isFile()) {
 			return prototype;
 		}
 		else if(prototype2.isFile()){
 			return prototype2;
 		}
 		else {
 			return null;
 		}
 	}
 	
 	private File findPkgInfo(File basedir2) 
 	{
 		File pkginfo = new File(basedir2, "pkginfo");
 		File pkginfo2 = new File(basedir2, "Pkginfo");
 		if(pkginfo.isFile()) {
 			return pkginfo;
 		}
 		else if(pkginfo2.isFile()){
 			return pkginfo2;
 		}
 		else {
 		    throw new PackageException("Did not find pkginfo file in directory " + basedir2);
 		}
 	}
 
 
 	private static String autoCreatePackageFilename(PkgInfo packageInfo) 
 	{
 		if(packageInfo == null) {
 			throw new NullPointerException("The parameter 'packageInfo' must not be null");
 		}
 		return packageInfo.generateFilename();
 	}
 
 
 	/**
 	 * @return The pkginfo object of the created package
 	 */
 	public PkgInfo getPackageInfo() {
 		return packageInfo;
 	}
 
 	/**
 	 * @return The prototype object that was used for creating the package
 	 */
 	Prototype getPrototype() {
 		return prototype;
 	}
 
 	
 	public boolean isOverwriteIfExists() {
 		return overwriteIfExists;
 	}
 
 	/**
 	 * Whether or not to overwrite the files in the target directory if this directory already exists
 	 * @param overwriteIfExists
 	 */
 	public void setOverwriteIfExists(boolean overwriteIfExists) {
 		this.overwriteIfExists = overwriteIfExists;
 	}
 
 	public File getGzipFile()
 	{
 		return this.gzipFile;
 	}
 	
 
 	/**
 	 * Creates the whole package
 	 * @throws IOException
 	 */
 	public void create() throws IOException
 	{
 		clean();
 		
 		// At first create the baseSourceDir if it does not exist yet
 		FileUtil.createDir(this.baseTargetDir, true);
 
 		//create a "pkginfo" file
 		this.packageInfo.create(this.baseTargetDir);
 		
 		// Create the pkgMap builder from the Prototype	
 		PkgMapBuilder pkgMapBuilder = new PkgMapBuilder(this.baseTargetDir, this.prototype);
 		//create "pkgmap" file
 		pkgMapBuilder.create();
 
 		// gzip
 		if(this.gzip) {
 			File tarFile = new File(this.baseTargetDir, this.targetFileName + ".tar");
 			FileUtil.createTar(this.baseTargetDir, tarFile);
 			this.gzipFile = FileUtil.createGzip(tarFile);
 		}
 
 		log.info("done - package created in directory '" + this.baseTargetDir + "': archive file: " + gzipFile);
 	}
 
 	private void clean() 
 	{
 		int fileCount = FileUtil.countFiles(this.baseTargetDir);
 		if(fileCount > 0) {
 			if(!overwriteIfExists) {
 				throw new PackageException("Will not overwrite the existing target directory '" + this.baseTargetDir + "'. Aborting package creation");
 			}
 			else {
 				// Remove all files and directories
 				log.info("Deleting directory '" + this.baseTargetDir + "' before creating the new package...");
 				FileUtil.deleteRecursively(this.baseTargetDir);
 			}
 		}
 	}
 
 	/**
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		StringBuffer sb = new StringBuffer();
 		sb.append(getClass().getName()).append("[");
 		sb.append("baseSourceDir=").append(this.baseSourceDir);
 		sb.append(", baseTargetDir=").append(this.baseTargetDir);
 		sb.append(", targetFileName=").append(this.targetFileName);
 		sb.append(", gzipFile=").append(this.gzipFile);
 		sb.append(", overwriteIfExists=").append(this.overwriteIfExists);
 		sb.append(", gzip=").append(this.gzip);
 		sb.append(", packageInfo=").append(this.packageInfo);
 		sb.append(", prototype=").append(this.prototype);
 		sb.append("]");
 		return sb.toString();
 	}
 	
 	
 	
 	// TODO UnitTest complete creation of a complex package
 	
 	
 	/**
 	 * Entry point for the application
 	 * @param args
 	 */
 	public static void main(String[] args)
 	{
 		Log log = LogFactory.getLog(PkgMk.class);
 		try {
 			// Current working directory is used as rootDir
 			File workingDir = new File(System.getProperty("user.dir"));
 			log.info("Current work dir: " + workingDir.getAbsolutePath());
 			
 			PkgMk pkgmk = new PkgMk(workingDir);
 			pkgmk.create();
 			
  			System.exit(0);
 			
 		} catch (IOException e) {
 			log.error("Exception while creating package: " + e, e);
 			System.exit(1);
 		}
 	}
 
 	
 //	########################################################################
 //	# usage
 //	########################################################################
 //	private static void printUsage()
 //	{
 //		StringBuffer sb = new StringBuffer();
 //		sb.append("Usage of $0");
 //		sb.append("> $0 output [-g] [-user <username>] [-group <group>]");
 //		sb.append( "             -p <pkg> -n <name> -v <version> -a <arch> [-c <category>]");
 //		sb.append("            [-b <baseSourceDir>] [-d <description>] [-vd <vendor>] [-o <flag>...]");
 //		sb.append( "  output             : output file name");
 //		sb.append( "  [Details of Option]");
 //		sb.append( "  -g                 : create gzipped package");
 //		sb.append( "  -p  <pkg>          : package name (ex. SUMWgcc)");
 //		sb.append( "  -n  <name>         : application name (ex. gcc)");
 //		sb.append( "  -v  <version>      : application version (ex. 4.2.0)");
 //		sb.append( "  -a  <arch>         : architecture, i86pc,sum4u...");
 //		sb.append( "  -c  <category>     : category of the application (ex. system, application, GNOME2)");
 //		sb.append( "                       (default = appilcation)");
 //		sb.append( "  -b  <baseSourceDir>      : base directory of the application (default = /)");
 //		sb.append( "  -d  <description>  : package description");
 //		sb.append( "  -vd <vendor>       : vendor name (default = unknown)");
 //		sb.append( "  -o  <flag>         : if you want to add other flags, please use it");
 //		sb.append( "                       (ex. -o \"SUMW_PRODNAME=SumOS\" -o \"SUMW_PRODVERS=5.10\"");
 //		System.out.println(sb.toString());
 //	}
 
 
 }