//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------

package org.eclipse.epf.library.edit.itemsfilter;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.epf.library.edit.LibraryEditPlugin;
import org.eclipse.epf.library.edit.util.PracticePropUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.Deliverable;
import org.eclipse.epf.uma.Domain;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Practice;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.util.AssociationHelper;
import org.eclipse.epf.uma.util.UserDefinedTypeMeta;

/**
 * This is a filter for variability base element selection. The filter will
 * check if object can be accepted as the base element of the filter owner.
 * 
 * Filter rules:
 * 
 * 1. The element itself and it's generalizers (contributor, replacer, or
 * extender) should be filtered out
 * 2. Any elements in the containment chain of the above, should be filtered
 * out
 * 3. if any of the base elements can't be selected, then this element can't
 * be selected.
 * 
 * @author Jinhua Xi
 * @since 1.0
 */
public class VariabilityBaseElementFilter implements
		org.eclipse.epf.library.edit.IFilter {

	private VariabilityElement element;

	private List badguys = new ArrayList();

	public VariabilityBaseElementFilter(VariabilityElement element) {
		this.element = element;

		// first of all, you can't vary yourself
		badguys.add(element);

		// get all my generalizers
		Iterator it = TngUtil.getGeneralizers(element);
		while (it.hasNext()) {
			VariabilityElement ve = (VariabilityElement) it.next();
			badguys.add(ve);

			// the containment chain on my generalizers can't be my base
			handleContainmentChain(ve);
		}

		// element's in my chain can't be my base
		handleContainmentChain(element);
	}

	private void handleContainmentChain(VariabilityElement e) {
		if (!hasContainmentFeature()) {
			return;
		}

		if (e instanceof CustomCategory) {
			List roots = new ArrayList();
			loadRootCustomCategories((CustomCategory) e, roots);
			badguys.addAll(roots);
		} else if (e instanceof Deliverable) {
			List roots = new ArrayList();
			deliverableParts((Deliverable) e, roots);
			badguys.addAll(roots);
		} else {
			// if the element has containment feature,
			// you can't select the element in the containment chain
			EObject root = getChainRoot(e);
			if (!badguys.contains(root)) {
				badguys.add(root);
			}

			/*
			 * hold off for now // also only one element in a chain can be
			 * selected as base // so get all the base elements in the element
			 * chain, and block the element chain of the base elements
			 * filterUsedBaseChain((VariabilityElement)root); for (Iterator it =
			 * root.eAllContents(); it.hasNext(); ) { Object o = it.next(); if (
			 * o.getClass().isInstance(element) ) {
			 * filterUsedBaseChain((VariabilityElement)o); } }
			 */
		}

	}

	private void deliverableParts(Deliverable e, List roots) {
		List list = ((Deliverable) e).getDeliveredWorkProducts();
		if (list != null && list.size() > 0) {
			for (Iterator iterator = list.iterator(); iterator.hasNext();) {
				Object obj = iterator.next();
				if (obj instanceof Deliverable) {
					roots.add(obj);
					deliverableParts((Deliverable) obj, roots);
				}
			}
		}
	}

	private void loadRootCustomCategories(CustomCategory e, List roots) {
		List cs = AssociationHelper.getCustomCategories(e);
		if (cs != null && cs.size() > 0) {
			for (Iterator it = cs.iterator(); it.hasNext();) {
				CustomCategory cc = (CustomCategory) it.next();
				if (!TngUtil.isRootCustomCategory(cc)) {
					loadRootCustomCategories(cc, roots);
				} else {
					if (!roots.contains(e)) {
						roots.add(e);
					}
					break;
				}
			}
		} else if (!roots.contains(e)) {
			roots.add(e);
		}
	}

	// private void filterUsedBaseChain(VariabilityElement e) {
	// VariabilityElement base = e.getVariabilityBasedOnElement();
	// if (base != null) {
	// // if the element chain is selected as base in the current chain,
	// // no element in that chain can be futher selected
	// Object root = getChainRoot(base);
	// if (!badguys.contains(root)) {
	// badguys.add(root);
	// }
	// }
	// }

	private boolean hasContainmentFeature() {
		return element instanceof Domain || element instanceof CustomCategory
				|| element instanceof Artifact || element instanceof Practice
				|| element instanceof Deliverable;
	}

	private EObject getChainRoot(MethodElement e) {
		EObject root = e;
		Object type = element.getType();
		EObject parent = e;
		while ((parent = parent.eContainer()) != null
				&& ((MethodElement) parent).getType() == type) {
			root = parent;
		}

		return root;
	}

	public boolean accept(Object obj) {

		// always accept packages
		if (obj instanceof MethodLibrary || obj instanceof MethodPlugin
				|| obj instanceof MethodPackage
				|| obj instanceof MethodConfiguration) {
			return true;
		}

		// must be variability element and can't be itself
		if (obj == element || !(obj instanceof VariabilityElement)) {
			return false;
		}

		// must be the same type
		VariabilityElement ve = (VariabilityElement) obj;
		if (ve.getType() != element.getType()) {
			return false;
		}
		
		if (element instanceof Practice && ve instanceof Practice) {
			Practice p1 = (Practice) element;
			Practice p2 = (Practice) ve;
			PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
			UserDefinedTypeMeta meta1 = null;
			UserDefinedTypeMeta meta2 = null;
			try {
				meta1 = propUtil.getUtdData(p1);
				meta2 = propUtil.getUtdData(p2);
			} catch (Exception e) {
				LibraryEditPlugin.getDefault().getLogger().logError(e);
			}
			if (meta1 != null && meta2 != null) {
				if (! meta1.getId().equals(meta2.getId())) {
					return false;
				}
			} else if (!(meta1 == null && meta2 == null)) {
				return false;
			}
		}

		// can't be my any of my generalizers
		if (badguys.contains(obj)) {
			return false;
		}

		// if this element's base chain is a badguy, can't accept, otherwise, a
		// circular lock
		while ((ve = ve.getVariabilityBasedOnElement()) != null) {
			if (badguys.contains(ve)) {
				return false;
			}
		}
		// anything else ?
		return true;
	}

}