/*******************************************************************************
 * Copyright (c) 2010, 2018 Willink Transformations and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     E.D.Willink - initial API and implementation
 *******************************************************************************/
package org.eclipse.ocl.xtext.base.cs2as;

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

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EContentsEList;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.pivot.Element;
import org.eclipse.ocl.pivot.Iteration;
import org.eclipse.ocl.pivot.Operation;
import org.eclipse.ocl.pivot.PivotPackage;
import org.eclipse.ocl.pivot.Property;
import org.eclipse.ocl.pivot.Type;
import org.eclipse.ocl.pivot.TypedElement;
import org.eclipse.ocl.pivot.VariableDeclaration;
import org.eclipse.ocl.pivot.internal.messages.PivotMessagesInternal;
import org.eclipse.ocl.pivot.internal.scoping.EnvironmentView;
import org.eclipse.ocl.pivot.internal.scoping.ScopeFilter;
import org.eclipse.ocl.pivot.internal.scoping.ScopeView;
import org.eclipse.ocl.pivot.internal.utilities.AbstractConversion;
import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal;
import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
import org.eclipse.ocl.pivot.resource.ASResource;
import org.eclipse.ocl.pivot.utilities.ClassUtil;
import org.eclipse.ocl.pivot.utilities.ParserContext;
import org.eclipse.ocl.pivot.utilities.PivotConstants;
import org.eclipse.ocl.pivot.utilities.PivotHelper;
import org.eclipse.ocl.pivot.utilities.StringUtil;
import org.eclipse.ocl.xtext.base.scoping.AbstractJavaClassScope;
import org.eclipse.ocl.xtext.base.scoping.BaseScopeView;
import org.eclipse.ocl.xtext.base.utilities.BaseCSResource;
import org.eclipse.ocl.xtext.base.utilities.CSI;
import org.eclipse.ocl.xtext.base.utilities.CSI2ASMapping;
import org.eclipse.ocl.xtext.basecs.BaseCSPackage;
import org.eclipse.ocl.xtext.basecs.ElementCS;
import org.eclipse.ocl.xtext.basecs.ElementRefCS;
import org.eclipse.ocl.xtext.basecs.ModelElementCS;
import org.eclipse.ocl.xtext.basecs.MultiplicityCS;
import org.eclipse.ocl.xtext.basecs.PathElementCS;
import org.eclipse.ocl.xtext.basecs.PathNameCS;
import org.eclipse.ocl.xtext.basecs.PivotableElementCS;
import org.eclipse.ocl.xtext.basecs.RootCS;
import org.eclipse.ocl.xtext.basecs.TypedRefCS;
import org.eclipse.ocl.xtext.basecs.TypedTypeRefCS;
import org.eclipse.ocl.xtext.basecs.util.BaseCSVisitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.xtext.TerminalRule;
import org.eclipse.xtext.diagnostics.Diagnostic;
import org.eclipse.xtext.diagnostics.DiagnosticMessage;
import org.eclipse.xtext.diagnostics.IDiagnosticConsumer;
import org.eclipse.xtext.diagnostics.Severity;
import org.eclipse.xtext.nodemodel.ICompositeNode;
import org.eclipse.xtext.nodemodel.ILeafNode;
import org.eclipse.xtext.nodemodel.INode;
import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
import org.eclipse.xtext.util.Triple;
import org.eclipse.xtext.util.Tuples;

/**
 * CS2AS manages the equivalence between a Concrete Syntax Resources
 * and their corresponding Pivot Resources creating a CS2ASConversion
 * to update.
 */
public abstract class CS2AS extends AbstractConversion	// FIXME migrate functionality to PivotHelper
{
	public static interface UnresolvedProxyMessageProvider
	{
		@NonNull EReference getEReference();
		@Nullable String getMessage(@NonNull EObject context, @NonNull String linkText);
	}

	public static abstract class AbstractUnresolvedProxyMessageProvider implements UnresolvedProxyMessageProvider
	{
		protected final @NonNull EReference eReference;

		public AbstractUnresolvedProxyMessageProvider(/*@NonNull*/ EReference eReference) {
			assert eReference != null;
			this.eReference = eReference;
		}
		@Override
		public @NonNull EReference getEReference() {
			return eReference;
		}

		@Override
		public abstract @Nullable String getMessage(@NonNull EObject context, @NonNull String linkText);
	}

