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

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

import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.epf.library.edit.LibraryEditResources;
import org.eclipse.epf.library.edit.uma.ScopeFactory;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessElement;
import org.eclipse.epf.uma.util.Scope;

public class ProcessScopeUtil {

	private static ProcessScopeUtil instance = new ProcessScopeUtil();
	
	private Scope libraryScope = ScopeFactory.getInstance().newLibraryScope();
	private Scope pluginScope = ScopeFactory.getInstance().newProcessScope(LibraryEditResources.scope_PluginsName);

	private Set<Scope> scopeInEditdSet = new HashSet<Scope>();

	public static final int ScopeType_Config = 0;
	public static final int ScopeType_Process = 1;
	public static final int ScopeType_Library = 2;
	public static final int ScopeType_Plugins = 3;
	
	private int scopeType = ScopeType_Config;
	
	public static ProcessScopeUtil getInstance() {
		return instance;
	}	
	
	public ProcessScopeUtil() {	
	}	
	
	public void setElemementSelectionScopeType(int type) {	
		scopeType = type;
	}
	
	public int getElemementSelectionScopeType() {
		return scopeType;
	}
	
	public Scope loadScope(Process proc) {
		if (proc == null) {
			return null;
		}
		if (! isConfigFree(proc)) {
			return null;
		}
		
		Scope scope = getScope(proc); 
		if (scope != null) {
			updateScope(proc);
			return scope;
		}
			
		scope =	ScopeFactory.getInstance().newProcessScope(null);

		addReferenceToScope(scope, proc, new HashSet<MethodElement>());
		boolean oldB = proc.eDeliver();
		try {
			if (oldB) {
				proc.eSetDeliver(false);
			}
			proc.setDefaultContext(scope);
			proc.getValidContext().add(scope);
		} finally {
			if (oldB) {
				proc.eSetDeliver(true);
			}
		}		
		return scope;
	}
	
	public void updateScope(Process proc) {
		Scope scope = getScope(proc);
		if (scope == null) {
			return;
		}
		scope.clearAll();
		addReferenceToScope(scope, proc, new HashSet<MethodElement>());

	}
	
	public void addReferenceToScope(Scope scope, MethodElement element, 
			Set<MethodElement> handledReferenceSet) {
		if (handledReferenceSet.contains(element)) {
			return;
		}
		handledReferenceSet.add(element);		
		scope.addToScope(element);
		
		if (element instanceof ContentElement) {
			
		} else if (element instanceof ProcessElement) {
			
		} else {
			return;
		}

		
		for (EStructuralFeature f : element.eClass()
				.getEAllStructuralFeatures()) {
			if (!(f instanceof EReference)) {
				continue;
			}
			EReference feature = (EReference) f;
			if (feature.isContainer() || feature.isContainment()) {
				continue;
			}

			Object value = element.eGet(feature);
			if (value == null) {
				continue;
			}
			
			if (value instanceof MethodElement) {
				addReferenceToScope(scope, (MethodElement) value, handledReferenceSet);
			} else if (value instanceof List) {
				List list = (List) value;
				if (list.size() > 0 && list.get(0) instanceof MethodElement) {
					for (int i = 0; i < list.size(); i++) {
						addReferenceToScope(scope, (MethodElement) list.get(i), handledReferenceSet);
					}
				}
			}
		}
		
	}
		
	public Scope getScope(Process proc) {
		if (proc == null || !(proc.getDefaultContext() instanceof Scope)) {
			return null;
		}
		
		Scope scope = (Scope) proc.getDefaultContext();		
		return scope;
	}
	
	public Scope getLibraryScope() {
		MethodLibrary lib = LibraryEditUtil.getInstance().getCurrentMethodLibrary();
		if (lib != null) {
			List<MethodPlugin> newPlugins = lib.getMethodPlugins();
			List<MethodPlugin> oldPlugins = libraryScope.getMethodPluginSelection();
			boolean same = newPlugins.size() == oldPlugins.size();
			if (same) {
				for (int i = 0; i < newPlugins.size(); i++) {
					if (newPlugins.get(i) != oldPlugins.get(i)) {
						same = false;
						break;
					}
				}
			}
			if (!same) {
				oldPlugins.clear();
				oldPlugins.addAll(newPlugins);
			}
			libraryScope.setName(lib.getName());
		}
		
		return libraryScope;
	}
	
	public Scope getPluginScope() {
		return pluginScope;
	}
	
	public void beginProcessEdit(Scope scope) {
		scopeInEditdSet.add(scope);
		scopeInEditdSet.add(libraryScope);
		scopeInEditdSet.add(pluginScope);
	}
	
	public void endProcessEdit(Scope scope) {
		scopeInEditdSet.remove(scope);
		scopeInEditdSet.remove(libraryScope);
		scopeInEditdSet.remove(pluginScope);
	}

	public Set<Scope> getScopeInEditdSet() {
		return scopeInEditdSet;
	}
	
	public boolean isConfigFree(Process process) {
		if (getScope(process) != null) {
			return true;
		}
	
		if (process.getDefaultContext() == null && process
						.getValidContext().isEmpty()) {
			return true;
		}
		if (! process.getValidContext().isEmpty()) {
			return process.getValidContext().get(0) instanceof Scope;
		}
				
		return false;
	}
	
}