/*******************************************************************************
 * Copyright (c) 2010, 2018 The Eclipse Foundation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * 	The Eclipse Foundation - initial API and implementation
 * 	Yatta Solutions - error handling (bug 374105), news (bug 401721), public API (bug 432803)
 * 	                  featured market (bug 461603)
 *******************************************************************************/
package org.eclipse.epp.internal.mpc.ui.catalog;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.epp.internal.mpc.core.MarketplaceClientCore;
import org.eclipse.epp.internal.mpc.ui.MarketplaceClientUi;
import org.eclipse.epp.internal.mpc.ui.catalog.MarketplaceCategory.Contents;
import org.eclipse.epp.internal.mpc.ui.util.ConcurrentTaskManager;
import org.eclipse.epp.mpc.core.model.ICategory;
import org.eclipse.epp.mpc.core.model.IMarket;
import org.eclipse.epp.mpc.core.model.INews;
import org.eclipse.epp.mpc.core.model.INode;
import org.eclipse.epp.mpc.core.model.ISearchResult;
import org.eclipse.equinox.internal.p2.discovery.AbstractDiscoveryStrategy;
import org.eclipse.equinox.internal.p2.discovery.Catalog;
import org.eclipse.equinox.internal.p2.discovery.DiscoveryCore;
import org.eclipse.equinox.internal.p2.discovery.model.CatalogCategory;
import org.eclipse.equinox.internal.p2.discovery.model.CatalogItem;
import org.eclipse.equinox.internal.p2.discovery.model.Certification;
import org.eclipse.equinox.internal.p2.discovery.model.Tag;
import org.eclipse.equinox.p2.core.ProvisionException;
import org.eclipse.equinox.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.p2.metadata.Version;
import org.eclipse.equinox.p2.operations.ProvisioningSession;
import org.eclipse.equinox.p2.query.IQuery;
import org.eclipse.equinox.p2.query.IQueryResult;
import org.eclipse.equinox.p2.query.QueryUtil;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepositoryManager;
import org.eclipse.equinox.p2.ui.ProvisioningUI;
import org.eclipse.osgi.util.NLS;

/**
 * @author David Green
 * @author Carsten Reckord
 */
public class MarketplaceCatalog extends Catalog {

	private final Map<String, Version> repositoryIuVersionById = new HashMap<>();

	private INews news;

	private List<MarketplaceNodeCatalogItem> availableUpdates = new ArrayList<>();

	private interface DiscoveryOperation {
		public void run(MarketplaceDiscoveryStrategy strategy, IProgressMonitor monitor) throws CoreException;
	}

