/*******************************************************************************
 * Copyright (c) 2010, 2011 SAP AG 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:
 *     Kaloyan Raev (SAP AG) - initial API and implementation
 *******************************************************************************/
package org.eclipse.libra.facet;

import static org.eclipse.libra.facet.OSGiBundleFacetUtils.BUILD_PROPERTIES;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_EL_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_PERSISTENCE_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_SERVLET_HTTP_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_SERVLET_JSP_EL_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_SERVLET_JSP_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_SERVLET_JSP_TAGEXT_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVAX_SERVLET_PACKAGE;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JAVA_FACET;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.JPA_FACET;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.META_INF;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.META_PERSISTENCE_HEADER;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.REQUIRED_PLUGINS_CONTAINER_PATH;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.WEB_CONTEXT_PATH_HEADER;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.WEB_INF_CLASSES;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.getBundleProjectDescription;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.getContextRootFromWTPModel;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.getWebContentPath;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.hasPluginNature;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.hasRequiredPlugins;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.isJavaProject;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.isJpaProject;
import static org.eclipse.libra.facet.OSGiBundleFacetUtils.isWebProject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.common.project.facet.core.internal.JavaFacetUtil;
import org.eclipse.libra.facet.internal.LibraFacetPlugin;
import org.eclipse.osgi.service.resolver.VersionRange;
import org.eclipse.pde.core.project.IBundleClasspathEntry;
import org.eclipse.pde.core.project.IBundleProjectDescription;
import org.eclipse.pde.core.project.IBundleProjectService;
import org.eclipse.pde.core.project.IPackageExportDescription;
import org.eclipse.pde.core.project.IPackageImportDescription;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.util.FacetedProjectUtilities;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.project.facet.core.IDelegate;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.osgi.framework.Version;


public class OSGiBundleFacetInstallDelegate implements IDelegate {
	
	public void execute(IProject project, IProjectFacetVersion fv,
			Object configObject, IProgressMonitor monitor) throws CoreException {
		OSGiBundleFacetInstallConfig config = (OSGiBundleFacetInstallConfig) configObject;
		doExecute(project, config, monitor);
	}
	
	private static void doExecute(IProject project,
			OSGiBundleFacetInstallConfig config, IProgressMonitor monitor)
			throws CoreException {
		setBundleRoot(project);
		createBundleProjectDescription(project, config, monitor);
		addRequiredPluginsClasspathContainer(project, monitor);

		if (isJpaProject(project)) {
			moveMetaInfToRoot(project, monitor);
		}
	}

	private static void setBundleRoot(IProject project) throws CoreException {
		IPath bundleRoot = null;
		if (isWebProject(project)) {
			bundleRoot = getWebContentPath(project);
		}
		
		if (bundleRoot != null) {
			IBundleProjectService bundleProjectService = LibraFacetPlugin.getDefault().getBundleProjectService();
			bundleProjectService.setBundleRoot(project, bundleRoot);
		}
	}
	
	private static void createBundleProjectDescription(IProject project,
			OSGiBundleFacetInstallConfig config, IProgressMonitor monitor)
			throws CoreException {
		IBundleProjectDescription bundleProjectDescription = getBundleProjectDescription(project);
		bundleProjectDescription.setSymbolicName(config.getSymbolicName());
		bundleProjectDescription.setBundleVersion(config.getVersion());
		
		String bundleName = config.getName();
		if (bundleName != null && bundleName.trim().length() > 0) {
			bundleProjectDescription.setBundleName(bundleName);
		}
		
		String bundleVendor = config.getVendor();
		if (bundleVendor != null && bundleVendor.trim().length() > 0) {
			bundleProjectDescription.setBundleVendor(bundleVendor);
		}
		
		bundleProjectDescription.setEquinox(true);
		bundleProjectDescription.setExtensionRegistry(false);
		bundleProjectDescription.setNatureIds(getNatureIds(bundleProjectDescription));
		bundleProjectDescription.setLaunchShortcuts(getLaunchShortcuts(project));
		
		Map<String, String> headers = getAdditionalHeaders(config, project);
		for (Map.Entry<String, String> entry : headers.entrySet()) {
			bundleProjectDescription.setHeader(entry.getKey(), entry.getValue());
		}
		
		bundleProjectDescription.setPackageExports(getPackageExports(project));
		bundleProjectDescription.setPackageImports(getPackageImports(bundleProjectDescription));
		bundleProjectDescription.setBinIncludes(getBinIncludes(bundleProjectDescription));
		bundleProjectDescription.setBundleClasspath(getBundleClasspath(bundleProjectDescription));
		setExecutionEnvironments(bundleProjectDescription);
		
		bundleProjectDescription.apply(monitor);
	}
	
