package org.argeo.slc.repo.maven;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.jar.Attributes.Name;
import java.util.jar.Manifest;

import javax.jcr.Binary;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.nodetype.NodeType;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import javax.jcr.query.qom.Ordering;
import javax.jcr.query.qom.QueryObjectModel;
import javax.jcr.query.qom.QueryObjectModelFactory;
import javax.jcr.query.qom.Selector;

import org.argeo.api.cms.CmsLog;
import org.argeo.jcr.JcrUtils;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.SlcNames;
import org.argeo.slc.SlcTypes;
import org.argeo.slc.repo.ArtifactIndexer;
import org.argeo.slc.repo.JarFileIndexer;
import org.argeo.slc.repo.RepoUtils;
import org.argeo.slc.repo.osgi.OsgiProfile;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.osgi.framework.Constants;

/**
 * Migrate the distribution from 1.2 to 1.4 by cleaning naming and dependencies.
 * The dependency to the SpringSource Enterprise Bundle repository is removed as
 * well as their naming conventions. All third party are move to org.argeo.tp
 * group IDs. Maven dependency for Eclipse artifacts don't use version ranges
 * anymore. Verison constraints on javax.* packages are removed (since they lead
 * to "use package conflicts" when Eclipse and Spring Security are used
 * together).
 */
public class Migration_01_03 implements Runnable, SlcNames {
	final String SPRING_SOURCE_PREFIX = "com.springsource";
	private final static CmsLog log = CmsLog.getLog(Migration_01_03.class);

	private Repository repository;
	private String sourceWorkspace;
	private String targetWorkspace;

	private List<String> excludedBundles = new ArrayList<String>();
	private Map<String, String> symbolicNamesMapping = new HashMap<String, String>();

	private Session origSession;
	private Session targetSession;

	private List<String> systemPackages = OsgiProfile.PROFILE_JAVA_SE_1_6.getSystemPackages();

	private String artifactBasePath = "/";

	private ArtifactIndexer artifactIndexer = new ArtifactIndexer();
	private JarFileIndexer jarFileIndexer = new JarFileIndexer();

	public void init() throws RepositoryException {
		origSession = JcrUtils.loginOrCreateWorkspace(repository, sourceWorkspace);
		targetSession = JcrUtils.loginOrCreateWorkspace(repository, targetWorkspace);

		// works only in OSGi!!
		// systemPackages = Arrays.asList(System.getProperty(
		// "org.osgi.framework.system.packages").split(","));
	}

	public void destroy() {
		JcrUtils.logoutQuietly(origSession);
		JcrUtils.logoutQuietly(targetSession);
	}

	public void run() {

		try {
			// clear target
			NodeIterator nit = targetSession.getNode(artifactBasePath).getNodes();
			while (nit.hasNext()) {
				Node node = nit.nextNode();
				if (node.isNodeType(NodeType.NT_FOLDER) || node.isNodeType(NodeType.NT_UNSTRUCTURED)) {
					node.remove();
					node.getSession().save();
					if (log.isDebugEnabled())
						log.debug("Cleared " + node);
				}
			}

			NodeIterator origArtifacts = listArtifactVersions(origSession);
			// process
			while (origArtifacts.hasNext()) {
				Node origArtifactNode = origArtifacts.nextNode();
				if (log.isTraceEnabled())
					log.trace(origArtifactNode);

				processOrigArtifactVersion(origArtifactNode);
			}
		} catch (Exception e) {
			throw new SlcException("Cannot perform v1.3 migration from " + sourceWorkspace + " to " + targetWorkspace,
					e);
		} finally {
			JcrUtils.discardQuietly(targetSession);
		}
	}

	protected void processOrigArtifactVersion(Node origArtifactNode) throws RepositoryException, IOException {
		Artifact origArtifact = RepoUtils.asArtifact(origArtifactNode);

		// skip eclipse artifacts
		if ((origArtifact.getGroupId().startsWith("org.eclipse")
				&& !(origArtifact.getArtifactId().equals("org.eclipse.osgi")
						|| origArtifact.getArtifactId().equals("org.eclipse.osgi.source")
						|| origArtifact.getArtifactId().startsWith("org.eclipse.rwt.widgets.upload")))
				|| origArtifact.getArtifactId().startsWith("com.ibm.icu")) {
			if (log.isDebugEnabled())
				log.debug("Skip " + origArtifact);
			return;
		}

		// skip SpringSource ActiveMQ
		if (origArtifact.getArtifactId().startsWith("com.springsource.org.apache.activemq"))
			return;

		String origJarNodeName = MavenConventionsUtils.artifactFileName(origArtifact);
		if (!origArtifactNode.hasNode(origJarNodeName))
			throw new SlcException("Cannot find jar node for " + origArtifactNode);
		Node origJarNode = origArtifactNode.getNode(origJarNodeName);

		// read MANIFEST
		Binary manifestBinary = origJarNode.getProperty(SLC_MANIFEST).getBinary();
		Manifest origManifest = new Manifest(manifestBinary.getStream());
		JcrUtils.closeQuietly(manifestBinary);

		Boolean manifestModified = false;
		Manifest targetManifest = new Manifest(origManifest);

		// transform symbolic name
		String origSymbolicName = origManifest.getMainAttributes().getValue(Constants.BUNDLE_SYMBOLICNAME);
		final String targetSymbolicName;
		if (symbolicNamesMapping.containsKey(origSymbolicName)) {
			targetSymbolicName = symbolicNamesMapping.get(origSymbolicName);
		} else if (origSymbolicName.startsWith(SPRING_SOURCE_PREFIX)
				&& !origSymbolicName.equals(SPRING_SOURCE_PREFIX + ".json")) {
			targetSymbolicName = origSymbolicName.substring(SPRING_SOURCE_PREFIX.length() + 1);
		} else {
			targetSymbolicName = origSymbolicName;
		}

		if (!targetSymbolicName.equals(origSymbolicName)) {
			targetManifest.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, targetSymbolicName);
			manifestModified = true;
			if (log.isDebugEnabled())
				log.debug(
						Constants.BUNDLE_SYMBOLICNAME + " to " + targetSymbolicName + " \t\tfrom " + origSymbolicName);
		}