	/**
	 * Return the containment features ordered so that library and import features are processed before anything else.
	 */
	public static EList<EObject> computeRootContainmentFeatures(RootCS csRoot) {
		BasicEList<EReference> containmentsList = new BasicEList<EReference>();
		for (EStructuralFeature eStructuralFeature : csRoot.eClass().getEAllStructuralFeatures()) {
			if (eStructuralFeature instanceof EReference) {
				EReference eReference = (EReference) eStructuralFeature;
				if (eReference.isContainment()) {
					containmentsList.add(eReference);
				}
			}
		}
		int index = containmentsList.indexOf(BaseCSPackage.Literals.ROOT_CS__OWNED_IMPORTS);
		if (index > 0) {
			containmentsList.move(0, index);		// Process imports second
		}
		return new EContentsEList<EObject>(csRoot, containmentsList);
	}

	private static Map<EReference, UnresolvedProxyMessageProvider> unresolvedProxyMessageProviderMap = new HashMap<EReference, UnresolvedProxyMessageProvider>();

	/**
	 * Whether to show file and line number context at the start of messages.
	 */
	public static boolean showContext = false;

	/**
	 * Interface for an optional message binder that may be used to affix additional context
	 * for standalone and command line applications.
	 */
	public static interface MessageBinder
	{
		@NonNull String bind(@NonNull EObject csContext, @NonNull String messageTemplate, Object... bindings);
	}

	/**
	 * Default message binder that just invokes {@link NLS#bind(String, Object[])}.
	 */
	public static class DefaultMessageBinder implements CS2AS.MessageBinder
	{
		public static final @NonNull MessageBinder INSTANCE = new DefaultMessageBinder();

		@Override
		public @NonNull String bind(@NonNull EObject csContext, @NonNull String messageTemplate, Object... bindings) {
			return StringUtil.bind(messageTemplate, bindings);
		}
	}

	/**
	 * Message binder that prefixes the uri and line number to the return from {@link NLS#bind(String, Object[])}.
	 */
	public static class MessageBinderWithLineContext implements CS2AS.MessageBinder
	{
		public static final MessageBinder INSTANCE = new MessageBinderWithLineContext();

		@Override
		public @NonNull String bind(@NonNull EObject csContext, @NonNull String messageTemplate, Object... bindings) {
			String message = StringUtil.bind(messageTemplate, bindings);
			ICompositeNode node = NodeModelUtils.getNode(csContext);
			if (node != null) {
				int startLine = node.getStartLine();
				String uri = csContext.eResource().getURI().toString();
				return uri + ":" + startLine + " " + message;
			}
			return message;
		}
	}

	private static MessageBinder messageBinder = DefaultMessageBinder.INSTANCE;

	public static void addUnresolvedProxyMessageProvider(UnresolvedProxyMessageProvider unresolvedProxyMessageProvider) {
		unresolvedProxyMessageProviderMap.put(unresolvedProxyMessageProvider.getEReference(), unresolvedProxyMessageProvider);
	}

	public static Element basicGetType(TypedTypeRefCS csTypedRef) {
		List<PathElementCS> path = csTypedRef.getOwnedPathName().getOwnedPathElements();
		int iLast = path.size()-1;
		for (int i = 0; i < iLast; i++) {
			Element element = path.get(i).basicGetReferredElement();
			if (element == null) {
				return null;
			}
		}
		Element element = path.get(iLast).basicGetReferredElement();
		if (element == null) {
			return null;
		}
		return element;
	}

	public static @Nullable DiagnosticMessage getUnresolvedProxyMessage(@NonNull EReference eReference, @NonNull EObject csContext, @NonNull String linkText) {
		String message = getUnresolvedProxyText(eReference, csContext, linkText);
		return message != null ? new DiagnosticMessage(message, Severity.ERROR, Diagnostic.LINKING_DIAGNOSTIC) : null;
	}

