/*******************************************************************************
 *  Copyright (c) 2007, 2015 IBM Corporation and others.
 *
 *  This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License 2.0
 *  which accompanies this distribution, and is available at
 *  https://www.eclipse.org/legal/epl-2.0/
 *
 *  SPDX-License-Identifier: EPL-2.0
 * 
 *  Contributors:
 *     IBM Corporation - initial API and implementation
 *     Red Hat Incorporated - fix for bug 225145
 *     Code 9 - ongoing development
 *     Pascal Rapicault - Support for bundled macosx http://bugs.eclipse.org/57349
 *     Ericsson AB (Pascal Rapicault) - Support to reuse bundles in place
 *     Red Hat Inc. - Bug 460967
 *******************************************************************************/
package org.eclipse.equinox.internal.p2.touchpoint.eclipse;

import java.io.File;
import java.net.*;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.frameworkadmin.BundleInfo;
import org.eclipse.equinox.internal.p2.core.helpers.*;
import org.eclipse.equinox.internal.p2.metadata.IRequiredCapability;
import org.eclipse.equinox.internal.provisional.frameworkadmin.ConfigData;
import org.eclipse.equinox.p2.core.*;
import org.eclipse.equinox.p2.engine.IProfile;
import org.eclipse.equinox.p2.metadata.*;
import org.eclipse.equinox.p2.repository.IRepository;
import org.eclipse.equinox.p2.repository.IRepositoryManager;
import org.eclipse.equinox.p2.repository.artifact.*;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.osgi.service.environment.EnvironmentInfo;
import org.eclipse.osgi.util.NLS;

public class Util {

	/**
	 * TODO "cache" is probably not the right term for this location
	 */
	private static final String REPOSITORY_TYPE = IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY;
	private static final String CACHE_EXTENSIONS = "org.eclipse.equinox.p2.cache.extensions"; //$NON-NLS-1$
	private static final String PIPE = "|"; //$NON-NLS-1$

	/**
	 * Bit-mask value representing this profile's bundle pool
	 */
	public static final int AGGREGATE_CACHE = 0x01;
	/**
	 * Bit-mask value representing the shared profile's bundle pool in a shared
	 * install
	 */
	public static final int AGGREGATE_SHARED_CACHE = 0x02;
	/**
	 * Bit-mask value representing the extension locations, such as the dropins
	 * folder.
	 */
	public static final int AGGREGATE_CACHE_EXTENSIONS = 0x04;

	public static IAgentLocation getAgentLocation(IProvisioningAgent agent) {
		return agent.getService(IAgentLocation.class);
	}

	public static IArtifactRepositoryManager getArtifactRepositoryManager(IProvisioningAgent agent) {
		return agent.getService(IArtifactRepositoryManager.class);
	}

	public static URI getBundlePoolLocation(IProvisioningAgent agent, IProfile profile) {
		String path = profile.getProperty(IProfile.PROP_CACHE);
		if (path != null)
			return new File(path).toURI();
		IAgentLocation location = getAgentLocation(agent);
		if (location == null)
			return null;
		return location.getDataArea(Activator.ID);
	}

	public static synchronized IFileArtifactRepository getBundlePoolRepository(IProvisioningAgent agent,
			IProfile profile) {
		URI location = getBundlePoolLocation(agent, profile);
		if (location == null)
			return null;
		IArtifactRepositoryManager manager = getArtifactRepositoryManager(agent);
		try {
			IArtifactRepository repository = manager.loadRepository(location, null);
			if (repository instanceof IFileArtifactRepository) {
				return (IFileArtifactRepository) repository;
			}
			// update site repository
			return null;
		} catch (ProvisionException e) {
			// the repository doesn't exist, so fall through and create a new one
		}
		try {
			String repositoryName = Messages.BundlePool;
			Map<String, String> properties = new HashMap<>(1);
			properties.put(IRepository.PROP_SYSTEM, Boolean.TRUE.toString());
			return (IFileArtifactRepository) manager.createRepository(location, repositoryName, REPOSITORY_TYPE,
					properties);
		} catch (ProvisionException e) {
			LogHelper.log(e);
			throw new IllegalArgumentException(NLS.bind(Messages.bundle_pool_not_writeable, location));
		}
	}

