//------------------------------------------------------------------------------
// 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 java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.epf.common.utils.StrUtil;
import org.eclipse.epf.library.edit.PresentationContext;
import org.eclipse.epf.library.edit.util.MethodElementUtil;
import org.eclipse.epf.library.edit.util.ModelStructure;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.Discipline;
import org.eclipse.epf.uma.DisciplineGrouping;
import org.eclipse.epf.uma.Domain;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessPackage;

/**
 * A helper class for managing element filtering in the method element selection
 * dialogs.
 * 
 * @author Shashidhar Kannoori
 * @author Phong Nguyen Le
 * @since 1.0
 */
public class FilterHelper {

	private String pattern;

	private String type;

	private Pattern regex;

	private String tabStr;

	private Object contentElement;

	private List existingElements = new ArrayList();

	private boolean showPresentationName = false;
	
	// This is separate handling for ContentContegory 
	private String contentCategoryTabStr;

	public FilterHelper(Object contentElement, String tabStr, String pattern,

	String filterTypeStr, List alreadySelectedList) {

		this.contentElement = contentElement;

		this.tabStr = tabStr;

		this.type = filterTypeStr;

		this.existingElements = alreadySelectedList;

		this.pattern = pattern;

		showPresentationName = PresentationContext.INSTANCE
		.isShowPresentationNames();


	}
	/*
	 * method to set contentCategoryTabStr, this 
	 * special handle for content category, tabStr implementation 
	 * donot work for this. 
	 */
	public void setContentCategoryTabStr(String contentCategoryTabStr){
		this.contentCategoryTabStr = contentCategoryTabStr;
	}
	/*
	 * method to set contentCategoryTabStr, this 
	 * special handle for content category, tabStr implementation 
	 * donot work for this. 
	 */
	public String getContentCategoryTabStr(){
		return this.contentCategoryTabStr;
	}

	public List getAlreadySelectedList() {

		return existingElements;

	}

	public void setAlreadySelectedList(List alreadySelectedList) {

		this.existingElements = alreadySelectedList;

	}

	public boolean matchPattern(Object obj) {
		return match(obj);
	}

	/*
	 * Convenient method to check any CategorizedElements (tree traversal) of
	 * CustomCategory has any match with matcher. @param CustomCategory
	 */
	private boolean hasMatchedChildCustomCategory(CustomCategory topCategory) {
		List list = topCategory.getCategorizedElements();

		for (Iterator iter = list.iterator(); iter.hasNext();) {
			Object object = iter.next();
			if (object instanceof CustomCategory) {
				CustomCategory category = (CustomCategory) object;
				if (matcher(category)) {
					return true;
				} else if (hasMatchedChildCustomCategory(category)) {
					return true;
				}
			}
		}
		return false;
	}

