/******************************************************************************
 * Copyright (c) 2006, 2010 VMware Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution. 
 * The Eclipse Public License is available at 
 * http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
 * is available at http://www.opensource.org/licenses/apache2.0.php.
 * You may elect to redistribute this code under either of these licenses. 
 * 
 * Contributors:
 *   VMware Inc.
 *****************************************************************************/

package org.eclipse.gemini.blueprint.test.internal.util.jar;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.jar.Manifest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.test.internal.util.jar.storage.MemoryStorage;
import org.eclipse.gemini.blueprint.test.internal.util.jar.storage.Storage;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.util.StringUtils;

/**
 * Helper class for creating Jar files. Note that this class is stateful and the
 * same instance should not be reused.
 * 
 * @author Costin Leau
 * 
 */
public class JarCreator {

	private static final Log log = LogFactory.getLog(JarCreator.class);

	public static final String EVERYTHING_PATTERN = "/**/*";

	private static final String CLASS_EXT = ".class";

	private String[] contentPattern = new String[] { EVERYTHING_PATTERN };

	private ResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();

	private Storage storage = new MemoryStorage();

	private String rootPath = determineRootPath();

	private boolean addFolders = true;

	/** collection of packages contained by this jar */
	private Collection containedPackages = new TreeSet();


	/**
	 * Resources' root path (the root path does not become part of the jar).
	 * 
	 * @return the root path
	 */
	public String determineRootPath() {
		return Thread.currentThread().getContextClassLoader().getResource(".").toString();
	}

	/**
	 * Actual jar creation.
	 * 
	 * @param manifest to use
	 * @param entries array of resource to include in the jar
	 * @return the number of bytes written to the underlying stream.
	 * 
	 * @throws IOException
	 */
	protected int addJarContent(Manifest manifest, Map entries) throws IOException {
		// load manifest
		// add it to the jar
		if (log.isTraceEnabled()) {
			if (manifest != null)
				log.trace("Adding MANIFEST.MF [" + manifest.getMainAttributes().entrySet() + "]");
			log.trace("Adding entries:");
			Set key = entries.keySet();
			for (Iterator iter = key.iterator(); iter.hasNext();) {
				log.trace(iter.next());
			}
		}

		return JarUtils.createJar(manifest, entries, storage.getOutputStream());
	}

	/**
	 * Create a jar using the current settings and return a {@link Resource}
	 * pointing to the jar.
	 * 
	 * @param manifest
	 */
	public Resource createJar(Manifest manifest) {
		return createJar(manifest, resolveContent());
	}

	/**
	 * Create a jar using the current settings and return a {@link Resource}
	 * pointing to the jar.
	 * 
	 * @param manifest
	 */
	public Resource createJar(Manifest manifest, Map content) {
		try {
			addJarContent(manifest, content);
			return storage.getResource();
		}
		catch (IOException ex) {
			throw (RuntimeException) new IllegalStateException("Cannot create jar").initCause(ex);
		}
	}

	/**
	 * Small utility method used for determining the file name by striping the
	 * root path from the file full path.
	 * 
	 * @param rootPath
	 * @param resource
	 * @return
	 */
	private String determineRelativeName(String rootPath, Resource resource) {
		try {
			String path = StringUtils.cleanPath(resource.getURL().getPath());
			return path.substring(path.indexOf(rootPath) + rootPath.length());
		}
		catch (IOException ex) {
			throw (RuntimeException) new IllegalArgumentException("illegal resource " + resource.toString()).initCause(ex);
		}
	}

	/**
	 * Transform the pattern and rootpath into actual resources.
	 * 
	 * @return
	 * @throws Exception
	 */
	private Resource[][] resolveResources() {
		ResourcePatternResolver resolver = getPatternResolver();

		String[] patterns = getContentPattern();
		Resource[][] resources = new Resource[patterns.length][];

		// transform Strings into Resources
		for (int i = 0; i < patterns.length; i++) {
			StringBuilder buffer = new StringBuilder(rootPath);

			// do checking on lost slashes
			if (!rootPath.endsWith(JarUtils.SLASH) && !patterns[i].startsWith(JarUtils.SLASH))
				buffer.append(JarUtils.SLASH);

			buffer.append(patterns[i]);
			try {
				resources[i] = resolver.getResources(buffer.toString());
			}
			catch (IOException ex) {
				IllegalStateException re = new IllegalStateException("cannot resolve pattern " + buffer.toString());
				re.initCause(ex);
				throw re;
			}
		}

		return resources;
	}