	public static @Nullable String getUnresolvedProxyText(@NonNull EReference eReference, @NonNull EObject csContext, @NonNull String linkText) {
		ExceptionAdapter exceptionAdapter = ClassUtil.getAdapter(ExceptionAdapter.class, csContext);
		if (exceptionAdapter != null) {
			return exceptionAdapter.getErrorMessage();
		}
		UnresolvedProxyMessageProvider unresolvedProxyMessageProvider = unresolvedProxyMessageProviderMap.get(eReference);
		if (unresolvedProxyMessageProvider != null) {
			return unresolvedProxyMessageProvider.getMessage(csContext, linkText);
		}
		@SuppressWarnings("null") @NonNull String messageTemplate = PivotMessagesInternal.Unresolved_ERROR_;
		String errorContext = "Unknown";
		EClass referenceType = eReference.getEReferenceType();
		if (referenceType != null) {
			errorContext = referenceType.getName();
		}
		return messageBinder.bind(csContext, messageTemplate, errorContext, linkText);
	}

	public static List<ILeafNode> getDocumentationNodes(@NonNull ICompositeNode node) {
		List<ILeafNode> documentationNodes = null;
		for (ILeafNode leafNode : node.getLeafNodes()) {
			EObject grammarElement = leafNode.getGrammarElement();
			if (!(grammarElement instanceof TerminalRule)) {
				break;
			}
			TerminalRule terminalRule = (TerminalRule) grammarElement;
			String name = terminalRule.getName();
			if ("WS".equals(name)) {
			}
			else if ("SL_COMMENT".equals(name)) {
			}
			else if ("ML_COMMENT".equals(name)) {
				if (documentationNodes == null) {
					documentationNodes = new ArrayList<ILeafNode>();
				}
				documentationNodes.add(leafNode);
			}
			else {
				break;
			}
		}
		return documentationNodes;
	}

	private static final class TypeValueFilter implements ScopeFilter
	{
		public static TypeValueFilter INSTANCE = new TypeValueFilter();

		@Override
		public boolean matches(@NonNull EnvironmentView environmentView, @NonNull Object object) {
			if (object instanceof Type) {
				return true;
			}
			if (object instanceof TypedElement) {
				return false; //((TypedElement)object).getType() instanceof Metaclass<?>;
			}
			return false;
		}
	}

	private static final class UndecoratedNameFilter implements ScopeFilter
	{
		public static UndecoratedNameFilter INSTANCE = new UndecoratedNameFilter();

		@Override
		public boolean matches(@NonNull EnvironmentView environmentView, @NonNull Object object) {
			return !(object instanceof Operation) && !(object instanceof org.eclipse.ocl.pivot.Package);
		}
	}

	public static MessageBinder getMessageBinder() {
		return messageBinder;
	}

	private static long startTime = System.currentTimeMillis();
	private static @NonNull Map<Thread,Long> threadRunTimes = new HashMap<Thread,Long>();
	private static long[] indentRunTimes = new long[100];
	private static @NonNull Integer indentation = 0;
	private static @NonNull String indents= ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";

	public static void printDiagnostic(@NonNull String message, boolean dispose, int indent) {
		synchronized (indentation) {
			if (indent < 0) {
				indentation--;
			}
			long currentTimeMillis = System.currentTimeMillis();
			Thread currentThread = Thread.currentThread();
			Long threadStartTime = threadRunTimes.get(currentThread);
			if (threadStartTime == null) {
				threadStartTime = currentTimeMillis;
				threadRunTimes.put(currentThread, threadStartTime);
			}
			if (indent > 0) {
				System.out.printf("%s %8.3f %s -- %6.3f %s\n", indents.substring(0, Math.min(indentation, indents.length()-1)), (currentTimeMillis - startTime) * 0.001, currentThread.getName(),
					(currentTimeMillis - threadStartTime) * 0.001, message);
			}
			else {
				System.out.printf("%s %8.3f %s -- %6.3f %6.3f %s\n", indents.substring(0, Math.min(indentation, indents.length()-1)), (currentTimeMillis - startTime) * 0.001, currentThread.getName(),
					(currentTimeMillis - threadStartTime) * 0.001, (currentTimeMillis - indentRunTimes[indentation]) * 0.001, message);
			}
			if (dispose) {
				threadRunTimes.remove(currentThread);
			}
			if (indent > 0) {
				indentRunTimes[indentation] = currentTimeMillis;
				indentation++;
			}
		}
	}

	public static void refreshContext(@NonNull PathNameCS pathNameCS, ElementCS csContext) {
		if (pathNameCS.getContext() != csContext) {
			pathNameCS.setContext(csContext);
		}
	}

