/*******************************************************************************
 * Copyright (c) 2016 RCP Vision (http://www.rcp-vision.com) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * Vincenzo Caselli - Initial contribution and API
 *******************************************************************************/
package org.eclipse.emf.parsley.web.tools;

import java.util.Arrays;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.parsley.dsl.additional.builder.builder.EmfParsleyDslPluginXmlNature;
import org.eclipse.emf.parsley.web.tools.ParsleyWebFacetInstallConfig.PERSISTENCE_OPTION;
import org.eclipse.emf.parsley.wizards.NewEmfParsleyProjectSupport;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
import org.eclipse.jst.j2ee.webapplication.WebApp;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;
import org.eclipse.wst.common.componentcore.internal.ProjectComponents;
import org.eclipse.wst.common.componentcore.internal.ReferencedComponent;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
import org.eclipse.wst.common.project.facet.core.IDelegate;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.xtext.ui.XtextProjectHelper;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.FrameworkUtil;

/**
 * Wizard class for execution of actions for the core Parsley-JEE project
 * creation
 * 
 * @author Vincenzo Caselli
 * 
 */
@SuppressWarnings("restriction")
public class ParsleyWebFacetInstallDelegate implements IDelegate {

	// private static Logger LOGGER =
	// Logger.getLogger(ParsleyWebFacetInstallDelegate.class);

	@Override
	public void execute(final IProject iProject, final IProjectFacetVersion fv, final Object config,
			final IProgressMonitor monitor) throws CoreException {
		monitor.beginTask("Processing EMF Parsley Web facet", 2);

		final ParsleyWebFacetInstallConfig wizardUserOptions = (ParsleyWebFacetInstallConfig) config;

		setWebModuleDependencies(iProject, monitor, wizardUserOptions);

		// final IFolder webInfLib = Utils.getFolder(iProject, "WEB-INF/lib");

		// Utils.copyFromPluginToWorkspace(org.eclipse.emf.parsley.hwt.Activator.getDefault().getBundle(),
		// new Path("/target/org.eclipse.emf.parsley.hwt-0.0.1-SNAPSHOT.jar"),
		// webInfLib.getFile("org.eclipse.emf.parsley.hwt.jar"));

		// Utils.copyFromPluginToWorkspace(org.eclipse.emf.parsley.web.servlets.Activator.getDefault().getBundle(),
		// new
		// Path("/target/org.eclipse.emf.parsley.web.servlets-0.0.1-SNAPSHOT.jar"),
		// webInfLib.getFile("emf.parsley.web-core.jar"));

		Utils.copyFile(iProject, monitor, "/templates/pom.xml", iProject.getFile("pom.xml"), new Properties());

		addProjectNature(iProject, monitor, XtextProjectHelper.NATURE_ID);
		addProjectNature(iProject, monitor, EmfParsleyDslPluginXmlNature.NATURE_ID ); 
		// TODO should take it from a predefined Maven plugin constant
		addProjectNature(iProject, monitor, "org.eclipse.m2e.core.maven2Nature"); 

		Properties replaceStrings;
		String mainPackage = NewEmfParsleyProjectSupport.getValidJavaName(iProject.getName());
		IPackageFragment pack = JavaCore.create(iProject).getPackageFragmentRoot(iProject.getFolder("src"))
				.createPackageFragment(mainPackage, true, monitor);
		IFolder folder = iProject.getFolder(pack.getPath().removeFirstSegments(1));

		replaceStrings = new Properties();
		replaceStrings.setProperty("org.eclipse.emf.parsley.web.tools.servlets", mainPackage);
		Utils.copyFile(iProject, monitor, "/templates/module.parsley",
				iProject.getFolder("src").getFile("module.parsley"), replaceStrings);

//		replaceStrings = new Properties();
//		replaceStrings.setProperty("org.eclipse.emf.parsley.web.tools.templates", projectName);
//		Utils.copyFile(iProject, monitor, "/templates/ParsleyWebGuiceModule.java",
//				folder.getFile("ParsleyWebGuiceModule.java"), replaceStrings);

		replaceStrings = new Properties();
		IPath fullPath = folder.getFullPath();
		String lastSegment = fullPath.segment(fullPath.segmentCount()-1);
		lastSegment = lastSegment.substring(0, 1).toUpperCase() + lastSegment.substring(1,lastSegment.length());
		replaceStrings.setProperty("ParsleyWebGuiceModule", lastSegment+"EmfParsleyGuiceModule");
		replaceStrings.setProperty("org.eclipse.emf.parsley.web.tools.templates", mainPackage);
		Utils.copyFile(iProject, monitor, "/templates/ParsleyGuiceServletContextListener.java",
				folder.getFile("ParsleyGuiceServletContextListener.java"), replaceStrings);

		replaceStrings = new Properties();

		replaceStrings.setProperty("org.eclipse.emf.parsley.web.tools.templates", mainPackage);

		Utils.copyFile(iProject, monitor, "/templates/ParsleyContextListener.java",
				folder.getFile("ParsleyContextListener.java"), replaceStrings);

		setupWebInfXml(iProject);

		ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, monitor);