	/**
	 * Resolve the jar content based on its path. Will return a map containing
	 * the entries relative to the jar root path as keys and Spring Resource
	 * pointing to the actual resources as values. It will also determine the
	 * packages contained by this package.
	 * 
	 * @return
	 */
	public Map resolveContent() {
		Resource[][] resources = resolveResources();

		URL rootURL;
		String rootP = getRootPath();
		try {
			rootURL = new URL(rootP);
		}
		catch (MalformedURLException ex) {
			throw (RuntimeException) new IllegalArgumentException("illegal root path given " + rootP).initCause(ex);
		}
		String rootPath = StringUtils.cleanPath(rootURL.getPath());

		// remove duplicates
		Map entries = new TreeMap();
		// save contained bundle packages
		containedPackages.clear();

		// empty stream used for folders
		Resource folderResource = new ByteArrayResource(new byte[0]);

		// add folder entries also
		for (int i = 0; i < resources.length; i++) {
			for (int j = 0; j < resources[i].length; j++) {
				String relativeName = determineRelativeName(rootPath, resources[i][j]);
				// be consistent when adding resources to jar
				if (!relativeName.startsWith("/"))
					relativeName = "/" + relativeName;
				entries.put(relativeName, resources[i][j]);

				// look for class entries
				if (relativeName.endsWith(CLASS_EXT)) {

					// determine package (exclude first char)
					String clazzName = relativeName.substring(1, relativeName.length() - CLASS_EXT.length()).replace(
						'/', '.');
					// remove class name
					int index = clazzName.lastIndexOf('.');
					if (index > 0)
						clazzName = clazzName.substring(0, index);
					// add it to the collection
					containedPackages.add(clazzName);
				}

				String token = relativeName;
				// get folder and walk up to the root
				if (addFolders) {
					// add META-INF
					entries.put("/META-INF/", folderResource);
					int slashIndex;
					// stop at root folder
					while ((slashIndex = token.lastIndexOf('/')) > 1) {
						// add the folder with trailing /
						entries.put(token.substring(0, slashIndex + 1), folderResource);
						// walk the tree
						token = token.substring(0, slashIndex);
					}
					// add root folder
					//entries.put("/", folderResource);
				}
			}
		}

		if (log.isTraceEnabled())
			log.trace("The following packages were discovered in the bundle: " + containedPackages);

		return entries;
	}

	public Collection getContainedPackages() {
		return containedPackages;
	}

	/**
	 * @return Returns the contentPattern.
	 */
	public String[] getContentPattern() {
		return contentPattern;
	}

	/**
	 * Pattern for content matching. Note that using {@link #EVERYTHING_PATTERN}
	 * can become problematic on windows due to file system locking.
	 * 
	 * @param contentPattern The contentPattern to set.
	 */
	public void setContentPattern(String[] contentPattern) {
		this.contentPattern = contentPattern;
	}

	/**
	 * @return Returns the patternResolver.
	 */
	public ResourcePatternResolver getPatternResolver() {
		return patternResolver;
	}

	/**
	 * @param patternResolver The patternResolver to set.
	 */
	public void setPatternResolver(ResourcePatternResolver patternResolver) {
		this.patternResolver = patternResolver;
	}

	/**
	 * @return Returns the jarStorage.
	 */
	public Storage getStorage() {
		return storage;
	}

	/**
	 * @param jarStorage The jarStorage to set.
	 */
	public void setStorage(Storage jarStorage) {
		this.storage = jarStorage;
	}

	/**
	 * @param
	 */
	public String getRootPath() {
		return rootPath;
	}

	/**
	 * @param rootPath The rootPath to set.
	 */
	public void setRootPath(String rootPath) {
		this.rootPath = rootPath;
	}

	/**
	 * @return Returns the addFolders.
	 */
	public boolean isAddFolders() {
		return addFolders;
	}

	/**
	 * Whether the folders in which the files reside, should be added to the
	 * archive. Default is true since otherwise, the archive will contains only
	 * files and no folders.
	 * 
	 * @param addFolders The addFolders to set.
	 */
	public void setAddFolders(boolean addFolders) {
		this.addFolders = addFolders;
	}
}