	public static void refreshElementType(PathElementCS pathElementCS, EClassifier elementType) {
		if ((pathElementCS != null)  && (pathElementCS.getElementType() != elementType)) {
			pathElementCS.setElementType(elementType);
		}
	}

	public static void refreshScopeFilter(@NonNull PathNameCS pathNameCS, ScopeFilter scopeFilter) {
		if (pathNameCS.getScopeFilter() != scopeFilter) {
			pathNameCS.setScopeFilter(scopeFilter);
		}
	}

	public static void setElementType(@NonNull PathNameCS pathNameCS, /*@NonNull*/ EClass elementType, @NonNull ElementCS csContext, @Nullable ScopeFilter scopeFilter) {
		assert elementType != null;
		refreshContext(pathNameCS, csContext);
		refreshScopeFilter(pathNameCS, scopeFilter);
		List<PathElementCS> path = pathNameCS.getOwnedPathElements();
		int iMax = path.size()-1;
		refreshElementType(path.get(iMax), elementType);
		if (PivotPackage.Literals.FEATURE.isSuperTypeOf(elementType) && (iMax > 0)) {
			refreshElementType(path.get(--iMax), PivotPackage.Literals.TYPE);
		}
		for (int i = 0; i < iMax; i++) {
			refreshElementType(path.get(i), PivotPackage.Literals.NAMESPACE);
		}
	}

	/**
	 * Define an alternative message binder. THe default null messageBinder uses
	 * {@link NLS#bind(String, Object[])}
	 */
	public static MessageBinder setMessageBinder(MessageBinder messageBinder) {
		MessageBinder savedMessageBinder = CS2AS.messageBinder;
		CS2AS.messageBinder = messageBinder;
		return savedMessageBinder;
	}

	/**
	 * Define the resolution of a PathNameCS explicitly avoiding the need for the normal Xtext proxy resolution.
	 * This is used after a non-trivial selection occurs such as the selection of the best operation overload.
	 * If element is null the Xtext error message corresponding to an unresolved proxy is generated.
	 * @param ambiguities
	 */
	public static void setPathElement(@NonNull PathNameCS csPathName, @Nullable Element element, @Nullable List<@NonNull ? extends EObject> ambiguities) {
		List<@NonNull PathElementCS> csPath = ClassUtil.nullFree(csPathName.getOwnedPathElements());
		PathElementCS csLastElement = csPath.get(csPath.size()-1);
		AmbiguitiesAdapter.setAmbiguities(csLastElement, ambiguities);
		if ((element == null) || (ambiguities != null)) {
			EObject eObject = csLastElement;
			INode iNode = NodeModelUtils.getNode(csLastElement);
			Triple<EObject, EReference, INode> triple = Tuples.create(eObject, BaseCSPackage.Literals.PATH_ELEMENT_CS__REFERRED_ELEMENT, iNode);
			Resource eResource = csLastElement.eResource();
			if (eResource instanceof BaseCSResource) {
				((BaseCSResource)eResource).createAndAddDiagnostic(triple);
			}
			csLastElement.setReferredElement(null);
		}
		else {
			csLastElement.setReferredElement(element);
		}
	}

	/**
	 * The CS resource mapped by this CS2AS.
	 */
	protected final @NonNull BaseCSResource csResource;

	/**
	 * The AS resource mapped by this CS2AS.
	 */
	protected final @NonNull ASResource asResource;

	/**
	 * CS to Pivot mapping controller for aliases and CSIs.
	 */
	protected final @NonNull CSI2ASMapping csi2asMapping;

	/**
	 * Construction helper, lazily created by the overrideable getHelper/createHelper.
	 */
	private @Nullable PivotHelper helper = null;

	private final @Nullable ParserContext parserContext;		// FIXME only non-null for API compatibility

	public CS2AS(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull BaseCSResource csResource, @NonNull ASResource asResource) {
		super(environmentFactory);
		this.csi2asMapping = CSI2ASMapping.getCSI2ASMapping(environmentFactory);
		this.csResource = csResource;
		this.asResource = asResource;
		csi2asMapping.add(csResource, this);
		this.parserContext = csResource.getParserContext();
		assert parserContext != null;
		assert parserContext.getEnvironmentFactory() == environmentFactory;
	}