	public static IFileArtifactRepository getAggregatedBundleRepository(IProvisioningAgent agent, IProfile profile) {
		return getAggregatedBundleRepository(agent, profile,
				AGGREGATE_CACHE | AGGREGATE_SHARED_CACHE | AGGREGATE_CACHE_EXTENSIONS);
	}

	public static IFileArtifactRepository getAggregatedBundleRepository(IProvisioningAgent agent, IProfile profile,
			int repoFilter) {
		List<IFileArtifactRepository> bundleRepositories = new ArrayList<>();

		// we check for a shared bundle pool first as it should be preferred over the
		// user bundle pool in a shared install
		IArtifactRepositoryManager manager = getArtifactRepositoryManager(agent);
		if ((repoFilter & AGGREGATE_SHARED_CACHE) != 0) {
			String sharedCache = profile.getProperty(IProfile.PROP_SHARED_CACHE);
			if (sharedCache != null) {
				try {
					URI repoLocation = new File(sharedCache).toURI();
					IArtifactRepository repository = manager.loadRepository(repoLocation, null);
					if (repository != null && repository instanceof IFileArtifactRepository
							&& !bundleRepositories.contains(repository))
						bundleRepositories.add((IFileArtifactRepository) repository);
				} catch (ProvisionException e) {
					// skip repository if it could not be read
				}
			}
		}

		if ((repoFilter & AGGREGATE_CACHE) != 0) {
			IFileArtifactRepository bundlePool = Util.getBundlePoolRepository(agent, profile);
			if (bundlePool != null)
				bundleRepositories.add(bundlePool);
		}

		if ((repoFilter & AGGREGATE_CACHE_EXTENSIONS) != 0) {
			List<String> repos = getListProfileProperty(profile, CACHE_EXTENSIONS);
			for (String repo : repos) {
				try {
					URI repoLocation;
					try {
						repoLocation = new URI(repo);
					} catch (URISyntaxException e) {
						// in 1.0 we wrote unencoded URL strings, so try as an unencoded string
						repoLocation = URIUtil.fromString(repo);
					}
					IArtifactRepository repository = manager.loadRepository(repoLocation, null);
					if (repository != null && repository instanceof IFileArtifactRepository
							&& !bundleRepositories.contains(repository))
						bundleRepositories.add((IFileArtifactRepository) repository);
				} catch (ProvisionException e) {
					// skip repositories that could not be read
				} catch (URISyntaxException e) {
					// unexpected, URLs should be pre-checked
					LogHelper.log(new Status(IStatus.ERROR, Activator.ID, e.getMessage(), e));
				}
			}
		}

		getRunnableRepositories(manager, bundleRepositories);
		return new AggregatedBundleRepository(agent, bundleRepositories);
	}

	private static void getRunnableRepositories(IArtifactRepositoryManager manager,
			List<IFileArtifactRepository> bundleRepositories) {
		URI[] localURLs = manager.getKnownRepositories(IRepositoryManager.REPOSITORIES_LOCAL);
		for (URI localURL : localURLs) {
			try {
				IArtifactRepository candidate = manager.loadRepository(localURL, new NullProgressMonitor());
				if (Boolean.parseBoolean(candidate.getProperty(IArtifactRepository.PROP_RUNNABLE))) {
					if (candidate != null && candidate instanceof IFileArtifactRepository
						&& !bundleRepositories.contains(candidate))
						bundleRepositories.add((IFileArtifactRepository) candidate);
				}
			}catch (ProvisionException e) {
				// skip repositories that could not be read
			}
		}
	}

