package org.eclipse.epf.toolbox.libutil;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.epf.toolbox.ToolboxPlugin;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.DeliveryProcess;
import org.eclipse.epf.uma.Descriptor;
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.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.Task;

public class LibUtil {

	private static boolean debug = ToolboxPlugin.getDefault().isDebugging();
	private static LibUtil instance = new LibUtil();
	public static LibUtil getInstance() {
		return instance;
	}
	
	public static Set<Descriptor> collectDescriptors(MethodLibrary lib) {
		Set<Descriptor> descriptors = new HashSet<Descriptor>();
		if (lib == null) {
			return descriptors;
		}
		for (Iterator iter = lib.eAllContents(); iter.hasNext();) {
			EObject element = (EObject) iter.next();
			if (element instanceof Descriptor) {
				descriptors.add((Descriptor) element);
			}
		}
		return descriptors;
	}

	public static Set<Activity> collectActivities(Process proc) {
		Set<Activity> activities = new HashSet<Activity>();
		collectActivities(proc, activities);
		return activities;
	}
	
	private static void collectActivities(Activity act, Set<Activity> activities) {
		if (act == null) {
			return;
		}
		activities.add(act);
		for (BreakdownElement be : act.getBreakdownElements()) {
			if (be instanceof Activity) {
				collectActivities((Activity) be, activities);
			}
		}
	}
	
	public static Set<Process> collectProcesses(MethodLibrary lib) {
		Set<Process> processes = new HashSet<Process>();
		if (lib == null) {
			return processes;
		}
		for (Iterator iter = lib.eAllContents(); iter.hasNext();) {
			EObject element = (EObject) iter.next();
			if (element instanceof MethodElement) {
				try {
					for (Iterator iterator = element.eCrossReferences()
							.iterator(); iterator.hasNext();) {
						Object obj = iterator.next();
						if (obj instanceof MethodElement) {
							processElement((MethodElement) obj, processes);
						}
					}
				} catch (Exception e) {
					CommonPlugin.INSTANCE.log(e);
					if (debug) {
						System.err
								.println("Error iterate thru cross references of element: " + element); //$NON-NLS-1$
					}
				}
				
				processElement((MethodElement) element, processes);
			}
		}
		return processes;
	}

	public static void processElement(MethodElement element, Set<Process> processes) {
		if (element instanceof CapabilityPattern ||
			element instanceof DeliveryProcess) {
			Process process = (Process) element;
			if (process.eContainer() instanceof ProcessComponent) {
				processes.add((Process)element);
			}
		}
	}

	public static void trace(String line) {
		ToolboxPlugin.getDefault().getLogger().logInfo(line);
		System.out.println(line);
	}
	
	public class CollectElementFilter {
		public boolean accept(MethodElement element) {
			return true;
		}
		
		public boolean skipChildren(MethodElement element) {
			if (element instanceof MethodPlugin) {
				return false;
			}
			if (element instanceof MethodPackage) {
				return false;
			}
			
			return true;
		}
		
	}
	
	private void collectElements(MethodElement element,
			CollectElementFilter filter, Set<MethodElement> collected,
			Set<MethodElement> processed) {
		if (processed.contains(element)) {
			return;
		}
		processed.add(element);

		if (filter.accept(element)) {
			collected.add(element);
		}
		if (filter.skipChildren(element)) {
			return;
		}

		EList<EReference> refList = element.eClass().getEAllContainments();
		if (refList == null || refList.isEmpty()) {
			return;
		}
		for (EReference ref : refList) {
			Object obj = element.eGet(ref);
			if (obj instanceof MethodElement) {
				collectElements((MethodElement) obj, filter, collected,
						processed);

			} else if (obj instanceof List) {
				List list = (List) obj;
				for (Object itemObj : list) {
					if (itemObj instanceof MethodElement) {
						collectElements((MethodElement) itemObj, filter,
								collected, processed);
					}
				}
			}
		}
	}
		
	public Set<? extends MethodElement> getElementsUnder(MethodElement topElement, CollectElementFilter filter) {
		Set<MethodElement> set = new HashSet<MethodElement>();
		collectElements(topElement, filter, set, new HashSet<MethodElement>());
		return set;
	}
	
	public Set<Task> getAllTasks(MethodElement topElement) {
		CollectElementFilter filter = new CollectElementFilter() {
			public boolean accept(MethodElement element) {
				return element instanceof Task;
			}
			
			public boolean skipChildren(MethodElement element) {
				if (element instanceof ProcessPackage) {
					return true;
				}
				
				return super.skipChildren(element);
			}
		};
		return (Set<Task> ) getElementsUnder(topElement, filter);
	}
	
}