org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/imports/EObjectUsages.java

package org.eclipse.osbp.xtext.oxtype.imports;

import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Sets.newHashSet;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.xtext.common.types.JvmType;
import org.eclipse.xtext.naming.QualifiedName;
import org.eclipse.xtext.util.ITextRegion;

import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.Multimap;

/**
 * This class collects all {@link EObjectUsage usages}.
 */
public class EObjectUsages {

	private Multimap<String, EObject> simpleName2eObjects = LinkedHashMultimap
			.create();
	private Multimap<EObject, EObjectUsage> eObject2usages = LinkedHashMultimap
			.create();
	private Multimap<EObject, EObjectJvmLinkUsage> jvmType2usages = LinkedHashMultimap
			.create();

	private Set<EObject> nsImports = newHashSet();

	private List<EObjectUsage> unresolvedEObjects = newArrayList();

	private List<EObjectJvmLinkUsage> unsresolvedJvmLinkUsages = new ArrayList<>();

	public EObjectUsage addResolvedEObject(EObject typeToImport,
			QualifiedName fqn, ITextRegion textRegion, EObject context) {
		if(fqn == null) {
			return null;
		}
		
		simpleName2eObjects.put(fqn.toString(), typeToImport);

		EObjectUsage usage = new EObjectUsage(typeToImport, fqn, textRegion,
				context);
		eObject2usages.put(typeToImport, usage);

		if (!nsImports.contains(typeToImport)) {
			nsImports.add(typeToImport);
		}

		return usage;
	}

	/**
	 * Needs to be called after
	 * {@link EObjectUsage#resolve(EObject, QualifiedName)} was called.
	 * 
	 * @param usage
	 */
	public void makeResolvedEObject(EObjectUsage usage) {
		simpleName2eObjects.put(usage.getUniqueKeyUnresolved(),
				usage.getUsedType());

		eObject2usages.put(usage.getUsedType(), usage);

		if (!nsImports.contains(usage.getUsedType())) {
			nsImports.add(usage.getUsedType());
		}
	}

	public EObjectJvmLinkUsage addResolvedJvmLink(EObjectUsage parent,
			JvmType jvmTypeToImport, ITextRegion textRegion, EObject context,
			String crossRefString) {

		String fqn = parent.getTypeQualifiedName().skipLast(1)
				.append(crossRefString).toString();
		simpleName2eObjects.put(fqn, jvmTypeToImport);

		EObjectJvmLinkUsage usage = new EObjectJvmLinkUsage(parent,
				jvmTypeToImport, textRegion, context);
		jvmType2usages.put(jvmTypeToImport, usage);

		if (!nsImports.contains(jvmTypeToImport)) {
			nsImports.add(jvmTypeToImport);
		}

		return usage;
	}

	public EObjectUsage addUnresolvedEObject(String unresolvedTypeName,
			EClassifier type, EReference reference, String suffix,
			ITextRegion textRegion, EObject context) {

		EObjectUsage usage = new EObjectUsage(unresolvedTypeName, type,
				reference, textRegion, context);
		unresolvedEObjects.add(usage);

		return usage;
	}

	public EObjectJvmLinkUsage addUnresolvedJvmLink(EObjectUsage parent,
			String crossRefText, ITextRegion textRegion, EObject context) {

		EObjectJvmLinkUsage usage = new EObjectJvmLinkUsage(parent,
				crossRefText, textRegion, context);
		unsresolvedJvmLinkUsages.add(usage);

		return usage;
	}

	public Multimap<String, EObject> getSimpleName2EObjects() {
		return simpleName2eObjects;
	}

	public Iterable<EObjectUsage> getResolvedEObjects(EObject type) {
		return eObject2usages.get(type);
	}

	public List<EObjectUsage> getUnresolvedEObjects() {
		return unresolvedEObjects;
	}

	public Iterable<EObjectJvmLinkUsage> getResolvedJvmTypes(EObject type) {
		return jvmType2usages.get(type);
	}

	public List<EObjectJvmLinkUsage> getUnresolvedJvmTypes() {
		return unsresolvedJvmLinkUsages;
	}

	public Set<EObject> getNamespaceImports() {
		return nsImports;
	}

}