	private static List<String> getListProfileProperty(IProfile profile, String key) {
		List<String> listProperty = new ArrayList<>();
		String dropinRepositories = profile.getProperty(key);
		if (dropinRepositories != null) {
			StringTokenizer tokenizer = new StringTokenizer(dropinRepositories, PIPE);
			while (tokenizer.hasMoreTokens()) {
				listProperty.add(tokenizer.nextToken());
			}
		}
		return listProperty;
	}

	public static BundleInfo createBundleInfo(File bundleFile, IInstallableUnit unit) {
		BundleInfo bundleInfo = new BundleInfo();
		if (bundleFile != null)
			bundleInfo.setLocation(bundleFile.toURI());

		Collection<IProvidedCapability> capabilities = unit.getProvidedCapabilities();
		for (IProvidedCapability capability : capabilities) {
			String nameSpace = capability.getNamespace();
			if (nameSpace.equals("osgi.bundle")) { //$NON-NLS-1$
				bundleInfo.setSymbolicName(capability.getName());
				bundleInfo.setVersion(capability.getVersion().toString());
			} else if (nameSpace.equals("osgi.fragment")) { //$NON-NLS-1$
				String fragmentName = capability.getName();
				String fragmentHost = getFragmentHost(unit, fragmentName);
				// shouldn't happen as long as the metadata is well-formed
				if (fragmentHost == null)
					LogHelper.log(createError("Unable to find fragment host for IU: " + unit)); //$NON-NLS-1$
				else
					bundleInfo.setFragmentHost(fragmentHost);
				bundleInfo.setVersion(capability.getVersion().toString());
			}
		}
		return bundleInfo;
	}

	public static BundleInfo findBundleInfo(ConfigData config, IInstallableUnit unit) {
		// Construct a partial BundleInfo from the IU capabilities.
		BundleInfo bundleInfo = Util.createBundleInfo(null, unit);

		// Find the actual fully populated BundleInfo used by the runtime.
		BundleInfo[] bundles = config.getBundles();
		for (BundleInfo bundle : bundles) {
			// Can't use BundleInfol.equals(), because bundleInfo is only partially
			// populated.
			if (bundleInfo.getSymbolicName().equals(bundle.getSymbolicName())
					&& bundleInfo.getVersion().equals(bundle.getVersion())) {
				return bundle;
			}
		}

		return null;
	}

	private static String getFragmentHost(IInstallableUnit unit, String fragmentName) {
		Collection<IRequirement> requires = unit.getRequirements();
		for (IRequirement iRequirement : requires) {
			if (iRequirement instanceof IRequiredCapability) {
				IRequiredCapability requiredCapability = (IRequiredCapability) iRequirement;
				if (fragmentName.equals(requiredCapability.getName())) {
					String fragmentHost = requiredCapability.getName();
					if (!requiredCapability.getRange().toString().equals("0.0.0")) { //$NON-NLS-1$
						fragmentHost += ";bundle-version=\"" + requiredCapability.getRange() + '"'; //$NON-NLS-1$
					}
					return fragmentHost;
				}
			}
		}
		return null;
	}

	public static File getArtifactFile(IProvisioningAgent agent, IArtifactKey artifactKey, IProfile profile) {
		IFileArtifactRepository aggregatedView = getAggregatedBundleRepository(agent, profile);
		File bundleJar = aggregatedView.getArtifactFile(artifactKey);
		return bundleJar;
	}

	public static File getConfigurationFolder(IProfile profile) {
		String config = profile.getProperty(IProfile.PROP_CONFIGURATION_FOLDER);
		if (config != null)
			return new File(config);
		return new File(getInstallFolder(profile), "configuration"); //$NON-NLS-1$
	}

	/*
	 * Do a look-up and return the OSGi install area if it is set.
	 */
	public static URL getOSGiInstallArea() {
		Location location = ServiceHelper.getService(Activator.getContext(), Location.class, Location.INSTALL_FILTER);
		if (location == null)
			return null;
		if (!location.isSet())
			return null;
		return location.getURL();
	}

