/*******************************************************************************
 * Copyright (c) 2000, 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
 *******************************************************************************/
package org.eclipse.ui;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Adapters;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;

/**
 * A resource working set filter filters resources from a view that
 * are neither a parent nor children of a working set element.
 *
 * @since 2.0
 */
public class ResourceWorkingSetFilter extends ViewerFilter {
	private IWorkingSet workingSet = null;

	private IAdaptable[] cachedWorkingSet = null;

	/**
	 * Returns the active working set the filter is working with.
	 *
	 * @return the active working set
	 */
	public IWorkingSet getWorkingSet() {
		return workingSet;
	}

	/**
	 * Sets the active working set.
	 *
	 * @param workingSet the working set the filter should work with
	 */
	public void setWorkingSet(IWorkingSet workingSet) {
		this.workingSet = workingSet;
	}

	/**
	 * Determines if an element should be filtered out.
	 *
	 * @see ViewerFilter#select(Viewer, Object, Object)
	 */
	@Override
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (workingSet == null || (workingSet.isAggregateWorkingSet() &&
				workingSet.isEmpty())) {
			return true;
		}

		IResource resource = Adapters.adapt(element, IResource.class);
		if (resource != null) {
			return isEnclosed(resource);
		}
		return true;
	}

	/**
	 * Returns if the given resource is enclosed by a working set element.
	 * The IContainmentAdapter of each working set element is used for the
	 * containment test. If there is no IContainmentAdapter for a working
	 * set element, a simple resource based test is used.
	 *
	 * @param element resource to test for enclosure by a working set
	 * 	element
	 * @return true if element is enclosed by a working set element and
	 * 	false otherwise.
	 */
	private boolean isEnclosed(IResource element) {
		IPath elementPath = element.getFullPath();
		IAdaptable[] workingSetElements = cachedWorkingSet;

		// working set elements won't be cached if select is called
		// directly, outside filter. fixes bug 14500.
		if (workingSetElements == null) {
			workingSetElements = workingSet.getElements();
		}

		for (IAdaptable workingSetElement : workingSetElements) {
			IContainmentAdapter containmentAdapter = workingSetElement.getAdapter(IContainmentAdapter.class);

			// if there is no IContainmentAdapter defined for the working
			// set element type fall back to using resource based
			// containment check
			if (containmentAdapter != null) {
				if (containmentAdapter.contains(workingSetElement, element,
						IContainmentAdapter.CHECK_CONTEXT
								| IContainmentAdapter.CHECK_IF_CHILD
								| IContainmentAdapter.CHECK_IF_ANCESTOR
								| IContainmentAdapter.CHECK_IF_DESCENDANT)) {
					return true;
				}
			} else if (isEnclosedResource(element, elementPath,
					workingSetElement)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Returns if the given resource is enclosed by a working set element.
	 * A resource is enclosed if it is either a parent of a working set
	 * element, a child of a working set element or a working set element
	 * itself.
	 * Simple path comparison is used. This is only guaranteed to return
	 * correct results for resource working set elements.
	 *
	 * @param element resource to test for enclosure by a working set
	 * 	element
	 * @param elementPath full, absolute path of the element to test
	 * @return true if element is enclosed by a working set element and
	 * 	false otherwise.
	 */
	private boolean isEnclosedResource(IResource element, IPath elementPath,
			IAdaptable workingSetElement) {
		IResource workingSetResource = null;

		if (workingSetElement.equals(element)) {
			return true;
		}
		workingSetResource = Adapters.adapt(workingSetElement, IResource.class);
		if (workingSetResource != null) {
			IPath resourcePath = workingSetResource.getFullPath();
			if (resourcePath.isPrefixOf(elementPath)) {
				return true;
			}
			if (elementPath.isPrefixOf(resourcePath)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Filters out elements that are neither a parent nor a child of
	 * a working set element.
	 *
	 * @see ViewerFilter#filter(Viewer, Object, Object[])
	 */
	@Override
	public Object[] filter(Viewer viewer, Object parent, Object[] elements) {
		Object[] result = null;
		if (workingSet != null) {
			cachedWorkingSet = workingSet.getElements();
		}
		try {
			result = super.filter(viewer, parent, elements);
		} finally {
			cachedWorkingSet = null;
		}
		return result;
	}
}