	public IStatus performQuery(final IMarket market, final ICategory category, final String queryText,
			IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.performQuery(market, category, queryText, monitor1),
				false, monitor);
	}

	public IStatus tagged(final String tag, IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.tagged(tag, monitor1), false, monitor);
	}

	public IStatus related(IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.related(monitor1), false, monitor);
	}

	public IStatus recent(IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.recent(monitor1), false, monitor);
	}

	public IStatus popular(IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.popular(monitor1), false, monitor);
	}

	public IStatus featured(IProgressMonitor monitor, final IMarket market, final ICategory category) {
		return performDiscovery((strategy, monitor1) -> strategy.featured(monitor1, market, category), false, monitor);
	}

	public IStatus installed(IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.installed(monitor1), false, monitor);
	}

	public IStatus userFavorites(final boolean login, IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.userFavorites(login, monitor1), false, monitor);
	}

	public IStatus refreshUserFavorites(IProgressMonitor monitor) {
		return performDiscovery((strategy, monitor1) -> strategy.refreshUserFavorites(monitor1), true, monitor);
	}

	/**
	 * Query for a set of node ids. Use this method infrequently since it may have to make multiple server round-trips.
	 *
	 * @param monitor
	 *            the progress monitor
	 * @param nodeIds
	 *            the nodes to retrieve
	 * @return
	 */
	public IStatus performQuery(IProgressMonitor monitor, final Set<String> nodeIds) {
		return performDiscovery((strategy, monitor1) -> strategy.performQuery(monitor1, nodeIds), false, monitor);
	}

	/**
	 * Query for a set of nodes. Use this method infrequently since it may have to make multiple server round-trips.
	 *
	 * @param monitor
	 *            the progress monitor
	 * @param nodeIds
	 *            the nodes to retrieve
	 * @return
	 */
	public IStatus performNodeQuery(IProgressMonitor monitor, final Set<? extends INode> nodes) {
		return performDiscovery((strategy, monitor1) -> strategy.performNodeQuery(monitor1, nodes), false, monitor);
	}

	public IStatus checkForUpdates(final IProgressMonitor monitor) {
		SubMonitor progress = SubMonitor.convert(monitor, Messages.MarketplaceCatalog_checkingForUpdates, 10000000);
		try {
			Map<String, IInstallableUnit> installedIUs = calculateInstalledIUs(progress.newChild(100000));
			List<MarketplaceNodeCatalogItem> updateCheckNeeded = new ArrayList<>();
			List<CatalogItem> updateCheckItems = getUpdateCheckItems(progress.newChild(100000));
			List<MarketplaceNodeCatalogItem> updateableItems = new ArrayList<MarketplaceNodeCatalogItem>();
			for (CatalogItem item : updateCheckItems) {
				if (monitor.isCanceled()) {
					return Status.CANCEL_STATUS;
				}
				if (!(item instanceof MarketplaceNodeCatalogItem)) {
					continue;
				}
				MarketplaceNodeCatalogItem catalogItem = (MarketplaceNodeCatalogItem) item;
				if (catalogItem.isInstalled()) {
					if (setUpdatesAvailable(installedIUs, catalogItem)) {
						updateCheckNeeded.add(catalogItem);
					} else if (Boolean.TRUE.equals(catalogItem.getUpdateAvailable())) {
						updateableItems.add(catalogItem);
					}
				}
			}
			if (!updateCheckNeeded.isEmpty()) {
				checkForUpdates(updateCheckNeeded, installedIUs, progress.newChild(10000000 - 200000));
				for (MarketplaceNodeCatalogItem catalogItem : updateCheckNeeded) {
					if (Boolean.TRUE.equals(catalogItem.getUpdateAvailable())) {
						updateableItems.add(catalogItem);
					}
				}
			}

			availableUpdates = updateableItems;

			return monitor.isCanceled() ? Status.CANCEL_STATUS : Status.OK_STATUS;
		} finally {
			monitor.done();
		}
	}

	private List<CatalogItem> getUpdateCheckItems(IProgressMonitor monitor) {
		List<CatalogItem> updateCheckItems = getItems();

		//add all locally installed items as well
		boolean includeInstalled = false;
		List<CatalogCategory> categories = getCategories();
		if (categories != null) {
			//Might be null if run before discovery
			for (CatalogCategory category : categories) {
				if (category instanceof MarketplaceCategory) {
					MarketplaceCategory marketplaceCategory = (MarketplaceCategory) category;
					if (marketplaceCategory.getContents() == Contents.FEATURED) {
						includeInstalled = true;
						break;
					}
				}
			}
		}
		if (!includeInstalled) {
			return updateCheckItems;
		}

		final List<CatalogItem> finalUpdateCheckItems = new ArrayList<>(updateCheckItems);
		runDiscoveryOperation((s, m) -> {
			try {
				performUpdateCheckDiscovery(s, m);
			} catch (CoreException e) {
				MarketplaceClientUi.log(IStatus.INFO, Messages.MarketplaceCatalog_UpdateCheckDiscoveryError, e);
			}
		}, finalUpdateCheckItems, categories, getCertifications(), getTags(), monitor);
		return finalUpdateCheckItems;
	}

	private void performUpdateCheckDiscovery(MarketplaceDiscoveryStrategy marketplaceDiscoveryStrategy,
			IProgressMonitor monitor) throws CoreException {
		SubMonitor discoveryStrategyProgress = SubMonitor.convert(monitor, 1000);

		List<CatalogItem> updateCheckItems = marketplaceDiscoveryStrategy.getItems();
		Map<String, CatalogItem> itemsById = new HashMap<>();
		for (CatalogItem catalogItem : updateCheckItems) {
			itemsById.put(catalogItem.getId(), catalogItem);
		}

		MarketplaceCategory catalogCategory = marketplaceDiscoveryStrategy
				.findMarketplaceCategory(discoveryStrategyProgress.newChild(1));
		final Contents realContents = catalogCategory.getContents();
		try {
			catalogCategory.setContents(Contents.INSTALLED);
			ISearchResult installed = marketplaceDiscoveryStrategy
					.computeInstalled(discoveryStrategyProgress.newChild(499));
			List<? extends INode> installedNodes = installed.getNodes();
			if (installedNodes == null || installedNodes.isEmpty()) {
				return;
			}
			SubMonitor itemProgress = discoveryStrategyProgress.newChild(500);
			itemProgress.setWorkRemaining(installedNodes.size() * 100);
			for (INode node : installedNodes) {
				CatalogItem item = marketplaceDiscoveryStrategy.createCatalogItem(node, catalogCategory.getId(), false,
						itemProgress.newChild(100));
				if (!itemsById.containsKey(item.getId())) {
					itemsById.put(item.getId(), item);
					updateCheckItems.add(item);
				}
			}
			itemProgress.done();
		} finally {
			catalogCategory.setContents(realContents);
		}
	}

	private Map<String, IInstallableUnit> calculateInstalledIUs(IProgressMonitor monitor) {
		Map<String, IInstallableUnit> installedIUs = new HashMap<>();
		List<AbstractDiscoveryStrategy> discoveryStrategies = getDiscoveryStrategies();
		SubMonitor progress = SubMonitor.convert(monitor, discoveryStrategies.size() * 1000);
		for (AbstractDiscoveryStrategy discoveryStrategy : discoveryStrategies) {
			if (monitor.isCanceled()) {
				break;
			}
			SubMonitor childProgress = progress.newChild(1000);
			if (discoveryStrategy instanceof MarketplaceDiscoveryStrategy) {
				MarketplaceDiscoveryStrategy marketplaceDiscoveryStrategy = (MarketplaceDiscoveryStrategy) discoveryStrategy;
				Map<String, IInstallableUnit> ius = marketplaceDiscoveryStrategy.computeInstalledIUs(childProgress);
				installedIUs.putAll(ius);
			}
			childProgress.setWorkRemaining(0);
		}
		return installedIUs;
	}

	protected IStatus checkForUpdates(List<MarketplaceNodeCatalogItem> updateCheckNeeded,
			final Map<String, IInstallableUnit> installedIUs, final IProgressMonitor monitor) {
		Map<URI, List<MarketplaceNodeCatalogItem>> installedCatalogItemsByUpdateUri = new HashMap<>();

		for (MarketplaceNodeCatalogItem catalogItem : updateCheckNeeded) {
			INode node = catalogItem.getData();
			String updateurl = node.getUpdateurl();
			try {
				if (updateurl == null) {
					catalogItem.setAvailable(false);
					continue;
				}
				URI uri = new URI(updateurl);
				List<MarketplaceNodeCatalogItem> catalogItemsThisSite = installedCatalogItemsByUpdateUri.get(uri);
				if (catalogItemsThisSite == null) {
					catalogItemsThisSite = new ArrayList<>();
					installedCatalogItemsByUpdateUri.put(uri, catalogItemsThisSite);
				}
				catalogItemsThisSite.add(catalogItem);
			} catch (URISyntaxException e) {
				MarketplaceClientUi.log(IStatus.WARNING,
						Messages.MarketplaceCatalog_InvalidRepositoryUrl, node.getName(), updateurl);
				catalogItem.setAvailable(false);
			}
		}
		if (installedCatalogItemsByUpdateUri.isEmpty()) {
			return Status.OK_STATUS;
		}

		ConcurrentTaskManager executor = new ConcurrentTaskManager(installedCatalogItemsByUpdateUri.size(),
				Messages.MarketplaceCatalog_checkingForUpdates);
		try {
			final IProgressMonitor pm = new NullProgressMonitor() {
				@Override
				public boolean isCanceled() {
					return super.isCanceled() || monitor.isCanceled();
				}
			};
			for (Map.Entry<URI, List<MarketplaceNodeCatalogItem>> entry : installedCatalogItemsByUpdateUri.entrySet()) {
				final URI uri = entry.getKey();
				final List<MarketplaceNodeCatalogItem> catalogItemsThisSite = entry.getValue();
				executor.submit(() -> {
					ProvisioningSession session = ProvisioningUI.getDefaultUI().getSession();
					IMetadataRepositoryManager manager = (IMetadataRepositoryManager) session.getProvisioningAgent()
							.getService(IMetadataRepositoryManager.SERVICE_NAME);
					try {
						for (MarketplaceNodeCatalogItem item1 : catalogItemsThisSite) {
							if (Boolean.TRUE.equals(item1.getAvailable())) {
								item1.setAvailable(null);
							}
						}
						IMetadataRepository repository = manager.loadRepository(uri, pm);
						IQuery<IInstallableUnit> query = QueryUtil.createMatchQuery( //
								"id ~= /*.feature.group/ && " + //$NON-NLS-1$
								"properties['org.eclipse.equinox.p2.type.group'] == true ");//$NON-NLS-1$
						IQueryResult<IInstallableUnit> result = repository.query(query, pm);

						// compute highest version for all available IUs.
						Map<String, Version> repositoryIuVersionById = new HashMap<>();
						for (IInstallableUnit iu : result) {
							String key1 = createRepositoryIuKey(uri.toString(), iu.getId());
							Version version = iu.getVersion();
							Version priorVersion = repositoryIuVersionById.put(key1, version);
							if (priorVersion != null && priorVersion.compareTo(version) > 0) {
								repositoryIuVersionById.put(key1, priorVersion);
							}
						}

						for (MarketplaceNodeCatalogItem item2 : catalogItemsThisSite) {
							List<MarketplaceNodeInstallableUnitItem> installableUnitItems = item2
									.getInstallableUnitItems();
							for (MarketplaceNodeInstallableUnitItem iuItem : installableUnitItems) {
								String key2 = createRepositoryIuKey(uri.toString(), iuItem.getId());
								Version availableVersion = repositoryIuVersionById.get(key2);
								MarketplaceCatalog.this.repositoryIuVersionById.put(key2, availableVersion);
								if (availableVersion != null) {
									item2.setAvailable(true);
								}
							}
						}
						for (MarketplaceNodeCatalogItem item3 : catalogItemsThisSite) {
							setUpdatesAvailable(installedIUs, item3);
						}

					} catch (ProvisionException e1) {
						MultiStatus errorStatus = new MultiStatus(MarketplaceClientUi.BUNDLE_ID, IStatus.WARNING,
								NLS.bind(Messages.MarketplaceCatalog_ErrorReadingRepository, uri), e1);
						for (MarketplaceNodeCatalogItem item4 : catalogItemsThisSite) {
							item4.setAvailable(false);
							errorStatus.add(MarketplaceClientUi.newStatus(IStatus.INFO, item4.getName()));
						}
						MarketplaceClientUi.getLog().log(errorStatus);
					} catch (OperationCanceledException e2) {
						// nothing to do
					}
				});
			}
			try {
				executor.waitUntilFinished(monitor);
			} catch (CoreException e) {
				MarketplaceClientUi.error(e);
				return e.getStatus();
			}
			return Status.OK_STATUS;
		} finally {
			executor.shutdownNow();
		}
	}

	private String createRepositoryIuKey(String uri, String id) {
		return uri + "!" + id; //$NON-NLS-1$
	}

	private boolean setUpdatesAvailable(Map<String, IInstallableUnit> installedIUs, MarketplaceNodeCatalogItem item) {
		boolean needOnlineCheck = false;
		List<MarketplaceNodeInstallableUnitItem> installableUnitItems = item.getInstallableUnitItems();
		for (MarketplaceNodeInstallableUnitItem iuItem : installableUnitItems) {
			String key = createRepositoryIuKey(item.getSiteUrl(), iuItem.getId());
			Version availableVersion = repositoryIuVersionById.get(key);
			iuItem.setUpdateAvailable(false);
			iuItem.setAvailable(false);
			if (availableVersion != null) {
				iuItem.setAvailable(true);
				IInstallableUnit installedIu = installedIUs.get(iuItem.getId());
				if (installedIu != null && installedIu.getVersion().compareTo(availableVersion) < 0) {
					iuItem.setUpdateAvailable(true);
				}
			} else if (!repositoryIuVersionById.containsKey(key)) {
				needOnlineCheck = true;
			}
		}
		return needOnlineCheck;
	}

	@Override
	public IStatus performDiscovery(IProgressMonitor monitor) {
		SubMonitor progress = SubMonitor.convert(monitor, 200000);
		IStatus status = super.performDiscovery(progress.newChild(100000));

		//check for updates
		if (status.getSeverity() < IStatus.ERROR) {
			IStatus updateStatus = checkForUpdates(progress.newChild(100000));
			if (!updateStatus.isOK()) {
				if (status.isOK()) {
					status = updateStatus;
				} else {
					MultiStatus multiStatus = new MultiStatus(MarketplaceClientUi.BUNDLE_ID, 0,
							Messages.MarketplaceCatalog_Discovery_Error, null);
					multiStatus.add(status);
					multiStatus.add(updateStatus);
					status = multiStatus;
				}
			}
		}
		return computeStatus(status);
	}

	private IStatus computeStatus(IStatus status) {
		if (status.getSeverity() == IStatus.ERROR) {
			// unwrap a multistatus with one child see bug 309612
			if (status.isMultiStatus()) {
				MultiStatus multiStatus = (MultiStatus) status;
				if (multiStatus.getChildren().length == 1) {
					status = multiStatus.getChildren()[0];
				}
			}
			if (!status.isMultiStatus()) {
				Throwable exception = status.getException();
				IStatus newStatus = MarketplaceClientCore.computeWellknownProblemStatus(exception);
				if (newStatus != null) {
					return newStatus;
				}
			}
		}
		return status;
	}

	protected IStatus performDiscovery(DiscoveryOperation operation, boolean refresh, IProgressMonitor monitor) {
		SubMonitor progress = SubMonitor.convert(monitor, Messages.MarketplaceCatalog_queryingMarketplace, 100);

		// reset, keeping no items but the same tags, categories and certifications
		List<CatalogItem> items = new ArrayList<>();
		List<CatalogCategory> categories = new ArrayList<>(getCategories());
		List<Certification> certifications = new ArrayList<>(getCertifications());
		List<Tag> tags = new ArrayList<>(getTags());
		if (!refresh) {
			for (CatalogCategory catalogCategory : categories) {
				catalogCategory.getItems().clear();
			}
		}
		progress.worked(1);

		try {
			IStatus status = runDiscoveryOperation(operation, items, categories, certifications, tags,
					progress.newChild(98));
			update(categories, items, certifications, tags);
			progress.worked(1);
			return status;
		} finally {
			progress.done();
		}
	}

	private IStatus runDiscoveryOperation(DiscoveryOperation operation, List<CatalogItem> items,
			List<CatalogCategory> categories, List<Certification> certifications, List<Tag> tags,
			IProgressMonitor monitor) {
		MultiStatus status = new MultiStatus(MarketplaceClientUi.BUNDLE_ID, 0, Messages.MarketplaceCatalog_queryFailed,
				null);
		if (getDiscoveryStrategies().isEmpty()) {
			throw new IllegalStateException();
		}

		final int strategyCount = getDiscoveryStrategies().size();
		final int strategyTicks = 100;
		SubMonitor progress = SubMonitor.convert(monitor, Messages.MarketplaceCatalog_queryingMarketplace,
				strategyTicks * strategyCount);
		try {
			for (AbstractDiscoveryStrategy discoveryStrategy : getDiscoveryStrategies()) {
				if (progress.isCanceled()) {
					status.add(Status.CANCEL_STATUS);
					break;
				}
				if (discoveryStrategy instanceof MarketplaceDiscoveryStrategy) {
					List<CatalogCategory> oldCategories = discoveryStrategy.getCategories();
					List<CatalogItem> oldItems = discoveryStrategy.getItems();
					List<Certification> oldCertifications = discoveryStrategy.getCertifications();
					List<Tag> oldTags = discoveryStrategy.getTags();

					discoveryStrategy.setCategories(categories);
					discoveryStrategy.setItems(items);
					discoveryStrategy.setCertifications(certifications);
					discoveryStrategy.setTags(tags);
					try {
						MarketplaceDiscoveryStrategy marketplaceStrategy = (MarketplaceDiscoveryStrategy) discoveryStrategy;
						operation.run(marketplaceStrategy, progress.newChild(strategyTicks));

					} catch (CoreException e) {
						IStatus error = MarketplaceClientCore.computeWellknownProblemStatus(e);
						if (error == null) {
							error = new Status(e.getStatus().getSeverity(), DiscoveryCore.ID_PLUGIN, NLS.bind(
									Messages.MarketplaceCatalog_failedWithError, discoveryStrategy.getClass()
									.getSimpleName()), e);
						}
						status.add(error);
					} finally {
						// remove everything from strategy again, so it can't accidentally mess with the results later
						discoveryStrategy.setCategories(oldCategories);
						discoveryStrategy.setItems(oldItems);
						discoveryStrategy.setCertifications(oldCertifications);
						discoveryStrategy.setTags(oldTags);

						// make sure strategy didn't misbehave
						if (items.contains(null)) {
							while (items.remove(null)) {
							}
							IStatus error = new Status(IStatus.WARNING, DiscoveryCore.ID_PLUGIN,
									NLS.bind(Messages.MarketplaceCatalog_addedNullEntry, discoveryStrategy.getClass().getSimpleName()));
							status.add(error);
						}
					}
				}
			}
		} finally {
			monitor.done();
		}
		return computeStatus(status);
	}

	public IStatus performNewsDiscovery(IProgressMonitor monitor) {
		if (getDiscoveryStrategies().isEmpty()) {
			throw new IllegalStateException();
		}

		INews news = null;

		MultiStatus status = new MultiStatus(MarketplaceClientUi.BUNDLE_ID, 0, Messages.MarketplaceCatalog_queryFailed,
				null);
		final int totalTicks = 100000;
		final SubMonitor progress = SubMonitor.convert(monitor, Messages.MarketplaceCatalog_Checking_News, totalTicks);
		try {
			int strategyTicks = totalTicks / getDiscoveryStrategies().size();
			for (AbstractDiscoveryStrategy discoveryStrategy : getDiscoveryStrategies()) {
				if (monitor.isCanceled()) {
					status.add(Status.CANCEL_STATUS);
					break;
				}
				if (discoveryStrategy instanceof MarketplaceDiscoveryStrategy) {
					try {
						MarketplaceDiscoveryStrategy marketplaceStrategy = (MarketplaceDiscoveryStrategy) discoveryStrategy;
						news = marketplaceStrategy.performNewsDiscovery(progress.newChild(strategyTicks));
						if (news != null) {
							break;
						}
					} catch (CoreException e) {
						status.add(new Status(e.getStatus().getSeverity(), DiscoveryCore.ID_PLUGIN, NLS.bind(
								Messages.MarketplaceCatalog_failedWithError, discoveryStrategy.getClass()
								.getSimpleName()), e));
					}
				}
			}
		} finally {
			monitor.done();
		}
		if (status.isOK()) {
			setNews(news);
		}
		return status;
	}

	/**
	 * Report an error for an attempted install
	 *
	 * @param result
	 *            the result of the install operation
	 * @param items
	 *            the catalog items to be installed
	 * @param operationIUs
	 *            the computed IUs that were part of the provisioning operation
	 * @param resolutionDetails
	 *            the detailed error message, or null
	 */
	public void installErrorReport(IProgressMonitor monitor, IStatus result, Set<CatalogItem> items,
			IInstallableUnit[] operationIUs, String resolutionDetails) {
		for (AbstractDiscoveryStrategy discoveryStrategy : getDiscoveryStrategies()) {
			if (discoveryStrategy instanceof MarketplaceDiscoveryStrategy) {
				try {
					((MarketplaceDiscoveryStrategy) discoveryStrategy).installErrorReport(monitor, result, items,
							operationIUs, resolutionDetails);
				} catch (CoreException e) {
					// log only
					MarketplaceClientUi.error(e);
				}
			}
		}
	}

	public INews getNews() {
		return news;
	}

	public void setNews(INews news) {
		this.news = news;
	}

	public List<IMarket> getMarkets() {
		List<IMarket> markets = new ArrayList<>();
		for (CatalogCategory category : getCategories()) {
			if (category instanceof MarketplaceCategory) {
				MarketplaceCategory marketplaceCategory = (MarketplaceCategory) category;
				for (IMarket market : marketplaceCategory.getMarkets()) {
					if (!markets.contains(market)) {
						markets.add(market);
					}
				}
			}
		}
		return markets;
	}

	public List<MarketplaceNodeCatalogItem> getAvailableUpdates() {
		return availableUpdates;
	}

	public void removeItem(CatalogItem item) {
		getItems().remove(item);
		getFilteredItems().remove(item);
		getAvailableUpdates().remove(item);
		for (CatalogCategory category : getCategories()) {
			category.getItems().remove(item);
		}
	}
}