		// skip excluded bundles
		if (excludedBundles.contains(targetSymbolicName))
			return;

		// check fragment host
		if (origManifest.getMainAttributes().containsKey(new Name(Constants.FRAGMENT_HOST))) {
			String origFragmentHost = origManifest.getMainAttributes().getValue(Constants.FRAGMENT_HOST);
			String targetFragmentHost;
			if (symbolicNamesMapping.containsKey(origFragmentHost)) {
				targetFragmentHost = symbolicNamesMapping.get(origFragmentHost);
			} else if (origFragmentHost.startsWith(SPRING_SOURCE_PREFIX)
					&& !origFragmentHost.equals(SPRING_SOURCE_PREFIX + ".json")) {
				targetFragmentHost = origFragmentHost.substring(SPRING_SOURCE_PREFIX.length() + 1);
			} else if (origFragmentHost.equals("org.argeo.dep.jacob;bundle-version=\"[1.14.3,1.14.4)\"")) {
				// this one for those who think I cannot be pragmatic - mbaudier
				targetFragmentHost = "com.jacob;bundle-version=\"[1.14.3,1.14.4)\"";
			} else {
				targetFragmentHost = origFragmentHost;
			}

			if (!targetFragmentHost.equals(origFragmentHost)) {
				targetManifest.getMainAttributes().putValue(Constants.FRAGMENT_HOST, targetFragmentHost);
				manifestModified = true;
				if (log.isDebugEnabled())
					log.debug(Constants.FRAGMENT_HOST + " to " + targetFragmentHost + " from " + origFragmentHost);
			}
		}

		// we assume there is no Require-Bundle in com.springsource.* bundles

		// javax with versions
		StringBuffer targetImportPackages = new StringBuffer("");
		NodeIterator origImportPackages = origJarNode.getNodes(SLC_ + Constants.IMPORT_PACKAGE);
		Boolean importPackagesModified = false;
		while (origImportPackages.hasNext()) {
			Node importPackage = origImportPackages.nextNode();
			String pkg = importPackage.getProperty(SLC_NAME).getString();
			targetImportPackages.append(pkg);
			if (importPackage.hasProperty(SLC_VERSION)) {
				String sourceVersion = importPackage.getProperty(SLC_VERSION).getString();
				String targetVersion = sourceVersion;
				if (systemPackages.contains(pkg)) {
					if (!(sourceVersion.trim().equals("0") || sourceVersion.trim().equals("0.0.0"))) {
						targetVersion = null;
						importPackagesModified = true;
						if (log.isDebugEnabled())
							log.debug(origSymbolicName + ": Nullify version of " + pkg + " from " + sourceVersion);
					}
				}
				if (targetVersion != null)
					targetImportPackages.append(";version=\"").append(targetVersion).append("\"");
			}
			if (importPackage.hasProperty(SLC_OPTIONAL)) {
				Boolean optional = importPackage.getProperty(SLC_OPTIONAL).getBoolean();
				if (optional)
					targetImportPackages.append(";resolution:=\"optional\"");

			}
			if (origImportPackages.hasNext())
				targetImportPackages.append(",");
		}

		if (importPackagesModified) {
			targetManifest.getMainAttributes().putValue(Constants.IMPORT_PACKAGE, targetImportPackages.toString());
			manifestModified = true;
		}

		if (!manifestModified && log.isTraceEnabled()) {
			log.trace("MANIFEST of " + origSymbolicName + " was not modified");
		}

		// target coordinates
		final String targetGroupId;
		if (origArtifact.getArtifactId().startsWith("org.eclipse.rwt.widgets.upload"))
			targetGroupId = "org.argeo.tp.rap";
		else if (origArtifact.getArtifactId().startsWith("org.polymap"))
			targetGroupId = "org.argeo.tp.rap";
		else if (origArtifact.getGroupId().startsWith("org.eclipse")
				&& !origArtifact.getArtifactId().equals("org.eclipse.osgi"))
			throw new SlcException(origArtifact + " should have been excluded");// targetGroupId
																				// =
																				// "org.argeo.tp.eclipse";
		else
			targetGroupId = "org.argeo.tp";

