package org.argeo.slc.repo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;

import javax.jcr.Binary;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
import org.argeo.slc.SlcTypes;
import org.osgi.framework.Constants;
import org.osgi.framework.Version;

/**
 * Indexes jar file, currently supports standard J2SE and OSGi metadata (both
 * from MANIFEST)
 */
public class JarFileIndexer implements NodeIndexer, SlcNames {
	private final static CmsLog log = CmsLog.getLog(JarFileIndexer.class);
	private Boolean force = false;

	public Boolean support(String path) {
		return FilenameUtils.getExtension(path).equals("jar");
	}

	public void index(Node fileNode) {
		Binary fileBinary = null;
		JarInputStream jarIn = null;
		ByteArrayOutputStream bo = null;
		ByteArrayInputStream bi = null;
		Binary manifestBinary = null;
		try {
			if (!support(fileNode.getPath()))
				return;

			// Already indexed
			if (!force && fileNode.isNodeType(SlcTypes.SLC_JAR_FILE))
				return;

			if (!fileNode.isNodeType(NodeType.NT_FILE))
				return;

			Session jcrSession = fileNode.getSession();
			Node contentNode = fileNode.getNode(Node.JCR_CONTENT);
			fileBinary = contentNode.getProperty(Property.JCR_DATA).getBinary();

			jarIn = new JarInputStream(fileBinary.getStream());
			Manifest manifest = jarIn.getManifest();
			if (manifest == null) {
				log.error(fileNode + " has no MANIFEST");
				return;
			}

			bo = new ByteArrayOutputStream();
			manifest.write(bo);
			byte[] newManifest = bo.toByteArray();
			if (fileNode.hasProperty(SLC_MANIFEST)) {
				byte[] storedManifest = JcrUtils.getBinaryAsBytes(fileNode.getProperty(SLC_MANIFEST));
				if (Arrays.equals(newManifest, storedManifest)) {
					if (log.isTraceEnabled())
						log.trace("Manifest not changed, doing nothing " + fileNode);
					return;
				}
			}

			bi = new ByteArrayInputStream(newManifest);
			manifestBinary = jcrSession.getValueFactory().createBinary(bi);

			// standard jar file
			fileNode.addMixin(SlcTypes.SLC_JAR_FILE);

			fileNode.setProperty(SlcNames.SLC_MANIFEST, manifestBinary);
			Attributes attrs = manifest.getMainAttributes();

			getI18nValues(fileBinary, attrs);

			// standard J2SE MANIFEST attributes
			addAttr(Attributes.Name.MANIFEST_VERSION, fileNode, attrs);
			addAttr(Attributes.Name.SIGNATURE_VERSION, fileNode, attrs);
			addAttr(Attributes.Name.CLASS_PATH, fileNode, attrs);
			addAttr(Attributes.Name.MAIN_CLASS, fileNode, attrs);
			addAttr(Attributes.Name.EXTENSION_NAME, fileNode, attrs);
			addAttr(Attributes.Name.IMPLEMENTATION_VERSION, fileNode, attrs);
			addAttr(Attributes.Name.IMPLEMENTATION_VENDOR, fileNode, attrs);
			addAttr(Attributes.Name.IMPLEMENTATION_VENDOR_ID, fileNode, attrs);
			addAttr(Attributes.Name.SPECIFICATION_TITLE, fileNode, attrs);
			addAttr(Attributes.Name.SPECIFICATION_VERSION, fileNode, attrs);
			addAttr(Attributes.Name.SPECIFICATION_VENDOR, fileNode, attrs);
			addAttr(Attributes.Name.SEALED, fileNode, attrs);

			// OSGi
			if (attrs.containsKey(new Name(Constants.BUNDLE_SYMBOLICNAME))) {
				addOsgiMetadata(fileNode, attrs);
				if (log.isTraceEnabled())
					log.trace("Indexed OSGi bundle " + fileNode);
			} else {
				if (log.isTraceEnabled())
					log.trace("Indexed JAR file " + fileNode);
			}

			JcrUtils.updateLastModified(fileNode);

		} catch (Exception e) {
			throw new SlcException("Cannot index jar " + fileNode, e);
		} finally {
			IOUtils.closeQuietly(bi);
			IOUtils.closeQuietly(bo);
			IOUtils.closeQuietly(jarIn);
			JcrUtils.closeQuietly(manifestBinary);
			JcrUtils.closeQuietly(fileBinary);
		}

	}