	protected CS2AS(@NonNull CS2AS aConverter) {
		super(aConverter.getEnvironmentFactory());
		this.csResource = aConverter.csResource;
		this.asResource = aConverter.asResource;
		this.csi2asMapping = CSI2ASMapping.getCSI2ASMapping(environmentFactory);
		//		csi2asMapping.add(this);
		this.parserContext = aConverter.parserContext;
		assert parserContext != null;
		assert parserContext.getEnvironmentFactory() == environmentFactory;
	}

	public @NonNull String bind(@NonNull EObject csContext, /*@NonNull*/ String messageTemplate, Object... bindings) {
		assert messageTemplate != null;
		return messageBinder.bind(csContext, messageTemplate, bindings);
	}

	protected abstract @NonNull BaseCSVisitor<Continuation<?>> createContainmentVisitor(@NonNull CS2ASConversion cs2asConversion);

	protected@NonNull  CS2ASConversion createConversion(@NonNull IDiagnosticConsumer diagnosticsConsumer, @NonNull BaseCSResource csResource) {
		return new CS2ASConversion(this, diagnosticsConsumer);
	}

	protected @NonNull PivotHelper createHelper() {
		return new PivotHelper(environmentFactory);
	}

	protected abstract @NonNull BaseCSVisitor<Element> createLeft2RightVisitor(@NonNull CS2ASConversion cs2asConversion);
	protected abstract @NonNull BaseCSVisitor<Continuation<?>> createPostOrderVisitor(@NonNull CS2ASConversion converter) ;
	protected abstract @NonNull BaseCSVisitor<Continuation<?>> createPreOrderVisitor(@NonNull CS2ASConversion converter);

	public void dispose() {
		csi2asMapping.removeCSResource(csResource);
	}

	public @NonNull ASResource getASResource() {
		return asResource;
	}

	public @Nullable ModelElementCS getCSElement(@NonNull Element pivotElement) {
		return csi2asMapping.getCSElement(pivotElement);
	}

	public @NonNull BaseCSResource getCSResource() {
		return csResource;
	}

	public @NonNull PivotHelper getHelper() {
		PivotHelper helper2 = helper;
		if (helper2 == null) {
			helper = helper2 = createHelper();
		}
		return helper2;
	}

	public Element getPivotElement(@NonNull ModelElementCS csElement) {
		return csi2asMapping.get(csElement);
	}

	public @Nullable <T extends Element> T getPivotElement(@NonNull Class<T> pivotClass, @NonNull ModelElementCS csElement) {
		Element pivotElement = csi2asMapping.get(csElement);
		if (pivotElement == null) {
			return null;
		}
		if (!pivotClass.isAssignableFrom(pivotElement.getClass())) {
			throw new ClassCastException(pivotElement.getClass().getName() + " is not assignable to " + pivotClass.getName());
		}
		@SuppressWarnings("unchecked")
		T castElement = (T) pivotElement;
		return castElement;
	}

	/**
	 * Install the mapping from a CS element that defines a pivot element to the defined pivot element. The definition
	 * is 'owned' by the CS element, so if the CS element vanishes, so does the pivot element.
	 */
	public void installPivotDefinition(@NonNull ModelElementCS csElement, @NonNull Element newPivotElement) {
		//	logger.trace("Installing " + csElement.getDescription()); //$NON-NLS-1$ //$NON-NLS-2$
		EObject oldPivotElement = csElement.getPivot();
		if (oldPivotElement != newPivotElement) {
			assert !newPivotElement.eIsProxy();
			csElement.setPivot(newPivotElement);
			if (oldPivotElement != null) {
				// WIP Queue dead element
			}
		}
		csi2asMapping.put(csElement, newPivotElement);
	}

	/**
	 * Install the mapping from a CS element to a completely independent pivot element. If the pivot element vanishes, the
	 * reference is stale, if the CS element the pivot element is less referenced.
	 */
	public void installPivotReference(@NonNull ElementRefCS csElement, @NonNull Element newPivotElement, @NonNull EReference eReference) {
		assert eReference.getEContainingClass().isSuperTypeOf(csElement.eClass());
		//	logger.trace("Installing " + csElement.getDescription()); //$NON-NLS-1$ //$NON-NLS-2$
		EObject oldPivotElement = csElement.getPivot();
		if (oldPivotElement != newPivotElement) {
			assert !newPivotElement.eIsProxy();
			csElement.setPivot(newPivotElement);
		}
	}