		String targetArtifactId = targetSymbolicName.split(";")[0];
		Artifact targetArtifact = new DefaultArtifact(targetGroupId, targetArtifactId, "jar",
				origArtifact.getVersion());
		String targetParentPath = MavenConventionsUtils.artifactParentPath(artifactBasePath, targetArtifact);
		String targetFileName = MavenConventionsUtils.artifactFileName(targetArtifact);
		String targetJarPath = targetParentPath + '/' + targetFileName;

		// copy
		Node targetParentNode = JcrUtils.mkfolders(targetSession, targetParentPath);
		targetSession.save();
		if (manifestModified) {
			Binary origBinary = origJarNode.getNode(Node.JCR_CONTENT).getProperty(Property.JCR_DATA).getBinary();
			byte[] targetJarBytes = RepoUtils.modifyManifest(origBinary.getStream(), targetManifest);
			JcrUtils.copyBytesAsFile(targetParentNode, targetFileName, targetJarBytes);
			JcrUtils.closeQuietly(origBinary);
		} else {// just copy
			targetSession.getWorkspace().copy(sourceWorkspace, origJarNode.getPath(), targetJarPath);
		}
		targetSession.save();

		// reindex
		Node targetJarNode = targetSession.getNode(targetJarPath);
		artifactIndexer.index(targetJarNode);
		jarFileIndexer.index(targetJarNode);

		targetSession.save();

		// sources
		Artifact origSourceArtifact = new DefaultArtifact(origArtifact.getGroupId(),
				origArtifact.getArtifactId() + ".source", "jar", origArtifact.getVersion());
		String origSourcePath = MavenConventionsUtils.artifactPath(artifactBasePath, origSourceArtifact);
		if (origSession.itemExists(origSourcePath)) {
			Node origSourceJarNode = origSession.getNode(origSourcePath);

			Artifact targetSourceArtifact = new DefaultArtifact(targetGroupId, targetArtifactId + ".source", "jar",
					origArtifact.getVersion());
			String targetSourceParentPath = MavenConventionsUtils.artifactParentPath(artifactBasePath,
					targetSourceArtifact);
			String targetSourceFileName = MavenConventionsUtils.artifactFileName(targetSourceArtifact);
			String targetSourceJarPath = targetSourceParentPath + '/' + targetSourceFileName;

			Node targetSourceParentNode = JcrUtils.mkfolders(targetSession, targetSourceParentPath);
			targetSession.save();

			if (!targetSymbolicName.equals(origSymbolicName)) {
				Binary origBinary = origSourceJarNode.getNode(Node.JCR_CONTENT).getProperty(Property.JCR_DATA)
						.getBinary();
				NameVersion targetNameVersion = RepoUtils.readNameVersion(targetManifest);
				byte[] targetJarBytes = RepoUtils.packageAsPdeSource(origBinary.getStream(), targetNameVersion);
				JcrUtils.copyBytesAsFile(targetSourceParentNode, targetSourceFileName, targetJarBytes);
				JcrUtils.closeQuietly(origBinary);
			} else {// just copy
				targetSession.getWorkspace().copy(sourceWorkspace, origSourceJarNode.getPath(), targetSourceJarPath);
			}
			targetSession.save();

			// reindex
			Node targetSourceJarNode = targetSession.getNode(targetSourceJarPath);
			artifactIndexer.index(targetSourceJarNode);
			jarFileIndexer.index(targetSourceJarNode);

			targetSession.save();
		}
	}

	/*
	 * UTILITIES
	 */

	static NodeIterator listArtifactVersions(Session session) throws RepositoryException {
		QueryManager queryManager = session.getWorkspace().getQueryManager();
		QueryObjectModelFactory factory = queryManager.getQOMFactory();

		final String artifactVersionsSelector = "artifactVersions";
		Selector source = factory.selector(SlcTypes.SLC_ARTIFACT_VERSION_BASE, artifactVersionsSelector);

		Ordering orderByArtifactId = factory
				.ascending(factory.propertyValue(artifactVersionsSelector, SlcNames.SLC_ARTIFACT_ID));
		Ordering[] orderings = { orderByArtifactId };

		QueryObjectModel query = factory.createQuery(source, null, orderings, null);

		QueryResult result = query.execute();
		return result.getNodes();
	}

	public void setRepository(Repository repository) {
		this.repository = repository;
	}

	public void setSourceWorkspace(String sourceWorkspace) {
		this.sourceWorkspace = sourceWorkspace;
	}

	public void setTargetWorkspace(String targetWorkspace) {
		this.targetWorkspace = targetWorkspace;
	}

	public void setExcludedBundles(List<String> excludedBundles) {
		this.excludedBundles = excludedBundles;
	}

	public void setSymbolicNamesMapping(Map<String, String> symbolicNamesMapping) {
		this.symbolicNamesMapping = symbolicNamesMapping;
	}

}