	private void getI18nValues(Binary fileBinary, Attributes attrs) throws IOException {
		JarInputStream jarIn = null;
		try {
			jarIn = new JarInputStream(fileBinary.getStream());
			String bundleLocalization = null;

			String blKey = Constants.BUNDLE_LOCALIZATION; // "Bundle-Localization";
			Name blkName = new Name(blKey);

			browse: for (Object obj : attrs.keySet()) {
				String value = attrs.getValue((Attributes.Name) obj);
				if (value.startsWith("%")) {
					if (attrs.containsKey(blkName)) {
						bundleLocalization = attrs.getValue(blkName);
						break browse;
					}
				}
			}

			JarEntry jarEntry = null;
			byte[] propBytes = null;
			ByteArrayOutputStream baos = null;
			browse: if (bundleLocalization != null) {
				JarEntry entry = jarIn.getNextJarEntry();
				while (entry != null) {
					if (entry.getName().equals(bundleLocalization + ".properties")) {
						jarEntry = entry;

						// if(je.getSize() != -1){
						// propBytes = new byte[(int)je.getSize()];
						// int len = (int) je.getSize();
						// int offset = 0;
						// while (offset != len)
						// offset += jarIn.read(propBytes, offset, len -
						// offset);
						// } else {
						baos = new ByteArrayOutputStream();
						while (true) {
							int qwe = jarIn.read();
							if (qwe == -1)
								break;
							baos.write(qwe);
						}
						propBytes = baos.toByteArray();
						break browse;
					}
					entry = jarIn.getNextJarEntry();
				}
			}

			if (jarEntry != null) {
				Properties prop = new Properties();
				InputStream is = new ByteArrayInputStream(propBytes);
				prop.load(is);

				for (Object obj : attrs.keySet()) {
					String value = attrs.getValue((Attributes.Name) obj);
					if (value.startsWith("%")) {
						String newVal = prop.getProperty(value.substring(1));
						if (newVal != null)
							attrs.put(obj, newVal);
					}
				}
			}
		} catch (RepositoryException e) {
			throw new SlcException("Error while reading the jar binary content " + fileBinary, e);
		} catch (IOException ioe) {
			throw new SlcException("unable to get internationalized values", ioe);
		} finally {
			IOUtils.closeQuietly(jarIn);
		}
	}

	protected void addOsgiMetadata(Node fileNode, Attributes attrs) throws RepositoryException {

		// TODO remove this ?
		// Compulsory for the time being, because bundle artifact extends
		// artifact
		if (!fileNode.isNodeType(SlcTypes.SLC_ARTIFACT)) {
			ArtifactIndexer indexer = new ArtifactIndexer();
			indexer.index(fileNode);
		}

		fileNode.addMixin(SlcTypes.SLC_BUNDLE_ARTIFACT);

		// symbolic name
		String symbolicName = attrs.getValue(Constants.BUNDLE_SYMBOLICNAME);
		// make sure there is no directive
		symbolicName = symbolicName.split(";")[0];
		fileNode.setProperty(SlcNames.SLC_SYMBOLIC_NAME, symbolicName);

		// direct mapping
		addAttr(Constants.BUNDLE_SYMBOLICNAME, fileNode, attrs);
		addAttr(Constants.BUNDLE_NAME, fileNode, attrs);
		addAttr(Constants.BUNDLE_DESCRIPTION, fileNode, attrs);
		addAttr(Constants.BUNDLE_MANIFESTVERSION, fileNode, attrs);
		addAttr(Constants.BUNDLE_CATEGORY, fileNode, attrs);
		addAttr(Constants.BUNDLE_ACTIVATIONPOLICY, fileNode, attrs);
		addAttr(Constants.BUNDLE_COPYRIGHT, fileNode, attrs);
		addAttr(Constants.BUNDLE_VENDOR, fileNode, attrs);
		addAttr("Bundle-License", fileNode, attrs);
		addAttr(Constants.BUNDLE_DOCURL, fileNode, attrs);
		addAttr(Constants.BUNDLE_CONTACTADDRESS, fileNode, attrs);
		addAttr(Constants.BUNDLE_ACTIVATOR, fileNode, attrs);
		addAttr(Constants.BUNDLE_UPDATELOCATION, fileNode, attrs);
		addAttr(Constants.BUNDLE_LOCALIZATION, fileNode, attrs);

		// required execution environment
		if (attrs.containsKey(new Name(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT)))
			fileNode.setProperty(SlcNames.SLC_ + Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT,
					attrs.getValue(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT).split(","));

		// bundle classpath
		if (attrs.containsKey(new Name(Constants.BUNDLE_CLASSPATH)))
			fileNode.setProperty(SlcNames.SLC_ + Constants.BUNDLE_CLASSPATH,
					attrs.getValue(Constants.BUNDLE_CLASSPATH).split(","));

		// version
		Version version = new Version(attrs.getValue(Constants.BUNDLE_VERSION));
		fileNode.setProperty(SlcNames.SLC_BUNDLE_VERSION, version.toString());
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.BUNDLE_VERSION);
		Node bundleVersionNode = fileNode.addNode(SlcNames.SLC_ + Constants.BUNDLE_VERSION, SlcTypes.SLC_OSGI_VERSION);
		mapOsgiVersion(version, bundleVersionNode);

