package com.erggroup.mass.ant;

import java.io.File;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Copy;
import org.apache.tools.ant.taskdefs.Echo;
import org.apache.tools.ant.taskdefs.Mkdir;
import org.apache.tools.ant.types.FileSet;

public class ReleaseElement implements JatsElement
{
	public static final String TASK_NAME = "release";

	private Project project;

	/**
	 * The version, used if type='force'
	 */
	private String version;

	/**
	 * Specifies the type of release (default=force; all other types are deprecated).
	 */
	private String type = "force";
	
	/**
	 * Specifies the label used when building this release (optional)
	 */
    private String label;

	/**
	 * 
	 */
	private PackageVersion releaseVersion = null;


	private Jats parent;

	public ReleaseElement()
	{
	}

	public String getElementType()
	{
		return TASK_NAME;
	}

	public void setType(String type)
	{
		this.type = type;
	}

	public void setVersion(String value)
	{
		this.version = value;
	}
	
	public void setLabel( String value )
	{
		this.label = value;
	}

	public void execute(Jats parent)
	{
		this.parent  = parent;
		this.project = parent.getProject();

		if ( "force".equalsIgnoreCase(type) )
		{
			if ( version == null ) 
			{
				throw new BuildException("Release 'version' attribute is mandatory."); 
			}
			releaseVersion = new PackageVersion(version);
		}
		else
		{
			throw new BuildException("Release type can only be 'force'; all other types are deprecated.");
		}

		updateDescpkgFile();

		releasePackage();
	}

	private void updateDescpkgFile()
	{
		StringBuffer buffer = new StringBuffer();

		buffer.append("Package Name: ")
		      .append(parent.getPackage());
		buffer.append("\nVersion:      ")
			  .append(releaseVersion.toString());
		buffer.append("\nReleased By:  ")
			  .append(project.replaceProperties("${user.name}"));
		buffer.append("\nReleased On:  ")
			  .append(new Date());
		
		// Build label (if specified)			
		if ( label != null )
		{
			buffer.append("\nLabel:        ")
				  .append(project.replaceProperties(label));
		}
		
		// Path to source of build (vob-relative)
		File baseDirectory = project.getBaseDir();
		String buildPath = baseDirectory.getAbsolutePath();
		int cpos = buildPath.indexOf(":");
		if ( cpos > -1 )
		{
			buildPath = buildPath.substring(cpos+1);
		}
		buffer.append("\nPath:         ").append(buildPath);

		buffer.append("\n\nBuild Dependencies:\n");
		Collection sandbox = SandboxElement.getSandboxElements();
		for (Iterator i = sandbox.iterator() ; i.hasNext() ; )
		{
			SandboxElement element = (SandboxElement)i.next();
			if ( ! element.isRuntime() )
			buffer.append("\n<sandbox name=\"")
				  .append(element.getName())
				  .append("\" version=\"")
				  .append(element.getVersion())
				  .append("\"/>");
		}

		Echo echo = new Echo();
		echo.setTaskName(TASK_NAME);
		echo.setProject(project);
		String descpkgFilename = project.replaceProperties("${basedir}") + "/pkg/descpkg";
		echo.setFile(new File(descpkgFilename));

		echo.setMessage(buffer.toString());
		echo.execute();
	}

	/**
	 * Attempts to copy the 'pkg' files into dpkg_archive.
	 */
	private void releasePackage()
	{
		String packageName = parent.getPackage();
		String version = releaseVersion.toString();

		// Check for the existance of the package directory in dpkg_archive, and if
		// it exists, then throw an exception.
		File dpkgArchivePackageDir = validatePackageDirectory(packageName);

		File dpkgArchiveVersionDir = validatePackageVersionDirectory(dpkgArchivePackageDir, version);

		// Copy the files from the pkg directory into
		// dpkg_archive/${jats.package.name}/${major}.${minor}.${patch}.${project}
		Copy copy = new Copy();
		copy.setProject(project);
		copy.setTaskName(this.getElementType());
		copy.setTodir(dpkgArchiveVersionDir);

		File basedir = new File(project.replaceProperties("${basedir}"));
		File pkgdir = new File(basedir, "pkg");

		FileSet fileSet = new FileSet();
		fileSet.setDir(pkgdir);
		fileSet.setIncludes("**/*");
		copy.addFileset(fileSet);
		copy.perform();
	}

	/**
	 *
	 * @param directoryName
	 * @return
	 */
	private File validatePackageDirectory(String directoryName)
	{
		File dir = new File(parent.getFromdir(), directoryName);

		if (dir.exists() == false)
		{
			makeDirectory(dir);
		}

		if (dir.isDirectory() == false)
		{
			throw new BuildException(dir.toString() + " is not a directory.");
		}

		return dir;
	}

	/**
	 *
	 * @param fromdir
	 * @param directoryName
	 * @return
	 */
	private File validatePackageVersionDirectory(File fromdir, String directoryName)
	{
		File dir = new File(fromdir, directoryName);

		if (dir.exists() == false)
		{
			makeDirectory(dir);
		}
		else
		{
			String packageName = parent.getPackage();
			throw new BuildException("Cannot release package \'"
									 + packageName + "\' version \'"
									 + releaseVersion + "\' as it has already been released.");
		}

		return dir;
	}

	/**
	 *
	 * @param dir
	 */
	private void makeDirectory(File dir)
	{
		Mkdir mkdir = new Mkdir();
		mkdir.setProject(this.project);
		mkdir.setTaskName(this.getElementType());

		mkdir.setDir(dir);

		mkdir.perform();
	}
}