	/**
	 * Install the mapping from a CS element to a related pivot element. This normally arises when more than one CS element
	 * are associated with a single pivot element. In this case one of the CS elements is the defining CS element and the
	 * others are users.
	 */
	public void installPivotUsage(@NonNull PivotableElementCS csElement, @NonNull Element newPivotElement) {
		//	logger.trace("Installing " + csElement.getDescription()); //$NON-NLS-1$ //$NON-NLS-2$
		EObject oldPivotElement = csElement.getPivot();
		if (oldPivotElement != newPivotElement) {
			assert !newPivotElement.eIsProxy();
			csElement.setPivot(newPivotElement);
		}
	}

	@Deprecated  /* @deprecated FIXME Bug 548500 workaround */
	public void installRootContents(@NonNull BaseCSResource csResource2) {}

	/**
	 * Return true if csTYpeRef referes to a type that cannot be null, e.g. T[1],
	 * or false if it refers to a type that may be null, e.g. T[?],
	 * or null if the nulloty is unspecifued.
	 *
	 * Note that a lazy UML Set such as T[*] is always required; UML collections cannot be null.
	 */
	public @Nullable Boolean isRequired(@NonNull TypedRefCS csTypeRef) {
		MultiplicityCS csMultiplicity = csTypeRef.getOwnedMultiplicity();
		if (csMultiplicity != null) {
			int upper = csMultiplicity.getUpper();
			if (upper != 1) {		// Lazy UML-style Set
				assert !csTypeRef.eContainer().eClass().getName().equals("CollectionTypeCS");
				return true;
			}
			int lower = csMultiplicity.getLower();
			return lower > 0;
		}
		return null;
	}