		monitor.done();
	}

	private void setWebModuleDependencies(final IProject iProject, final IProgressMonitor monitor,
			ParsleyWebFacetInstallConfig wizardUserOptions) {
		Set<String> pluginJarSet = getPluginJarSet(wizardUserOptions);
		Map<String, Object> pluginInstalledPathMap = getInstalledPluginPathMap(pluginJarSet, monitor);

		StructureEdit se = StructureEdit.getStructureEditForWrite(iProject);
		ProjectComponents root = se.getComponentModelRoot();
		WorkbenchComponent firstComponent = (WorkbenchComponent) root.getComponents().get(0);

		addDependentModules(iProject, pluginInstalledPathMap, firstComponent, wizardUserOptions, monitor);

		addMavenDependentModule(iProject, "guice-servlet-4.0.jar", "com/google/inject/extensions/guice-servlet/4.0",
				firstComponent, monitor);
		addMavenDependentModule(iProject, "json-simple-1.1.1.jar", "com/googlecode/json-simple/json-simple/1.1.1",
				firstComponent, monitor);

		se.save(monitor);
	}

	private void addProjectNature(final IProject iProject, final IProgressMonitor monitor, String natureId)
			throws CoreException {
		IProjectDescription description = iProject.getDescription();
		String[] currentNatures = description.getNatureIds();
		String[] newNatures = Arrays.copyOf(currentNatures, currentNatures.length + 1);
		newNatures[currentNatures.length] = natureId;
		description.setNatureIds(newNatures);
		iProject.setDescription(description, monitor);
	}

	private Set<String> getPluginJarSet(final ParsleyWebFacetInstallConfig wizardUserOptions) {
		return new LinkedHashSet<String>() {
			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			{
				add("com.google.guava");
				add("com.google.inject");
				add("javax.inject");
				add("javax.persistence");
				add("org.apache.commons.logging");
				add("org.apache.log4j");
				add("org.eclipse.jface");
				add("org.eclipse.osgi");
				add("org.eclipse.core.commands");
				add("org.eclipse.core.databinding");
				add("org.eclipse.core.databinding.observable");
				add("org.eclipse.core.databinding.property");
				add("org.eclipse.jface.databinding");
				add("org.eclipse.ui.workbench");
				add("org.eclipse.equinox.common");
				add("org.eclipse.ui.views");
				add("org.eclipse.ui.forms");
				// add("org.eclipse.swt.win32.win32.x86_64");
				add("org.eclipse.emf");
				add("org.eclipse.emf.common");
				add("org.eclipse.emf.common.ui");
				add("org.eclipse.emf.databinding");
				add("org.eclipse.emf.ecore");
				add("org.eclipse.emf.ecore.edit");
				add("org.eclipse.emf.ecore.xmi");
				add("org.eclipse.emf.edit");
				add("org.eclipse.emf.edit.ui");
				add("org.eclipse.equinox.registry");
				add("org.eclipse.emf.parsley.common");
				add("org.eclipse.emf.parsley.runtime.common");
				add("org.eclipse.emf.parsley.web.servlets");

				if (wizardUserOptions.getPersistenceOption().equals(PERSISTENCE_OPTION.TENEO)) {
					// Just in case Teneo is installed, then its needed plugins
					// are referenced
					// in plugins
					add("org.eclipse.emf.teneo.hibernate.mapper");
					add("org.eclipse.emf.teneo.annotations");
					add("org.eclipse.emf.teneo.hibernate");
					add("org.eclipse.emf.teneo");
					// Deps of org.hibernate
					add("antlr");
					add("hibernate-commons-annotations");
					add("hibernate-core");
					add("jboss-logging");
					add("jboss-transaction-api_1.2_spec");
					// Deps of org.eclipse.m2e.archetype.common
					add("dom4j");
				}
			}
		};
	}

	private Map<String, Object> getInstalledPluginPathMap(Set<String> pluginJarSet, final IProgressMonitor monitor) {
		Map<String, Object> map = new HashMap<String, Object>();
		try {
			BundleContext ctx = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
			Bundle[] bundles = ctx.getBundles();
			for (Bundle bundle : bundles) {
				String pluginId = bundle.getSymbolicName();
				if (bundle.getLocation().indexOf("plugins/") > -1 || "System Bundle".equals(bundle.getLocation())) {
					if (pluginJarSet.contains(pluginId)) {
						map.put(pluginId, bundle);
						logAdded(pluginId, "plugins", bundle.getLocation());
					} else {
						Dictionary<String, String> deps = bundle.getHeaders();
						Enumeration<String> keysEnum = deps.keys();
						while (keysEnum.hasMoreElements()) {
							String depKey = keysEnum.nextElement();
							String depsValues = deps.get(depKey);
							// System.out.println("\t\t" + depKey + ": " +
							// depsValues);
							if ("Embedded-Artifacts".equals(depKey)) {
								String[] depsArray = depsValues.split(";");
								/*
								 * Structure has the following pattern:
								 * 
								 * archetype-common-2.3.jar,
								 * g="org.apache.maven.archetype",
								 * a="archetype-common", v="2.3",
								 * 
								 * dom4j-1.6.1.jar, g="dom4j", a="dom4j",
								 * v="1.6.1",
								 */
								for (int j = 0; j < depsArray.length; j++) {
									// System.out.println("depsArray[" + j + "]
									// = " + depsArray[j]);
									if (depsArray[j].startsWith("a=\"")) {
										String depId = depsArray[j].substring(3, depsArray[j].length() - 1);
										// System.out.println(depId);
										if (pluginJarSet.contains(depId)) {
											String depIdWithVersion = depsArray[j - 2].split(",")[1];
											map.put(depIdWithVersion, bundle.getSymbolicName() + "_"
													+ bundle.getVersion() + "/" + depIdWithVersion);
											logAdded(depIdWithVersion, "Embedded-Artifacts", bundle.getSymbolicName()
													+ "_" + bundle.getVersion() + "/" + depIdWithVersion);
											break;
										}
									}
								}
								// System.out.println(depsArray);
								break;
							}
							if ("Bundle-ClassPath".equals(depKey)) {
								if (!depsValues.equals(".")) {
									String[] depsArray = depsValues.split(",");
									// System.out.println(depsValues);
									/*
									 * Structure has the following pattern:
									 * 
									 * antlr-2.7.7.jar,c3p0-0.9.2.1.jar,dom4j-1.
									 * 6.1.jar,ehcache-core -2.4 .3.jar, ...
									 */
									for (int j = 0; j < depsArray.length; j++) {
										// System.out.println("depsArray[" + j +
										// "] = " +
										// depsArray[j]);
										if (!depsArray[j].equals(".") && depsArray[j].lastIndexOf(".jar") > -1) {
											String depId = depsArray[j].substring(0, depsArray[j].lastIndexOf(".jar"));
											// System.out.println(depId);
											depId = stripVersionIfExists(depId);
											// String depId =
											// depsArray[j].substring(0,
											// depsArray[j].lastIndexOf("-"));
											// System.out.println(depId);
											if (pluginJarSet.contains(depId)) {
												map.put(depsArray[j], bundle.getSymbolicName() + "_"
														+ bundle.getVersion() + "/" + depsArray[j]);
												logAdded(depsArray[j], "Bundle-ClassPath", bundle.getSymbolicName()
														+ "_" + bundle.getVersion() + "/" + depsArray[j]);
											}
										}
									}
									// System.out.println(depsArray);
								}
								break;
							}
						}
					}
					// Enumeration<String> keys = bundle.getHeaders().keys();
					// while (keys.hasMoreElements()) {
					// String key = keys.nextElement();
					// System.out.println(key + "\t\t" +
					// bundle.getHeaders().get(key));
					// }
				}

			}

			monitor.worked(1);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return map;
	}

	private void logAdded(String pluginId, String from, String location) {
		// System.out.println("Added " + Strings.padEnd(pluginId, 50, ' ') +
		// from + "\t\t" + location);
		// LOGGER.debug("Added " + Strings.padEnd(pluginId, 50, ' ') + from +
		// "\t\t" + location);
	}

	private String stripVersionIfExists(String depId) {
		int posLastDot = depId.lastIndexOf('.');
		int posLastDash = depId.lastIndexOf('-');
		if (posLastDot > -1 && posLastDash > -1) {
			return depId.substring(0, posLastDash);
		}
		return depId;
	}

	@SuppressWarnings("unchecked")
	private void addDependentModules(IProject iProject, Map<String, Object> pluginInstalledPathMap,
			WorkbenchComponent firstComponent, ParsleyWebFacetInstallConfig wizardUserOptions,
			IProgressMonitor monitor) {
		for (String pluginId : pluginInstalledPathMap.keySet()) {
			Object obj = pluginInstalledPathMap.get(pluginId);
			String archiveName;
			String bundleIdVersionJar;
			String bundleUri = null;
			boolean oomphedEclipse = false;
			if (obj instanceof Bundle) {
				Bundle bundle = (Bundle) obj;
				oomphedEclipse = bundle.getLocation().indexOf("/.p2/pool/") > -1;
				if (("org.eclipse.emf.parsley.common".equals(pluginId)
						|| "org.eclipse.emf.parsley.runtime.common".equals(pluginId))
						&& !bundle.getLocation().endsWith(".jar")) {
					checkForImportedPlugins(pluginId, bundle);
					// EMF Parsley Project development case
					bundleUri = "module:/resource/" + pluginId + "/" + pluginId;
				}
				bundleIdVersionJar = oomphedEclipse ? bundle.getLocation().substring("reference:/file:".length())
						: bundle.getSymbolicName() + "_" + bundle.getVersion() + ".jar";
				archiveName = bundle.getSymbolicName() + ".jar";
			} else {
				// String => Bundle dependency
				bundleIdVersionJar = (String) obj;
				archiveName = pluginId;
			}
			ReferencedComponent refC = ComponentcoreFactory.eINSTANCE.createReferencedComponent();
			URI uri;
			if (bundleUri != null) {
				// EMF Parsley Project development case
				uri = URI.createURI(bundleUri);
			} else {
				if (oomphedEclipse) {
					uri = URI.createURI("module:/classpath/lib/" + bundleIdVersionJar);
				} else {
					uri = URI.createURI("module:/classpath/var/ECLIPSE_HOME/plugins/" + bundleIdVersionJar);
				}
			}
			refC.setHandle(uri);
			refC.setArchiveName(archiveName);
			Path newPath = new Path("/WEB-INF/lib");
			refC.setRuntimePath(newPath);
			firstComponent.getReferencedComponents().add(refC);
		}

	}

	private void checkForImportedPlugins(final String pluginId, final Bundle bundle) {
		IProject[] workspaceProjects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		boolean found = false;
		for (IProject iProject : workspaceProjects) {
			if (iProject.getName().equals(pluginId) && iProject.isOpen()) {
				found = true;
				break;
			}
		}
		if (!found) {
			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
				@Override
				public void run() {
					String importPath = bundle.getLocation().substring("reference:file:".length() + 1);
					MessageDialog.openError(null, "Error", "Please import (or open) plugin '" + pluginId
							+ "' from EMF Parsley first instance environment!\n" + "Path: " + importPath);
				}
			});
		}
	}

	// private void addModelDependentModule(IProject iProject, String
	// modelPlugin,
	// WorkbenchComponent firstComponent, IProgressMonitor monitor) {
	// ReferencedComponent refC =
	// ComponentcoreFactory.eINSTANCE.createReferencedComponent();
	// URI uri = URI.createURI("module:/resource/" + modelPlugin + "/" +
	// modelPlugin);
	// refC.setHandle(uri);
	// refC.setArchiveName(modelPlugin + ".jar");
	// Path newPath = new Path("/WEB-INF/lib");
	// refC.setRuntimePath(newPath);
	// firstComponent.getReferencedComponents().add(refC);
	// }

	@SuppressWarnings("unchecked")
	private void addMavenDependentModule(IProject iProject, String jarName, String jarPathInMavenRepo,
			WorkbenchComponent firstComponent, IProgressMonitor monitor) {
		ReferencedComponent refC = ComponentcoreFactory.eINSTANCE.createReferencedComponent();
		URI uri = URI.createURI("module:/classpath/var/M2_REPO/" + jarPathInMavenRepo + "/" + jarName);
		refC.setHandle(uri);
		refC.setArchiveName(jarName);
		Path newPath = new Path("/WEB-INF/lib");
		refC.setRuntimePath(newPath);
		firstComponent.getReferencedComponents().add(refC);
	}

	private void setupWebInfXml(final IProject iProject) {
		final WebArtifactEdit artifact = WebArtifactEdit.getWebArtifactEditForWrite(iProject);
		final WebApp webAppRoot = artifact.getWebApp();
		try {
			Utils.registerServlet(iProject, webAppRoot, "JsonTableServlet",
					"org.eclipse.emf.parsley.web.servlets.JsonTableServlet", "/JsonTableServlet");
			Utils.registerServlet(iProject, webAppRoot, "JsonDetailsServlet",
					"org.eclipse.emf.parsley.web.servlets.JsonDetailsServlet", "/JsonDetailsServlet");
			Utils.registerServlet(iProject, webAppRoot, "JsonSaveServlet",
					"org.eclipse.emf.parsley.web.servlets.JsonSaveServlet", "/JsonSaveServlet");

			artifact.saveIfNecessary(null);
		} finally {
			artifact.dispose();
		}
	}

}