	private static String[] getNatureIds(IBundleProjectDescription bundleProjectDescription) {
		String[] natureIds = bundleProjectDescription.getNatureIds();
		String[] newNatureIds = new String[natureIds.length + 1];
		for (int i = 0; i < natureIds.length; i++) {
			newNatureIds[i] = natureIds[i];
		}
		newNatureIds[newNatureIds.length - 1] = IBundleProjectDescription.PLUGIN_NATURE;
		
		return newNatureIds;
	}

	private static String[] getLaunchShortcuts(IProject project) throws CoreException {
		if (isWebProject(project)) {
			return new String[] {
					"org.eclipse.pde.ui.EquinoxLaunchShortcut",  //$NON-NLS-1$
					"org.eclipse.wst.server.launchShortcut" //$NON-NLS-1$
			};
		}
		// use default OSGi Framework launchers
		return null;
	}
	
	private static Map<String, String> getAdditionalHeaders(OSGiBundleFacetInstallConfig config, IProject project) throws CoreException {
		Map<String, String> headers = new HashMap<String, String>();
		
		if (isWebProject(project)) {
			// check if there is existing Web-ContextPath header in the manifest
			if (config.getHeaders().containsKey(WEB_CONTEXT_PATH_HEADER)) {
				// overwrite the context path in the WTP model with the one value from the OSGi header
				headers.put(WEB_CONTEXT_PATH_HEADER, config.getHeaders().get(WEB_CONTEXT_PATH_HEADER));
			} else {
				// use the context path from the WTP model
				headers.put(WEB_CONTEXT_PATH_HEADER, getContextRootFromWTPModel(project));
			}
		}
		
		if (isJpaProject(project)) {
			headers.put(META_PERSISTENCE_HEADER, ""); //$NON-NLS-1$
		}
		
		return headers;
	}

	private static IPackageExportDescription[] getPackageExports(IProject project) throws CoreException {
		IBundleProjectService bundleProjectService = LibraFacetPlugin.getDefault().getBundleProjectService();
		List<IPackageExportDescription> list = new ArrayList<IPackageExportDescription>();
		
		if (isJavaProject(project)) {
			IJavaProject javaProject = JavaCore.create(project);
			IPackageFragmentRoot[] fragmentRoots = javaProject.getAllPackageFragmentRoots();
			for (IPackageFragmentRoot fragmentRoot : fragmentRoots) {
				if (fragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE && fragmentRoot.getParent().equals(javaProject)) {
					IJavaElement[] elements = fragmentRoot.getChildren();
					for (IJavaElement element : elements) {
						IPackageFragment fragment = (IPackageFragment) element;
						if (fragment.containsJavaResources()) {
							list.add(bundleProjectService.newPackageExport(fragment.getElementName(), null, true, null));
						}
					}
				}
			}
		}
		
		return list.toArray(new IPackageExportDescription[list.size()]);
	}