		// fragment
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.FRAGMENT_HOST);
		if (attrs.containsKey(new Name(Constants.FRAGMENT_HOST))) {
			String fragmentHost = attrs.getValue(Constants.FRAGMENT_HOST);
			String[] tokens = fragmentHost.split(";");
			Node node = fileNode.addNode(SlcNames.SLC_ + Constants.FRAGMENT_HOST, SlcTypes.SLC_FRAGMENT_HOST);
			node.setProperty(SlcNames.SLC_SYMBOLIC_NAME, tokens[0]);
			for (int i = 1; i < tokens.length; i++) {
				if (tokens[i].startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
					node.setProperty(SlcNames.SLC_BUNDLE_VERSION, attributeValue(tokens[i]));
				}
			}
		}

		// imported packages
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.IMPORT_PACKAGE);
		if (attrs.containsKey(new Name(Constants.IMPORT_PACKAGE))) {
			String importPackages = attrs.getValue(Constants.IMPORT_PACKAGE);
			List<String> packages = parseCommaSeparated(importPackages);
			for (String pkg : packages) {
				String[] tokens = pkg.split(";");
				Node node = fileNode.addNode(SlcNames.SLC_ + Constants.IMPORT_PACKAGE, SlcTypes.SLC_IMPORTED_PACKAGE);
				node.setProperty(SlcNames.SLC_NAME, tokens[0]);
				for (int i = 1; i < tokens.length; i++) {
					if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
						node.setProperty(SlcNames.SLC_VERSION, attributeValue(tokens[i]));
					} else if (tokens[i].startsWith(Constants.RESOLUTION_DIRECTIVE)) {
						node.setProperty(SlcNames.SLC_OPTIONAL,
								directiveValue(tokens[i]).equals(Constants.RESOLUTION_OPTIONAL));
					}
				}
			}
		}

		// dynamic import package
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.DYNAMICIMPORT_PACKAGE);
		if (attrs.containsKey(new Name(Constants.DYNAMICIMPORT_PACKAGE))) {
			String importPackages = attrs.getValue(Constants.DYNAMICIMPORT_PACKAGE);
			List<String> packages = parseCommaSeparated(importPackages);
			for (String pkg : packages) {
				String[] tokens = pkg.split(";");
				Node node = fileNode.addNode(SlcNames.SLC_ + Constants.DYNAMICIMPORT_PACKAGE,
						SlcTypes.SLC_DYNAMIC_IMPORTED_PACKAGE);
				node.setProperty(SlcNames.SLC_NAME, tokens[0]);
				for (int i = 1; i < tokens.length; i++) {
					if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
						node.setProperty(SlcNames.SLC_VERSION, attributeValue(tokens[i]));
					}
				}
			}
		}

		// exported packages
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.EXPORT_PACKAGE);
		if (attrs.containsKey(new Name(Constants.EXPORT_PACKAGE))) {
			String exportPackages = attrs.getValue(Constants.EXPORT_PACKAGE);
			List<String> packages = parseCommaSeparated(exportPackages);
			for (String pkg : packages) {
				String[] tokens = pkg.split(";");
				Node node = fileNode.addNode(SlcNames.SLC_ + Constants.EXPORT_PACKAGE, SlcTypes.SLC_EXPORTED_PACKAGE);
				node.setProperty(SlcNames.SLC_NAME, tokens[0]);
				// TODO: are these cleans really necessary?
				cleanSubNodes(node, SlcNames.SLC_USES);
				cleanSubNodes(node, SlcNames.SLC_VERSION);
				for (int i = 1; i < tokens.length; i++) {
					if (tokens[i].startsWith(Constants.VERSION_ATTRIBUTE)) {
						String versionStr = attributeValue(tokens[i]);
						Node versionNode = node.addNode(SlcNames.SLC_VERSION, SlcTypes.SLC_OSGI_VERSION);
						mapOsgiVersion(new Version(versionStr), versionNode);
					} else if (tokens[i].startsWith(Constants.USES_DIRECTIVE)) {
						String usedPackages = directiveValue(tokens[i]);
						// log.debug("uses='" + usedPackages + "'");
						for (String usedPackage : usedPackages.split(",")) {
							// log.debug("usedPackage='" +
							// usedPackage +
							// "'");
							Node usesNode = node.addNode(SlcNames.SLC_USES, SlcTypes.SLC_JAVA_PACKAGE);
							usesNode.setProperty(SlcNames.SLC_NAME, usedPackage);
						}
					}
				}
			}
		}

		// required bundle
		cleanSubNodes(fileNode, SlcNames.SLC_ + Constants.REQUIRE_BUNDLE);
		if (attrs.containsKey(new Name(Constants.REQUIRE_BUNDLE))) {
			String requireBundle = attrs.getValue(Constants.REQUIRE_BUNDLE);
			List<String> bundles = parseCommaSeparated(requireBundle);
			for (String bundle : bundles) {
				String[] tokens = bundle.split(";");
				Node node = fileNode.addNode(SlcNames.SLC_ + Constants.REQUIRE_BUNDLE, SlcTypes.SLC_REQUIRED_BUNDLE);
				node.setProperty(SlcNames.SLC_SYMBOLIC_NAME, tokens[0]);
				for (int i = 1; i < tokens.length; i++) {
					if (tokens[i].startsWith(Constants.BUNDLE_VERSION_ATTRIBUTE)) {
						node.setProperty(SlcNames.SLC_BUNDLE_VERSION, attributeValue(tokens[i]));
					} else if (tokens[i].startsWith(Constants.RESOLUTION_DIRECTIVE)) {
						node.setProperty(SlcNames.SLC_OPTIONAL,
								directiveValue(tokens[i]).equals(Constants.RESOLUTION_OPTIONAL));
					}
				}
			}
		}

	}

	private void addAttr(String key, Node node, Attributes attrs) throws RepositoryException {
		addAttr(new Name(key), node, attrs);
	}

	private void addAttr(Name key, Node node, Attributes attrs) throws RepositoryException {
		if (attrs.containsKey(key)) {
			String value = attrs.getValue(key);
			node.setProperty(SlcNames.SLC_ + key, value);
		}
	}

	private void cleanSubNodes(Node node, String name) throws RepositoryException {
		if (node.hasNode(name)) {
			NodeIterator nit = node.getNodes(name);
			while (nit.hasNext())
				nit.nextNode().remove();
		}
	}

	private String attributeValue(String str) {
		return extractValue(str, "=");
	}

	private String directiveValue(String str) {
		return extractValue(str, ":=");
	}

	private String extractValue(String str, String eq) {
		String[] tokens = str.split(eq);
		// String key = tokens[0];
		String value = tokens[1].trim();
		// TODO: optimize?
		if (value.startsWith("\""))
			value = value.substring(1);
		if (value.endsWith("\""))
			value = value.substring(0, value.length() - 1);
		return value;
	}

	/** Parse package list with nested directive with ',' */
	private List<String> parseCommaSeparated(String str) {
		List<String> res = new ArrayList<String>();
		StringBuffer curr = new StringBuffer("");
		boolean in = false;
		for (char c : str.toCharArray()) {
			if (c == ',') {
				if (!in) {// new package
					res.add(curr.toString());
					curr = new StringBuffer("");
				} else {// a ',' within " "
					curr.append(c);
				}
			} else if (c == '\"') {
				in = !in;
				curr.append(c);
			} else {
				curr.append(c);
			}
		}
		res.add(curr.toString());
		// log.debug(res);
		return res;
	}

	protected void mapOsgiVersion(Version version, Node versionNode) throws RepositoryException {
		versionNode.setProperty(SlcNames.SLC_AS_STRING, version.toString());
		versionNode.setProperty(SlcNames.SLC_MAJOR, version.getMajor());
		versionNode.setProperty(SlcNames.SLC_MINOR, version.getMinor());
		versionNode.setProperty(SlcNames.SLC_MICRO, version.getMicro());
		if (!version.getQualifier().equals(""))
			versionNode.setProperty(SlcNames.SLC_QUALIFIER, version.getQualifier());
	}

	public void setForce(Boolean force) {
		this.force = force;
	}

}