	/*
	 * Convenient method to check any subArtifacts (tree traversal) of Artifact
	 * has any match with matcher. @param CustomCategory
	 */
	private boolean hasMatchedArtifact(Artifact artifact) {

		List list = artifact.getContainedArtifacts();
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			Object object = iter.next();
			if (object instanceof Artifact) {
				Artifact subartifact = (Artifact) object;
				if (matcher(subartifact)) {
					return true;
				} else if (hasMatchedArtifact(subartifact)) {
					return true;
				}
			}
		}
		return false;
	}
	
	/*
	 * Convenient method to check any subArtifacts (tree traversal) of Artifact
	 * has any match with  alreadyexisting elements.
	 */
	private boolean hasMatchedArtifact(Artifact artifact, List existingList) {

		List list = artifact.getContainedArtifacts();
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			Object object = iter.next();
			if (object instanceof Artifact) {
				Artifact subartifact = (Artifact) object;
				if(!existingList.contains(subartifact)){
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * Convenient method to check any ChildPackages (tree traversal) of Content
	 * Package has any match with matcher.
	 * 
	 * @param CustomCategory
	 */
	private boolean hasMatchedChild(ContentPackage pkg) {

		for (Iterator iter = pkg.getChildPackages().iterator(); iter.hasNext();) {
			Object childPkg = iter.next();
			if (childPkg instanceof ContentPackage) {
				ContentPackage contentPkg = (ContentPackage) childPkg;
				if (matcher(contentPkg)) {
					return true;
				} else if (hasMatchedChild(contentPkg)) {
					return true;
				}
			}
		}
		return false;

	}

	/**
	 * Convenient method to check any subDomain (tree traversal) of Domain has
	 * any match with matcher <link>matcher(Object obj)</link>
	 * 
	 * @param CustomCategory
	 */
	private boolean hasMatchedSubDomains(Domain domain) {
		List list = domain.getSubdomains();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object subdomain = iterator.next();
			if (matcher(subdomain)) {
				return true;
			} else if (hasMatchedSubDomains((Domain) subdomain)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 
	 */
	private boolean hasMatchedSubDiscipline(Discipline discipline){
		List list = discipline.getSubdiscipline();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object subdiscipline = iterator.next();
			if (matcher(subdiscipline)) {
				return true;
			} else if (hasMatchedSubDiscipline((Discipline) subdiscipline)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 
	 */
	private boolean hasMatchedDisciplines(DisciplineGrouping grouping){
		List list = grouping.getDisciplines();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object subdiscipline = iterator.next();
			if (matcher(subdiscipline)) {
				return true;
			} else if (hasMatchedSubDiscipline((Discipline) subdiscipline)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Convenient method to check any activity (tree traversal) of activity has
	 * any match with matcher <link>matcher(Object obj)</link>
	 * 
	 * @param CustomCategory
	 */
	private boolean hasMatchedActivities(Activity activity) {
		List list = activity.getBreakdownElements();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			if (element instanceof Activity) {
				if (matcher(element)) {
					return true;
				} else if (hasMatchedActivities((Activity) element)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * Convenient method to check any activity (tree traversal) of ProcessPackage has
	 * any match with matcher <link>matcher(Object obj)</link>
	 * 
	 * @param CustomCategory
	 */
	private boolean hasMatchedActivities(ProcessPackage procPackage) {
		if(procPackage instanceof ProcessComponent) {
			Process proc = ((ProcessComponent) procPackage).getProcess();
			if(proc != null && (matcher(proc) || hasMatchedActivities(proc))) {
				return true;
			}
		}
		
		// check child packages
		List<?> list = procPackage.getChildPackages();
		for (Iterator<?> iterator = list.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			if (element instanceof ProcessPackage) {
				if (hasMatchedActivities((ProcessPackage) element)) {
					return true;
				}
			}
		}
		return false;
	}


	public String getFilterTypeStr() {

		// Trim "-"(hyphen) from the strings (types).  Only in case methodplugin
		// don't trim "-" because methodplug-in contain "-" (hyphen)and useful.
		while (type != null && type.indexOf(FilterConstants.space) > -1
				&& !type.equals(FilterConstants.METHO_PLUGINS)) {
			type = type.substring(type.indexOf(FilterConstants.space) + 1, type
					.length());
		}
		return type;
	}

	public String getPattern() {

		return pattern;

	}

	public Pattern getRegexPattern() {

		return regex;

	}

	public String getTabStr() {

		return tabStr;

	}

	/*
	 * 
	 * Method checks whether arbitrary object passed is
	 * 
	 * equal to current content element's variability or not.
	 * 
	 * If variability of ContentElement matches arbitrary object,
	 * 
	 * returns true.
	 * 
	 * @retun boolean.
	 * 
	 */

	public boolean checkVariability(Object obj) {
		if (contentElement instanceof ContentElement) {

			Object variabilityObject = ((ContentElement) contentElement)
					.getVariabilityBasedOnElement();
			if (variabilityObject != null) {
				if (obj.equals(variabilityObject))
					return true;
			}
		}
		return false;
	}

	public Object getContentElement() {

		return contentElement;

	}

	public void setContentElement(Object contentElement) {

		this.contentElement = contentElement;

	}

	public void setFilterTypeStr(String filterTypeStr) {

		this.type = filterTypeStr;

	}

	public void setPattern(String pattern) {

		this.pattern = pattern;

	}

	public void setRegexPattern(Pattern regexPattern) {

		this.regex = regexPattern;

	}

	public void setTabStr(String tabStr) {

		this.tabStr = tabStr;

	}

	public String[] getPathBasedOnTabString(String tabStr) {

		if (FilterConstants.contentElementStrs.contains(tabStr)) {
			return ModelStructure.DEFAULT.coreContentPath;
		} else if (tabStr.equals(FilterConstants.ROLESETS)
				|| tabStr.equals(FilterConstants.ROLE_SET_GROUPINGS)) {
			return ModelStructure.DEFAULT.roleSetPath;
		} else if (tabStr.equals(FilterConstants.DISCIPLINES)
				|| tabStr.equals(FilterConstants.DISCIPLINE_GROUPINGS)) {
			return ModelStructure.DEFAULT.disciplineDefinitionPath;
		} else if (tabStr.equals(FilterConstants.TOOLS)) {
			return ModelStructure.DEFAULT.toolPath;
		} else if (tabStr.equals(FilterConstants.WORKPRODUCTTYPES)) {
			return ModelStructure.DEFAULT.workProductTypePath;
		} else if (tabStr.equals(FilterConstants.DOMAINS)) {
			return ModelStructure.DEFAULT.domainPath;
		} else if (tabStr.equals(FilterConstants.CUSTOM_CATEGORIES)) {
			return ModelStructure.DEFAULT.customCategoryPath;
		} else
			return ModelStructure.DEFAULT.coreContentPath;

	}

	/**
	 * 
	 * This is convenient method to check all the condition, like matchPattern,
	 * if object exists in already selected list, check variability match, and
	 * is object itself donot display.
	 * 
	 * @param object
	 * @return boolean
	 */

	public boolean checkObjectAccepted(Object obj) {

		if (!match(obj))
			return false;
		// Check if already existing (associated elements) don't display.
		if (getAlreadySelectedList() != null
				&& getAlreadySelectedList().contains(obj)){
			// special case handling for Artifact and sub-artifact.
			if(obj instanceof Artifact){
				if(!hasMatchedArtifact((Artifact)obj,getAlreadySelectedList()))
					return false;
			}else{
				return false;
			}
		}

		if (checkVariability(obj))
			return false;

		// if object itself don't display
		// Do equal check only on elements otherthan method plugin, In case of
		// Copyright(supporting material) associating to methodplugin, if
		// methodplugin (contentElemtn) equals
		// obj, then results false.Plugin will lost from tree in the filter. In
		// turn supporting material for that particular plugin will not be
		// displayed.
		if (!(obj instanceof MethodPlugin)) {
			if (contentElement != null && obj.equals(contentElement))
				return false;
		}
		return true;

	}

	/**
	 * 
	 * Convenient method for checking MethodPlugin accepted or not. Method needs
	 * to invoked only for MethodPlugin object.
	 * 
	 * @param object
	 * @return boolean
	 */

	public boolean acceptMethodPlugin(Object obj) {
		if (contentElement != null) {
			if (MethodElementUtil.getAllModels(contentElement).contains(obj))
				return true;
			else
				return false;
		} else {
			return true;
		}
	}

	/**
	 * Convenient method for checking Content Package accepted or not. Method
	 * needs to invoked only for Content Package object.
	 * 
	 * @param object
	 * @return boolean
	 */
	public boolean acceptContentPackage(Object obj) {

		if (((ContentPackage) obj).getChildPackages().isEmpty()
				&& ((ContentPackage) obj).getContentElements().isEmpty())
			return false;
		else
			return true;
	}

	public boolean isObjectInSelectedItems(Object obj) {

		if (getAlreadySelectedList() != null
				&& getAlreadySelectedList().contains(obj))
			return false;
		else
			return true;
	}

	public boolean isContributor(ContentElement element) {
		// Just returning true, because contribution checked in other place.
		return false;
	}

	public boolean matchPatternBasedOnType(Object obj) {
		return match(obj);
	}

	public boolean matchPatternOnPresentationName(Object obj) {
		return match(obj);
	}

	public boolean isShowPresentationName() {
		return showPresentationName;
	}

	public void setShowPresentationName(boolean showPresentationName) {
		this.showPresentationName = showPresentationName;
	}

	/**
	 * Generic method to check match of an object based on regular expression
	 * also based on type that selected in the dialog.
	 */

	private boolean match(Object obj) {

		// Do not do Pattern match if type or pattern string is null.
		if (type == null) {
			return true;
		}
		if (pattern == null || pattern.equalsIgnoreCase(StrUtil.EMPTY_STRING)) {
			if(type.equals(FilterConstants.ACTIVITIES) && obj instanceof ProcessPackage) {
				ProcessPackage pkg = (ProcessPackage) obj;
				
				// filter out package without any process
				//
				if(!pkg.getChildPackages().isEmpty()) {
					AbstractTreeIterator<MethodPackage> iterator = new AbstractTreeIterator<MethodPackage>(pkg) {

						private static final long serialVersionUID = 1L;

						@Override
						protected Iterator<? extends MethodPackage> getChildren(
								Object object) {
							return ((MethodPackage) object).getChildPackages().iterator();
						}

					};
					while(iterator.hasNext()) {
						MethodPackage childPkg = iterator.next();
						if(childPkg instanceof ProcessComponent && ((ProcessComponent) childPkg).getProcess() != null) {
							return true;
						}
					}
				}

				return false;
			}
			return true;
		}

		// Check if type is of Content Package
		if (type.equals(FilterConstants.CONTENT_PACKAGES)) {

			if (obj instanceof ContentPackage) {

				if (matcher(obj) || hasMatchedChild((ContentPackage) obj)) {
					return true;
				} else {
					return false;
				}

			} else {

				// else for all content elements, if their content pakcage
				// matches , return true.
				if (obj instanceof ContentElement) {
					Object container = ((ContentElement) obj).getContainer();
					if (container instanceof ContentPackage) {
						if (!matcher(container))
							return false;
					}
				}
				return true;
			}

		} else if (type.equals(FilterConstants.METHO_PLUGINS)) {
			// Check if type is of Method Plugins
			if (obj instanceof MethodPlugin) {
				// if is a MethodPlugin, return true if matches the pattern
				return matcher(obj);

			} else {
				return true;
			}

		} else if (type.equals(FilterConstants.ACTIVITIES)) {
			if (obj instanceof Activity) {
				if (matcher(obj)) {
					return true;
				} else {
					return hasMatchedActivities((Activity)obj);
				}
			} else if (obj instanceof ProcessPackage) {
				return hasMatchedActivities((ProcessPackage)obj);
			} else {
				return true;
			}
		} else if (type != null) {

			if (obj instanceof ContentElement
					|| obj instanceof ProcessComponent
					|| obj instanceof Process) {

				if (type.indexOf(FilterConstants.space) > -1) {
					type = type.substring(type.indexOf(FilterConstants.space), type.length());
				}

				Class cls = FilterInitializer.getInstance().getClassForType(
						type);
				if (cls != null && !cls.isInstance(obj)) {
					return true;
				}

				if (matcher(obj)) {
					return true;
				} else {

					if (obj instanceof CustomCategory)
						return hasMatchedChildCustomCategory((CustomCategory) obj);

					if (obj instanceof Artifact) {
						return hasMatchedArtifact((Artifact) obj);
					}
					if (obj instanceof Domain) {
						return hasMatchedSubDomains((Domain) obj);
					}
					if (obj instanceof Discipline){
						return hasMatchedSubDiscipline((Discipline)obj);
					}
					if (obj instanceof DisciplineGrouping){
						return hasMatchedDisciplines((DisciplineGrouping)obj);
					}
					return false;
				}
			} else { // else for all other types of elements
				return true;
			}

		} else
			// the All case
			return true;
	}

	/**
	 * Convenient method which does actual matching of given object with regular
	 * expression. Checks to do presentationname or name.
	 */
	public boolean matcher(Object obj) {
		if(regex != null){
			Matcher m = regex.matcher(((MethodElement) obj).getName());
			if (showPresentationName) {
				if (obj instanceof DescribableElement
						&& ((DescribableElement) obj).getPresentationName() != null)
					m = regex.matcher(((DescribableElement) obj)
							.getPresentationName());
			}
			return m.matches();
		}
		return true;
	}
}