	private static IPackageImportDescription[] getPackageImports(IBundleProjectDescription bundleProjectDescription) throws CoreException {
		IProject project = bundleProjectDescription.getProject();
		Map<String, IPackageImportDescription> packages = new TreeMap<String, IPackageImportDescription>();
		
		// look for existing package imports
		IPackageImportDescription[] imports = bundleProjectDescription.getPackageImports();
		if (imports != null) {
			for (IPackageImportDescription imp : imports) {
				packages.put(imp.getName(), imp);
			}
		}

		if (isWebProject(project)) {
			// add the most popular servlet packages
			addPackageImport(packages, JAVAX_SERVLET_PACKAGE, null, false);
			addPackageImport(packages, JAVAX_SERVLET_HTTP_PACKAGE, null, false);
			addPackageImport(packages, JAVAX_SERVLET_JSP_PACKAGE, null, false);
			addPackageImport(packages, JAVAX_SERVLET_JSP_EL_PACKAGE, null, false);
			addPackageImport(packages, JAVAX_SERVLET_JSP_TAGEXT_PACKAGE, null, false);
			addPackageImport(packages, JAVAX_EL_PACKAGE, null, false);

			// add packages exported by referenced components
			IVirtualComponent component = ComponentCore.createComponent(project);
			IVirtualReference[] references = component.getReferences();
			for (IVirtualReference ref : references) {
				IProject refProject = ref.getReferencedComponent().getProject();
				if (refProject != null && refProject != project && hasPluginNature(refProject)) {
					IPackageExportDescription[] exports = getBundleProjectDescription(refProject).getPackageExports();
					for (IPackageExportDescription export : exports) {
						String importName = export.getName();
						Version exportVersion = export.getVersion();
						VersionRange range = (exportVersion == null) ? null : new VersionRange(exportVersion.toString());
						addPackageImport(packages, importName, range, false);
					}
				}
			}
		}
		
		if (isJpaProject(project)) {
			String version = FacetedProjectUtilities.getProjectFacetVersion(project, JPA_FACET).getVersionString();
			addPackageImport(packages, String.format(JAVAX_PERSISTENCE_PACKAGE, version), null, false);
		}
		
		return packages.values().toArray(new IPackageImportDescription[packages.size()]);
	}
	
	private static void addPackageImport(Map<String, IPackageImportDescription> packages, String importName, VersionRange range, boolean optional) {
		IBundleProjectService bundleProjectService = LibraFacetPlugin.getDefault().getBundleProjectService();
		if (!packages.containsKey(importName)) {
			IPackageImportDescription imp = bundleProjectService.newPackageImport(importName, range, optional);
			packages.put(importName, imp);
		}
	}
	
	private static IPath[] getBinIncludes(IBundleProjectDescription bundleProjectDescription) throws CoreException {
		IProject project = bundleProjectDescription.getProject();
		IVirtualComponent component = ComponentCore.createComponent(project);
		
		if (isWebProject(project)) {
			IPath bundleRoot = component.getRootFolder().getProjectRelativePath();
			IResource[] resources = project.getFolder(bundleRoot).members();
			List<IPath> binPaths = new ArrayList<IPath>();
			
			for (int i = 0; i < resources.length; i++) {
				String token = resources[i].getName();
				if (resources[i].getType() == IResource.FOLDER) {
					token += '/';
				}
				
				if (!token.equals(BUILD_PROPERTIES)) {
					binPaths.add(new Path(token));
				}
			}
			
			return binPaths.toArray(new IPath[binPaths.size()]);
		} 

		// don't modify bin.includes by default
		return bundleProjectDescription.getBinIncludes();
	}

	private static IBundleClasspathEntry[] getBundleClasspath(IBundleProjectDescription bundleProjectDescription) throws CoreException {
		IProject project = bundleProjectDescription.getProject();
		IBundleClasspathEntry[] bundleClasspath = bundleProjectDescription.getBundleClasspath(); 
		
		if (OSGiBundleFacetUtils.isJavaProject(project)) {
			IJavaProject javaProject = JavaCore.create(project);
			if (bundleClasspath == null || bundleClasspath.length == 0) {
				IPath[] javaSourceFolderPaths = getJavaSourceFolderPaths(javaProject);
				
				if (javaSourceFolderPaths != null && javaSourceFolderPaths.length > 0) {
					IBundleProjectService bundleProjectService = LibraFacetPlugin.getDefault().getBundleProjectService();
					
					List<IBundleClasspathEntry> bundleClasspathList = new ArrayList<IBundleClasspathEntry>(); 
					
					IPath binary = getRelativePath(project, javaProject.getOutputLocation());
					IPath library = (isWebProject(project)) 
							? new Path(WEB_INF_CLASSES) 	// add WEB-INF/classes for WABs
							: null; 						// add . for other OSGi bundles
							
					// iterate over source folders and create IBundleClasspathEntry for each one.
					for (IPath iPath : javaSourceFolderPaths) {
						bundleClasspathList.add(bundleProjectService.newBundleClasspathEntry(
								getRelativePath(project, iPath), binary, library));
					}
					bundleClasspath = bundleClasspathList.toArray(new IBundleClasspathEntry[] { });
				}
			} else {
				// TODO
			}
		}
		
		// don't modify bin.includes by default
		return bundleClasspath;
	}
	