	/*
	 * Helper method to return the eclipse.home location. Return null if it is
	 * unavailable.
	 */
	public static File getEclipseHome() {
		Location eclipseHome = ServiceHelper.getService(Activator.getContext(), Location.class,
				Location.ECLIPSE_HOME_FILTER);
		if (eclipseHome == null || !eclipseHome.isSet())
			return null;
		URL url = eclipseHome.getURL();
		if (url == null)
			return null;
		return URLUtil.toFile(url);
	}

	/**
	 * Returns the install folder for the profile, or <code>null</code> if no
	 * install folder is defined.
	 */
	public static File getInstallFolder(IProfile profile) {
		String folder = profile.getProperty(IProfile.PROP_INSTALL_FOLDER);
		return folder == null ? null : new File(folder);
	}

	public static File getLauncherPath(IProfile profile) {
		String name = profile.getProperty(EclipseTouchpoint.PROFILE_PROP_LAUNCHER_NAME);
		if (name == null || name.length() == 0)
			name = "eclipse"; //$NON-NLS-1$
		String relativePath = getLauncherRelativePath(name, getOSFromProfile(profile), getInstallFolder(profile));
		return relativePath == null ? null : new File(getInstallFolder(profile), relativePath);
	}

	/**
	 * Returns the name of the Eclipse application launcher.
	 */
	private static String getLauncherRelativePath(String name, String os, File installFolder) {
		if (os == null) {
			EnvironmentInfo info = ServiceHelper.getService(Activator.getContext(), EnvironmentInfo.class);
			if (info == null)
				return null;
			os = info.getOS();
		}

		if (os.equals(org.eclipse.osgi.service.environment.Constants.OS_WIN32)) {
			IPath path = IPath.fromOSString(name);
			if ("exe".equals(path.getFileExtension())) //$NON-NLS-1$
				return name;
			return name + ".exe"; //$NON-NLS-1$
		}

		if (os.equals(org.eclipse.osgi.service.environment.Constants.OS_MACOSX)) {
			return "../MacOS/" + name; //$NON-NLS-1$
		}
		return name;
	}

	public static String getOSFromProfile(IProfile profile) {
		String environments = profile.getProperty(IProfile.PROP_ENVIRONMENTS);
		if (environments == null)
			return null;
		for (StringTokenizer tokenizer = new StringTokenizer(environments, ","); tokenizer.hasMoreElements();) { //$NON-NLS-1$
			String entry = tokenizer.nextToken();
			int i = entry.indexOf('=');
			String key = entry.substring(0, i).trim();
			if (!key.equals("osgi.os")) //$NON-NLS-1$
				continue;
			return entry.substring(i + 1).trim();
		}
		return null;
	}

	public static IStatus createError(String message) {
		return createError(message, null);
	}

	public static IStatus createError(String message, Exception e) {
		return new Status(IStatus.ERROR, Activator.ID, message, e);
	}

	public static IStatus createWarning(String message) {
		return createWarning(message, null);
	}

	public static IStatus createWarning(String message, Exception e) {
		return new Status(IStatus.WARNING, Activator.ID, message, e);
	}

	public static File getLauncherConfigLocation(IProfile profile) {
		String launcherConfig = profile.getProperty(IProfile.PROP_LAUNCHER_CONFIGURATION);
		return launcherConfig == null ? null : new File(launcherConfig);
	}

	public static String resolveArtifactParam(Map<String, Object> parameters) throws CoreException {
		String artifactLocation = (String) parameters.get(EclipseTouchpoint.PARM_ARTIFACT_LOCATION);
		if (artifactLocation != null)
			return artifactLocation;

		IArtifactKey artifactKey = (IArtifactKey) parameters.get(EclipseTouchpoint.PARM_ARTIFACT);
		if (artifactKey == null) {
			IInstallableUnit iu = (IInstallableUnit) parameters.get(EclipseTouchpoint.PARM_IU);
			throw new CoreException(Util.createError(NLS.bind(Messages.iu_contains_no_arifacts, iu)));
		}

		throw new CoreException(Util.createError(NLS.bind(Messages.artifact_file_not_found, artifactKey)));
	}
}