	public @Nullable Iteration lookupIteration(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName, @Nullable ScopeFilter scopeFilter) {
		setElementType(csPathName, PivotPackage.Literals.ITERATION, csElement, scopeFilter);
		Element namedElement = csPathName.getReferredElement();
		if ((namedElement instanceof Iteration) && !namedElement.eIsProxy()) {
			return (Iteration) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable Operation lookupOperation(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName, @Nullable ScopeFilter scopeFilter) {
		setElementType(csPathName, PivotPackage.Literals.OPERATION, csElement, scopeFilter);
		Element namedElement = csPathName.getReferredElement();
		if ((namedElement instanceof Operation) && !namedElement.eIsProxy()) {
			return (Operation) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable Property lookupProperty(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName, @Nullable ScopeFilter scopeFilter) {
		setElementType(csPathName, PivotPackage.Literals.PROPERTY, csElement, scopeFilter);
		Element namedElement = csPathName.getReferredElement();
		if ((namedElement instanceof Property) && !namedElement.eIsProxy()) {
			return (Property) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable VariableDeclaration lookupSelf(@NonNull ElementCS csElement) {
		@SuppressWarnings("null") @NonNull EReference eReference = PivotPackage.Literals.EXPRESSION_IN_OCL__OWNED_CONTEXT;
		@SuppressWarnings("deprecation")
		EnvironmentView environmentView = parserContext != null ? new EnvironmentView(parserContext, eReference, PivotConstants.SELF_NAME) : new EnvironmentView(environmentFactory, eReference, PivotConstants.SELF_NAME);
		ScopeView baseScopeView = BaseScopeView.getScopeView(environmentFactory, csElement, eReference);
		environmentView.computeLookups(baseScopeView);
		VariableDeclaration variableDeclaration = (VariableDeclaration) environmentView.getContent();
		return variableDeclaration;
	}

	public @Nullable Type lookupType(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName) {
		setElementType(csPathName, PivotPackage.Literals.TYPE, csElement, null);
		Element namedElement = csPathName.getReferredElement();
		if ((namedElement instanceof Type) && !namedElement.eIsProxy()) {
			return (Type) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable Type lookupTypeQualifier(@NonNull PathNameCS csPathName) {
		List<PathElementCS> path = csPathName.getOwnedPathElements();
		int iMax = path.size();
		if (iMax <= 1) {
			return null;
		}
		PathElementCS pathElementCS = path.get(iMax-2);
		refreshElementType(pathElementCS, PivotPackage.Literals.TYPE);
		for (int i = 0; i < iMax-2; i++) {
			refreshElementType(path.get(i), PivotPackage.Literals.NAMESPACE);
		}
		Element namedElement = pathElementCS.getReferredElement();
		if ((namedElement instanceof Type) &&  !namedElement.eIsProxy()) {
			return (Type) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable Type lookupTypeValue(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName) {
		setElementType(csPathName, PivotPackage.Literals.NAMED_ELEMENT, csElement, TypeValueFilter.INSTANCE);	// Type or Variable
		Element namedElement = csPathName.getReferredElement();
		if ((namedElement instanceof Type) && !namedElement.eIsProxy()) {
			return (Type) namedElement;
		}
		else {
			return null;
		}
	}

	public @Nullable Element lookupUndecoratedName(@NonNull ElementCS csElement, @NonNull PathNameCS csPathName) {
		setElementType(csPathName, PivotPackage.Literals.ELEMENT, csElement, UndecoratedNameFilter.INSTANCE);
		Element namedElement = csPathName.getReferredElement();
		return namedElement;
	}

	public @NonNull <T extends Element> T refreshModelElement(@NonNull Class<T> pivotClass, @NonNull EClass pivotEClass, @Nullable ModelElementCS csElement) {
		Element pivotElement = csElement != null ? getPivotElement(csElement) : null;
		@NonNull Element pivotElement2;
		if ((pivotElement != null)
				&& pivotClass.isAssignableFrom(pivotElement.getClass())					// Avoid resetting container of incidental reference
				&& ((csElement == null) || (csElement.eContainer() != null))) {			// Avoid resetting container of potentially re-used root
			PivotUtilInternal.resetContainer(pivotElement);		// Bypass child-stealing detector
		}
		if ((pivotElement == null) || (pivotEClass != pivotElement.eClass())) {
			EFactory eFactoryInstance = pivotEClass.getEPackage().getEFactoryInstance();
			@NonNull Element pivotElement3 = (Element) eFactoryInstance.create(pivotEClass);
			pivotElement2 = pivotElement3;
		}
		else {
			pivotElement2 = pivotElement;
		}
		if (csElement != null) {
			installPivotDefinition(csElement, pivotElement2);
		}
		@SuppressWarnings("unchecked")
		@NonNull T castElement = (T) pivotElement2;
		return castElement;
	}

	public synchronized void update(@NonNull IDiagnosticConsumer diagnosticsConsumer) {
		//		printDiagnostic("CS2AS.update start", false, 0);
		@SuppressWarnings("unused") Map<CSI, Element> oldCSI2AS = csi2asMapping.getMapping();
		@SuppressWarnings("unused") Set<CSI> newCSIs = csi2asMapping.computeCSIs(csResource);
		//		System.out.println("==========================================================================");
		//		for (Resource csResource : csResources) {
		//			System.out.println("CS " + csResource.getClass().getName() + "@" + csResource.hashCode() + " " + csResource.getURI());
		//		}
		CS2ASConversion conversion = createConversion(diagnosticsConsumer, csResource);
		conversion.update(csResource);
		//		System.out.println("---------------------------------------------------------------------------");
		//		Collection<? extends Resource> pivotResources = cs2asResourceMap.values();
		//		for (Entry<? extends Resource, ? extends Resource> entry : cs2asResourceMap.entrySet()) {
		//			Resource csResource = entry.getKey();
		//			Resource asResource = entry.getValue();
		//			System.out.println("CS " + csResource.getClass().getName() + "@" + csResource.hashCode() + " => " + asResource.getClass().getName() + "@" + asResource.hashCode());
		//		}
		/*		Set<String> deadCSIs = new HashSet<String>(oldCSI2AS.keySet());
		deadCSIs.removeAll(newCSIs);
		for (String deadCSI : deadCSIs) {
			Element deadPivot = oldCSI2AS.get(deadCSI);	// WIP
//			metamodelManager.kill(deadPivot);
		} */
		Map<BaseCSResource, ASResource> cs2asResourceMap = new HashMap<BaseCSResource, ASResource>();
		ASResource asResource = csi2asMapping.getASResource(csResource);
		cs2asResourceMap.put(csResource, asResource);
		AbstractJavaClassScope javaClassScope = AbstractJavaClassScope.findAdapter(csResource);
		if (javaClassScope != null) {
			javaClassScope.installContents(csResource);
		}
		conversion.garbageCollect(cs2asResourceMap);
		csi2asMapping.update();
		//		printDiagnostic("CS2AS.update end", false, 0);
	}
}