	private static void addRequiredPluginsClasspathContainer(IProject project, IProgressMonitor monitor) throws CoreException {
		if (isJavaProject(project)) {
			IJavaProject javaProject = JavaCore.create(project);
			IClasspathEntry[] entries = javaProject.getRawClasspath();
			if (!hasRequiredPlugins(entries)) {
				IClasspathEntry[] newEntries = new IClasspathEntry[entries.length + 1];
				System.arraycopy(entries, 0, newEntries, 0, entries.length);
				newEntries[newEntries.length - 1] = JavaCore.newContainerEntry(REQUIRED_PLUGINS_CONTAINER_PATH);
				javaProject.setRawClasspath(newEntries, monitor);
			}
		}
	}

	private static IPath[] getJavaSourceFolderPaths(IJavaProject javaProject) throws JavaModelException {
		List<IPath> paths = new ArrayList<IPath>();
		
		IPackageFragmentRoot[] fragmentRoots = javaProject.getAllPackageFragmentRoots();
		for (IPackageFragmentRoot fragmentRoot : fragmentRoots) {
			if (fragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE && fragmentRoot.getParent().equals(javaProject)) {
				paths.add(fragmentRoot.getPath());
			}
		}
		
		return paths.toArray(new IPath[paths.size()]);
	}
	
	private static IPath getRelativePath(IProject project, IPath path) {
		return path.makeRelativeTo(project.getFullPath()).addTrailingSeparator();
	}
	
	private static void setExecutionEnvironments(IBundleProjectDescription bundleProjectDescription) {
		IProject project = bundleProjectDescription.getProject();
		IProjectFacetVersion javaProjectFacetVersion = FacetedProjectUtilities.getProjectFacetVersion(project, JAVA_FACET);
		if (javaProjectFacetVersion != null) {
			String[] existingEEs = bundleProjectDescription.getExecutionEnvironments();
			String newEE = JavaFacetUtil.getCorrespondingExecutionEnvironment(javaProjectFacetVersion);
			//if there are existing EEs different from newEE add newEE. Else just set newEE.   
			if (existingEEs != null) {
				ArrayList<String> eeList = new ArrayList<String>(Arrays.asList(existingEEs));
				if (!eeList.contains(newEE)) {
					eeList.add(newEE);
					bundleProjectDescription.setExecutionEnvironments(eeList.toArray(new String[eeList.size()]));
				}
			} else {
				bundleProjectDescription.setExecutionEnvironments(new String[] { newEE } );
			}
		}
	}
	
	private static void moveMetaInfToRoot(IProject project, IProgressMonitor monitor) throws CoreException {
		// find the first META-INF folder as a second-level folder
		IFolder folder = null;
		IResource[] resources = project.members();
		for (IResource r : resources) {
			if (r.getType() == IResource.FOLDER) {
				IFolder f = (IFolder) r;
				IResource metaInf = f.findMember(META_INF);
				if (metaInf != null && metaInf.getType() == IResource.FOLDER) {
					folder = (IFolder) metaInf;
					break;
				}
			}
		}
		
		if (folder == null || !folder.exists())
			return;
		
		// copy all resources to /META-INF
		IResource[] members = folder.members();
		for (IResource member : members) {
			IPath destination = project.getFolder(META_INF).getFullPath().append(member.getName());  
			if (!project.getWorkspace().getRoot().exists(destination)) { // this check is needed for the /src/MANIFEST.MF added by the jst.utility facet
				member.move(destination, true, monitor);
			}
		}
		folder.delete(true, monitor);
	}

}