/*******************************************************************************
 * Copyright (c) 2013, 2019 THALES GLOBAL SERVICES 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/

package org.eclipse.emf.ecoretools.design.service;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.codegen.ecore.genmodel.GenClass;
import org.eclipse.emf.codegen.ecore.genmodel.GenDelegationKind;
import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
import org.eclipse.emf.common.EMFPlugin;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.ENamedElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.ETypeParameter;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.impl.EStringToStringMapEntryImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.URIConverter;
import org.eclipse.emf.ecore.util.Diagnostician;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.edit.EMFEditPlugin;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.sirius.business.api.session.Session;
import org.eclipse.sirius.business.api.session.SessionManager;
import org.eclipse.sirius.diagram.DDiagram;
import org.eclipse.sirius.diagram.DDiagramElement;
import org.eclipse.sirius.diagram.DEdge;
import org.eclipse.sirius.diagram.DNodeContainer;
import org.eclipse.sirius.diagram.DNodeList;
import org.eclipse.sirius.diagram.DSemanticDiagram;
import org.eclipse.sirius.diagram.EdgeArrows;
import org.eclipse.sirius.diagram.EdgeTarget;
import org.eclipse.sirius.diagram.business.api.query.DDiagramQuery;
import org.eclipse.sirius.diagram.business.internal.helper.task.operations.CreateViewTask;
import org.eclipse.sirius.diagram.business.internal.metamodel.helper.ContainerMappingHelper;
import org.eclipse.sirius.diagram.business.internal.metamodel.helper.ContentHelper;
import org.eclipse.sirius.diagram.business.internal.query.DDiagramInternalQuery;
import org.eclipse.sirius.diagram.description.AbstractNodeMapping;
import org.eclipse.sirius.diagram.description.DiagramElementMapping;
import org.eclipse.sirius.diagram.description.tool.CreateView;
import org.eclipse.sirius.diagram.description.tool.ToolFactory;
import org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor;
import org.eclipse.sirius.ecore.extender.business.api.accessor.exception.FeatureNotFoundException;
import org.eclipse.sirius.ecore.extender.business.api.accessor.exception.MetaClassNotFoundException;
import org.eclipse.sirius.ext.emf.AllContents;
import org.eclipse.sirius.tools.api.command.CommandContext;
import org.eclipse.sirius.viewpoint.DRepresentation;
import org.eclipse.sirius.viewpoint.DSemanticDecorator;
import org.eclipse.sirius.viewpoint.FontFormat;

import com.google.common.base.Ascii;
import com.google.common.base.CharMatcher;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.collect.Sets;

/**
 * Generic Ecore services usable from a VSM.
 */
public class DesignServices extends EReferenceServices {
	private static final String CLASS_DIAGRAM_CLASS_MAPPINGID = "EC EClass";

	/**
	 * Returns all the root objects of all the resources in the same
	 * resource-set as the specified object.
	 * 
	 * @param any
	 *            an EObject.
	 * @return all the root objects in the same resource-set as <code>any</code>
	 *         or an empty collection if <code>any</code> is not inside a
	 *         resource-set.
	 */
	public List<EObject> allRoots(EObject any) {
		Resource res = any.eResource();
		if (res != null && res.getResourceSet() != null) {
			List<EObject> roots = new ArrayList<EObject>();
			for (Resource childRes : res.getResourceSet().getResources()) {
				roots.addAll(childRes.getContents());
			}
			return roots;
		} else {
			return Collections.emptyList();
		}
	}

	public Set<EPackage> rootEPackages(EObject any) {
		return Sets.newLinkedHashSet(Iterables.filter(allRoots(any), EPackage.class));
	}

	public Boolean isEOperation(EObject any) {
		return any instanceof EOperation;
	}

	public Boolean isEStructuralFeature(EObject any) {
		return any instanceof EStructuralFeature;
	}

	public Boolean isEPackage(EObject any) {
		return any instanceof EPackage;
	}

	public Boolean isEClass(EObject any) {
		return any instanceof EClass;
	}

	public Boolean isEEnum(EObject any) {
		return any instanceof EEnum;
	}

	protected static final String GEN_MODEL_PACKAGE_NS_URI = "http://www.eclipse.org/emf/2002/GenModel";

	protected static final String ECORE_PACKAGE_NS_URI = "http://www.eclipse.org/emf/2002/Ecore";

	public EObject markForAutosize(EObject any) {
		if (any != null) {
			any.eAdapters().add(AutosizeTrigger.AUTO_SIZE_MARKER);
		}
		return any;
	}

	public EObject eContainerEContainer(EObject any) {
		if (any.eContainer() != null)
			return any.eContainer().eContainer();
		return null;
	}

	public Set<EStringToStringMapEntryImpl> getVisibleDocAnnotations(EObject self, DSemanticDiagram diag) {
		// [diagram.getDisplayedEModelElements().oclAsType(ecore::EModelElement).eAnnotations.details->select(key
		// = 'documentation')/]
		Set<EStringToStringMapEntryImpl> result = Sets.newLinkedHashSet();
		for (EModelElement displayed : getDisplayedEModelElements(diag)) {
			if (!(displayed instanceof EAttribute) && !(displayed instanceof EEnumLiteral)
					&& !(displayed instanceof EOperation)) {
				EAnnotation eAnnot = displayed.getEAnnotation(GEN_MODEL_PACKAGE_NS_URI);
				if (eAnnot != null) {
					for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(eAnnot.getDetails(),
							EStringToStringMapEntryImpl.class)) {
						if ("documentation".equals(mapEntry.getKey())) {
							result.add(mapEntry);
						}
					}
				}
			}

		}
		return result;
	}

	public Set<EStringToStringMapEntryImpl> getVisibleConstraintsAnnotations(EObject self,
			DSemanticDiagram diag) {
		Set<EStringToStringMapEntryImpl> result = Sets.newLinkedHashSet();
		for (EModelElement displayed : getDisplayedEModelElements(diag)) {
			if (!(displayed instanceof EAttribute) && !(displayed instanceof EEnumLiteral)
					&& !(displayed instanceof EOperation)) {
				EAnnotation eAnnot = displayed.getEAnnotation(ECORE_PACKAGE_NS_URI);
				if (eAnnot != null) {
					for (EStringToStringMapEntryImpl mapEntry : Iterables.filter(eAnnot.getDetails(),
							EStringToStringMapEntryImpl.class)) {
						if ("constraints".equals(mapEntry.getKey())) {
							result.add(mapEntry);
						}
					}
				}
			}

		}
		return result;
	}

	public boolean hasNoClassifier(DSemanticDiagram diagram) {
		Iterator<DSemanticDecorator> it = Iterators.filter(diagram.getOwnedDiagramElements().iterator(),
				DSemanticDecorator.class);
		while (it.hasNext()) {
			DSemanticDecorator dec = it.next();
			if (dec.getTarget() instanceof EClassifier)
				return true;
		}
		return false;
	}

	public Set<EReference> getNonDisplayedEReferences(EClass self, DSemanticDiagram diag) {
		Set<EReference> result = Sets.newLinkedHashSet();
		Set<EClass> displayedEClasses = null;
		for (EReference eReference : self.getEAllReferences()) {
			if (eReference.getEType() != null) {
				if (displayedEClasses == null) {
					displayedEClasses = getDisplayedEClasses(diag);
				}
				/*
				 * if the target of the EReference is not visible, we *have* to
				 * display it as a node except if it iis from a supertype which
				 * is visible itself, then the reference will be already
				 * displayed. but if the reference is owned by a super type and
				 * this supertype is not visible, even if the target is visible,
				 * then we have to display it as a node to!
				 */
				boolean targetTypeIsVisible = displayedEClasses.contains(eReference.getEType());
				boolean referenceIsInherited = eReference.getEContainingClass() != self;
				boolean referenceHostIsVisible = displayedEClasses.contains(eReference.getEContainingClass());
				if (!referenceIsInherited && !targetTypeIsVisible) {
					result.add(eReference);
				}
				if (referenceIsInherited && (!referenceHostIsVisible)) {
					result.add(eReference);
				}
			}
		}
		return result;
	}

	public Set<EClass> getDisplayedEClasses(DSemanticDiagram diagram) {
		Set<EClass> result = Sets.newLinkedHashSet();
		Iterator<DNodeList> it = Iterators.filter(new DDiagramInternalQuery(diagram).getContainers().iterator(),
				DNodeList.class);
		while (it.hasNext()) {
			DNodeList dec = it.next();
			if (dec.getTarget() instanceof EClass && dec.isVisible()) {
				result.add((EClass) dec.getTarget());
			}
		}
		return result;
	}

	public Set<EClassifier> getDisplayedEClassifiers(DSemanticDiagram diagram) {
		Set<EClassifier> result = Sets.newLinkedHashSet();
        Iterator<DNodeList> it = Iterators.filter(new DDiagramInternalQuery(diagram).getContainers().iterator(),
                DNodeList.class);
        while (it.hasNext()) {
			DNodeList dec = it.next();
			if (dec.getTarget() instanceof EClassifier && dec.isVisible()) {
				result.add((EClassifier) dec.getTarget());
			}
		}
		return result;
	}

	private Set<EClass> getInternalEClasses(DSemanticDiagram diagram) {
		Set<EClass> result = Sets.newLinkedHashSet();
        Iterator<DNodeList> it = Iterators.filter(new DDiagramInternalQuery(diagram).getContainers().iterator(),
                DNodeList.class);
		while (it.hasNext()) {
			DNodeList dec = it.next();
			if (dec.getTarget() instanceof EClass) {
				if (dec.getActualMapping() != null
						&& CLASS_DIAGRAM_CLASS_MAPPINGID.equals(dec.getActualMapping().getName())) {
					result.add((EClass) dec.getTarget());
				}
			}
		}
		return result;
	}

	public Set<EClass> getDirectSuperTypesOrMostSpecificVisibleOnes(EClass self, DSemanticDiagram diagram) {
		Set<EClass> result = Sets.newLinkedHashSet();
		Set<EClass> displayed = getDisplayedEClasses(diagram);
		for (EClass directSuperType : self.getESuperTypes()) {
			if (displayed.contains(directSuperType)) {
				result.add(directSuperType);
			} else {
				Set<EClass> mostSpecificDisplayed = findMostSpecificAndVisible(directSuperType.getESuperTypes(),
						displayed);
				if (mostSpecificDisplayed != null) {
					result.addAll(mostSpecificDisplayed);
				}
			}
		}
		return result;
	}

	private Set<EClass> findMostSpecificAndVisible(Collection<EClass> superTypes, Set<EClass> displayed) {
		Set<EClass> result = Sets.newLinkedHashSet();
		for (EClass eClass : superTypes) {
			if (displayed.contains(eClass)) {
				result.add(eClass);
			} else {
				result.addAll(findMostSpecificAndVisible(eClass.getESuperTypes(), displayed));
			}
		}
		return result;
	}

	public Set<EClass> getExternalEClasses(EPackage root, DSemanticDiagram diagram) {

		Set<EClass> related = Sets.newLinkedHashSet();
		Set<EClass> eClasses = getInternalEClasses(diagram);
		RelatedElementsSwitch relations = new RelatedElementsSwitch();
		for (EClass eClass : eClasses) {
			for (EClass other : Iterables.filter(relations.getRelatedElements(eClass), EClass.class)) {
				related.add(other);
			}
		}

		return Sets.difference(related, eClasses);
	}

	public Set<EReference> getEReferencesToDisplay(EPackage root, DSemanticDiagram diagram) {
		// [diagram.getDisplayedEClasses().oclAsType(ecore::EClass).eAllReferences->flatten()/]
		Collection<EClass> eClasses = getDisplayedEClasses(diagram);
		Set<EReference> eRefs = Sets.newLinkedHashSet();
		for (EClass clazz : eClasses) {
			eRefs.addAll(clazz.getEAllReferences());
		}
		return eRefs;
	}

	public Boolean targetIsInterface(EClass clazz, EObject view) {
		if (view instanceof DEdge) {
			EdgeTarget target = ((DEdge) view).getTargetNode();
			if (target instanceof DSemanticDecorator && ((DSemanticDecorator) target).getTarget() instanceof EClass) {
				return ((EClass) ((DSemanticDecorator) target).getTarget()).isInterface();
			}
		}
		return false;
	}

	public List<EReference> getEOppositeSemanticElements(EReference ref) {
		Set<EReference> allRefs = Sets.newLinkedHashSet();
		allRefs.add(ref);
		if (ref.getEOpposite() != null)
			allRefs.add(ref.getEOpposite());
		return Ordering.natural().onResultOf(new Function<EReference, String>() {

			public String apply(EReference input) {
				return input.getName();
			}
		}).sortedCopy(allRefs);
	}

	public Set<EModelElement> getDisplayedEModelElements(DSemanticDiagram diagram) {
		Set<EModelElement> modelelements = Sets.newLinkedHashSet();
		Iterator<DSemanticDecorator> it = Iterators.filter(Iterators.concat(Iterators.singletonIterator(diagram),
				new DDiagramQuery(diagram).getAllDiagramElements().iterator()), DSemanticDecorator.class);
		while (it.hasNext()) {
			DSemanticDecorator dec = it.next();
			if (dec.getTarget() instanceof EModelElement)
				modelelements.add((EModelElement) dec.getTarget());
		}
		return modelelements;
	}

	public List<EObject> getValidsForDiagram(final EObject element, final DSemanticDecorator containerView) {
		Predicate<EObject> validForClassDiagram = new Predicate<EObject>() {

			public boolean apply(EObject input) {
				return input instanceof EPackage || input instanceof EClassifier;
			}
		};
		return allValidSessionElements(element, validForClassDiagram);
	}

	public Set<EObject> getRelated(EObject firstView, List<EObject> allSelectedViews, DDiagram diag) {
		Set<EObject> relateds = Sets.newLinkedHashSet();
		for (DSemanticDecorator decorator : Iterables.filter(allSelectedViews, DSemanticDecorator.class)) {
			relateds.addAll(new RelatedElementsSwitch().getRelatedElements(decorator.getTarget()));
		}
		return relateds;
	}

	public Set<EObject> getRelated(EObject firstView, EObject aView, DDiagram diag) {
		return getRelated(firstView, Lists.newArrayList(aView), diag);
	}

	private List<EObject> allValidSessionElements(EObject cur, Predicate<EObject> validForClassDiagram) {
		Session found = SessionManager.INSTANCE.getSession(cur);
		List<EObject> result = Lists.newArrayList();
		if (found != null) {
			for (Resource res : found.getSemanticResources()) {
				if (res.getURI().isPlatformResource() || res.getURI().isPlatformPlugin()) {
					Iterators.addAll(result, Iterators.filter(res.getAllContents(), validForClassDiagram));
				}
			}
		}
		return result;
	}

	/**
	 * Gets the containing resource name, or null.
	 * 
	 * @param current
	 *            is the object
	 * @return the resource
	 */
	public String eResourceName(final EObject current) {
		if (current != null && current.eResource() != null) {
			return current.eResource().getURI().lastSegment();
		} else {
			return null;
		}
	}

	/**
	 * Replace spaces by camel case value.
	 * 
	 * @param any
	 * @param from
	 * @return
	 */
	public String toCamelCase(EObject any, String from) {
		if (from != null) {
			StringBuffer buffer = new StringBuffer(from.length());
			for (String word : Splitter.on(CharMatcher.WHITESPACE).trimResults().split(from)) {
				buffer.append(toU1Case(word));
			}
			return buffer.toString();
		}
		return from;
	}

	private String toU1Case(String word) {
		if (word != null && word.length() > 0) {
			return new StringBuilder(word.length()).append(Ascii.toUpperCase(word.charAt(0))).append(word.substring(1))
					.toString();
		}
		return word;
	}

	/**
	 * Computes the label of an EAttribute.
	 */
	public String render(EAttribute attr) {
		return new EAttributeServices().render(attr);
	}

	/**
	 * Performs a "direct edit" operation on an EAttribute.
	 */
	public EStructuralFeature performEdit(EAttribute attr, String editString) {
		return new EAttributeServices().performEdit(attr, editString);
	}

	/**
	 * Performs a "direct edit" operation on an EAttribute.
	 */
	public EStructuralFeature performEditAsAttribute(EStructuralFeature attr, String editString) {
		return new EAttributeServices().performEdit(attr, editString);
	}

	/**
	 * Computes the label of an EOperation.
	 */
	public String render(EOperation op) {
		return new EOperationServices().render(op);
	}

	public String renderTooltip(EObject current) {
		String result = "";
		Optional<Diagnostic> diag = DiagnosticAttachment.get(current);
		if (diag.isPresent()) {
			result += prettyMessage(diag.get());
		}
		return result;
	}

	private String prettyMessage(Diagnostic diag) {
		String result = "";
		for (Diagnostic child : diag.getChildren()) {
			String message = child.getMessage();
			/*
			 * we remove any substring which could be the toString of some data
			 * and replace it with something which will not change on subsequent
			 * executions.
			 */
			for (EObject data : Iterables.filter(child.getData(), EObject.class)) {
				String instanceVariableString = data.getClass().getName() + "@" + Integer.toHexString(data.hashCode());
				message = message.replace(instanceVariableString, data.eClass().getName());
			}

			result += "\n" + severityLabel(child.getSeverity()) + " : " + message;
			result += prettyMessage(child);
		}
		return result;
	}

	private String severityLabel(int severity) {
		switch (severity) {
		case Diagnostic.ERROR:
			return "ERROR";
		case Diagnostic.CANCEL:
			return "CANCEL";
		case Diagnostic.INFO:
			return "INFO";
		case Diagnostic.WARNING:
			return "WARNING";
		case Diagnostic.OK:
			return "OK";

		}
		return "UNKNOWN";
	}

	/**
	 * Computes the tooltip of an EOperation.
	 * 
	 * @param op
	 *            the operation to get the tooltip from
	 * @return the tooltip of the given EOperation.
	 */
	public String renderEOperationTooltip(EOperation op) {
		String validationTooltip = renderTooltip(op);
		String operationSignature = new EOperationServices().renderEOperationTooltip(op);
		if (validationTooltip != null && validationTooltip.length() > 0) {
			return validationTooltip + "\n" + operationSignature;
		} else {
			return operationSignature;
		}
	}

	/**
	 * Performs a "direct edit" operation on an EOperation.
	 */
	public EOperation performEdit(EOperation op, String editString) {
		return new EOperationServices().performEdit(op, editString);
	}

	public List<ENamedElement> getAllAssociatedElements(EOperation op) {
		return new EOperationServices().getAllAssociatedElements(op);
	}

	/**
	 * Computes the label of an EReference.
	 */
	@Override
	public String render(EReference ref) {
		return new EReferenceServices().render(ref);
	}

	/**
	 * Computes the label of an EReference.
	 */
	@Override
	public String renderAsNode(EReference ref) {
		return new EReferenceServices().renderAsNode(ref);
	}

	public String renderEOpposite(EReference ref) {
		if (ref.getEOpposite() != null) {
			return new EReferenceServices().render(ref.getEOpposite());
		}
		return "";
	}

	/**
	 * Performs a "direct edit" operation on an EReference.
	 */
	@Override
	public EReference performEdit(EReference ref, String editString) {
		return new EReferenceServices().performEdit(ref, editString);
	}

	/**
	 * Finds a type matching the specified name (case-insensitive) in the same
	 * resource-set as obj, or inside Ecore itself if none could be found.
	 * 
	 * @param obj
	 *            the object defining the context in which to look.
	 * @param name
	 *            the name of the type to look for (case-insensitive). Only
	 *            basic type names are supported (no qualified names).
	 *            Whitespace before or after the name is ignored.
	 * @return the first type found in the resource set or Ecore itself which
	 *         matches the specified name.
	 */
	public EClassifier findTypeByName(EObject obj, String name) {
		EClassifier result = findTypeByName(allRoots(obj), name);
		if (result == null) {
			result = findTypeByNameFrom(EcorePackage.eINSTANCE, name);
		}
		return result;
	}

	/**
	 * Returns the root container; it may be this object itself
	 * 
	 * @param eObject
	 *            the object to get the root container for.
	 * @return the root container.
	 */
	public EObject getRootContainer(EObject eObject) {
		return EcoreUtil.getRootContainer(eObject);
	}

	private EClassifier findTypeByName(Iterable<EObject> roots, String name) {
		for (EObject root : roots) {
			EClassifier result = findTypeByNameFrom(root, name);
			if (result != null) {
				return result;
			}
		}
		return null;
	}

	private EClassifier findTypeByNameFrom(EObject root, String name) {
		if (root instanceof EClassifier && nameMatches((EClassifier) root, name)) {
			return (EClassifier) root;
		}
		for (EObject obj : AllContents.of(root)) {
			if (obj instanceof EClassifier && nameMatches((EClassifier) obj, name)) {
				return (EClassifier) obj;
			}
		}
		return null;
	}

	private boolean nameMatches(EClassifier type, String name) {
		if (type != null && type.getName() != null && name != null) {
			return type.getName().trim().equalsIgnoreCase(name.trim());
		} else {
			return false;
		}
	}

	public Boolean hasError(EObject eObj) {
		if (eObj instanceof EClass || eObj instanceof EStructuralFeature) {
			DiagnosticAttachment attachment = DiagnosticAttachment.getAttachment(eObj);
			if (attachment == null) {
				Diagnostic diagnostic = Diagnostician.INSTANCE.validate(eObj);
				attachment = DiagnosticAttachment.getOrCreate(eObj, diagnostic);
			}
			Diagnostic diag = attachment.getDiagnostic();
			if (diag != null) {
				return diag.getSeverity() == Diagnostic.ERROR;
			}
		}
		return false;
	}

	public Boolean isEDataType(EObject eObj) {
		return eObj.eClass() == EcorePackage.eINSTANCE.getEDataType();
	}

	public Boolean isDDiagram(EObject any, EObject view) {
		return view instanceof DDiagram;
	}

	public List<EObject> eOperationSemanticElements(EOperation eOp) {
		List result = Lists.newArrayList(Ordering.natural().onResultOf(new Function<EParameter, String>() {

			public String apply(EParameter arg0) {
				return arg0.getName();
			}
		}).sortedCopy(eOp.getEParameters()));
		result.add(0, eOp);
		return result;
	}

	public Boolean viewContainerNotSemanticContainer(EObject self, DSemanticDiagram diag,
			DSemanticDecorator containerView) {
		return containerView.getTarget() != self.eContainer();
	}

	public Boolean noEOpposite(EReference ref) {
		return ref.getEOpposite() == null;
	}

	public boolean hasNoDocAnnotation(EObject eObj) {
		// Error[eAnnotations.details->select(key = 'documentation')->size() =
		// 0/]
		if (eObj instanceof EModelElement) {
			return EcoreUtil.getDocumentation((EModelElement) eObj) == null;
		}
		return true;
	}

	public EdgeArrows arrowsFillDiamond(EObject any) {
		return EdgeArrows.FILL_DIAMOND_LITERAL;
	}

	public FontFormat fontFormatBold(EObject any) {
		return FontFormat.BOLD_LITERAL;
	}

	public void reconnectESuperTypeSource(EObject element, EObject target, EObject source, EObject otherEnd,
			EObject edgeView, EObject sourceView) {
		if (edgeView instanceof DEdge && ((DEdge) edgeView).getSourceNode() instanceof DSemanticDecorator
				&& ((DEdge) edgeView).getTargetNode() instanceof DSemanticDecorator) {
			EObject newSource = ((DSemanticDecorator) ((DEdge) edgeView).getSourceNode()).getTarget();
			EObject newTarget = ((DSemanticDecorator) ((DEdge) edgeView).getTargetNode()).getTarget();

			/*
			 * reconnect source:
			 */
			if (newSource instanceof EClass && newTarget instanceof EClass && source instanceof EClass) {
				((EClass) source).getESuperTypes().remove(newTarget);
				((EClass) newSource).getESuperTypes().add((EClass) newTarget);

			}
		}

	}

	public void reconnectESuperTypeTarget(EObject element, EObject target, EObject source, EObject otherEnd,
			EObject edgeView, EObject sourceView) {
		if (edgeView instanceof DEdge && ((DEdge) edgeView).getSourceNode() instanceof DSemanticDecorator
				&& ((DEdge) edgeView).getTargetNode() instanceof DSemanticDecorator) {
			EObject newTarget = ((DSemanticDecorator) ((DEdge) edgeView).getTargetNode()).getTarget();

			/*
			 * reconnect target:
			 */
			if (newTarget instanceof EClass && target instanceof EClass && element instanceof EClass) {
				((EClass) element).getESuperTypes().remove(newTarget);
				((EClass) element).getESuperTypes().add((EClass) target);

			}
		}

	}

	public void reconnectEReferenceSource(EObject element, EObject newValue) {
		if (newValue instanceof EClass && element instanceof EReference) {

			EReference eRef = (EReference) element;
			EClass srcClass = (EClass) newValue;

			if (eRef.eContainer() != srcClass) {
				srcClass.getEStructuralFeatures().add(eRef);
			}

		}
	}

	public void reconnectEReferenceTarget(EObject element, EObject newValue) {
		if (newValue != null && element instanceof EReference) {

			EReference eRef = (EReference) element;

			if (newValue instanceof EClass) {
				EClass targetClass = (EClass) newValue;
				if (eRef.getEType() != newValue) {
					eRef.setEType(targetClass);
				}
			} else if (newValue instanceof ETypeParameter) {
				if (eRef.getEType() != newValue) {
					EGenericsServices.setETypeWithGenerics(eRef, newValue);
				}
			}

		}
	}

	/**
	 * Create view.
	 * 
	 * @param semanticElement
	 *            Semantic element
	 * @param containerView
	 *            Container view
	 * @param session
	 *            Session
	 * @param containerViewVariable
	 *            Name of the container view variable
	 */
	private void createView(final EObject semanticElement, final DSemanticDecorator containerView,
			final Session session, final String containerViewVariable) {
		// Get all available mappings applicable for the copiedElement in the
		// current container
		List<DiagramElementMapping> semanticElementMappings = getMappings(semanticElement, containerView, session);

		// Build a createView tool
		final CreateView createViewOp = ToolFactory.eINSTANCE.createCreateView();
		for (DiagramElementMapping copiedElementMapping : semanticElementMappings) {
			final DiagramElementMapping tmpCopiedElementMapping = copiedElementMapping;
			createViewOp.setMapping(tmpCopiedElementMapping);
			final String containerViewExpression = "var:" + containerViewVariable;
			createViewOp.setContainerViewExpression(containerViewExpression);

			session.getTransactionalEditingDomain().getCommandStack()
					.execute(new RecordingCommand(session.getTransactionalEditingDomain()) {

						@SuppressWarnings("restriction")
						@Override
						protected void doExecute() {
							try {
								// Get the command context
								DRepresentation representation = null;
								if (containerView instanceof DRepresentation) {
									representation = (DRepresentation) containerView;
								} else if (containerView instanceof DDiagramElement) {
									representation = ((DDiagramElement) containerView).getParentDiagram();
								}

								final CommandContext context = new CommandContext(semanticElement, representation);

								// Execute the create view task
								new CreateViewTask(context, session.getModelAccessor(), createViewOp,
										session.getInterpreter()).execute();
							} catch (MetaClassNotFoundException e) {
								EcoreToolsDesignPlugin.INSTANCE.log(e);
							} catch (FeatureNotFoundException e) {
								EcoreToolsDesignPlugin.INSTANCE.log(e);
							}
						}
					});
		}
	}

	/**
	 * Paste a semantic element and create the corresponding view in the given
	 * container
	 * 
	 * @param container
	 *            Semantic container
	 * @param semanticElement
	 *            Element to paste
	 * @param containerView
	 *            Container view
	 */
	public void paste(final EObject container, final EObject semanticElement, final DSemanticDecorator elementView,
			final DSemanticDecorator containerView) {
		// Paste the semantic element from the clipboard to the selected
		// container
		final Session session = SessionManager.INSTANCE.getSession(container);
		TransactionalEditingDomain domain = session.getTransactionalEditingDomain();
		// The feature is set to null because the domain will deduce it
		Command cmd = AddCommand.create(domain, container, null, semanticElement);
		if (cmd.canExecute()) {
			cmd.execute();
		}
		// Create the view for the pasted element
		createView(semanticElement, containerView, session, "containerView");
	}

	/**
	 * Get mappings available for a semantic element and a given container view.
	 * 
	 * @param semanticElement
	 *            Semantic element
	 * @param containerView
	 *            Container view
	 * @param session
	 *            Session
	 * @return List of mappings which could not be null
	 */
	@SuppressWarnings("restriction")
	private List<DiagramElementMapping> getMappings(final EObject semanticElement,
			final DSemanticDecorator containerView, Session session) {
		ModelAccessor modelAccessor = session.getModelAccessor();
		List<DiagramElementMapping> mappings = new ArrayList<DiagramElementMapping>();

		if (containerView instanceof DSemanticDiagram) {

            for (DiagramElementMapping mapping : ContentHelper.getAllContainerMappings((((DSemanticDiagram) containerView).getDescription()), false)) {
				String domainClass = ((AbstractNodeMapping) mapping).getDomainClass();
				if (modelAccessor.eInstanceOf(semanticElement, domainClass) && !mapping.isCreateElements()) {
					mappings.add(mapping);
				}
			}
            for (DiagramElementMapping mapping : ContentHelper.getAllNodeMappings((((DSemanticDiagram) containerView).getDescription()), false)) {
				String domainClass = ((AbstractNodeMapping) mapping).getDomainClass();
				if (modelAccessor.eInstanceOf(semanticElement, domainClass) && !mapping.isCreateElements()) {
					mappings.add(mapping);
				}
			}
		} else if (containerView instanceof DNodeContainer) {
            for (DiagramElementMapping mapping : ContainerMappingHelper.getAllContainerMappings((((DNodeContainer) containerView).getActualMapping()))) {
				String domainClass = ((AbstractNodeMapping) mapping).getDomainClass();
				if (modelAccessor.eInstanceOf(semanticElement, domainClass) && !mapping.isCreateElements()) {
					mappings.add(mapping);
				}
			}
            for (DiagramElementMapping mapping : ContainerMappingHelper.getAllNodeMappings((((DNodeContainer) containerView).getActualMapping()))) {
				String domainClass = ((AbstractNodeMapping) mapping).getDomainClass();
				if (modelAccessor.eInstanceOf(semanticElement, domainClass) && !mapping.isCreateElements()) {
					mappings.add(mapping);
				}
			}
		}
		return mappings;
	}

	public String getClassesTableName(EObject cur) {
		// [(if (oclIsKindOf(ecore::EStructuralFeature) and
		// oclAsType(ecore::EStructuralFeature).derived) then '/' else '' endif)
		// + name/]
		if (cur instanceof EStructuralFeature) {
			if (((EStructuralFeature) cur).isDerived()) {
				return "/" + ((EStructuralFeature) cur).getName();
			}
		}
		if (cur instanceof ENamedElement) {
			return ((ENamedElement) cur).getName();
		}
		return cur.eClass().getName();
	}

	public boolean hasCDOBundle(EObject cur) {
		return Platform.getBundle("org.eclipse.emf.cdo") != null;
	}

	public EObject enableCDOGen(EObject cur, Set<GenModel> genmodels) throws IOException {
		for (GenModel genModel : genmodels) {
			if (isNotFromPluginsOrRegistry(genModel)) {
				genModel.getModelPluginVariables().add("CDO=org.eclipse.emf.cdo");
				genModel.setRootExtendsInterface("org.eclipse.emf.cdo.CDOObject");
				genModel.setRootExtendsClass("org.eclipse.emf.internal.cdo.CDOObjectImpl");
				genModel.setFeatureDelegation(GenDelegationKind.REFLECTIVE_LITERAL);
				genModel.setProviderRootExtendsClass("org.eclipse.emf.cdo.edit.CDOItemProviderAdapter");

				if (genModel.eResource().getURI().isPlatformResource()) {
					URI cdoMFURI = getCDOMFUri(genModel);
					if (!URIConverter.INSTANCE.exists(cdoMFURI, Collections.EMPTY_MAP)) {
						try (OutputStream out = URIConverter.INSTANCE.createOutputStream(cdoMFURI,
								Collections.EMPTY_MAP)) {
							new PrintWriter(out).write("This is a marker file for bundles with CDO native models.");
						}
					}

				}

			}
		}
		return cur;
	}

	private boolean isNotFromPluginsOrRegistry(GenModel genModel) {
		return genModel.eResource() != null && genModel.eResource().getURI() != null
				&& !genModel.eResource().getURI().isPlatformPlugin();
	}

	private URI getCDOMFUri(GenModel genModel) {
		return URI.createPlatformResourceURI(genModel.eResource().getURI().segment(1), true).appendSegment("META-INF")
				.appendSegment("CDO.MF");
	}

	public EObject disableCDOGen(EObject cur, Set<GenModel> genmodels) throws IOException {
		for (GenModel genModel : genmodels) {
			if (isNotFromPluginsOrRegistry(genModel)) {
				genModel.getModelPluginVariables().remove("CDO=org.eclipse.emf.cdo");
				genModel.setRootExtendsInterface("org.eclipse.emf.ecore.EObject");
				genModel.setRootExtendsClass("org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container");
				genModel.setFeatureDelegation(GenDelegationKind.NONE_LITERAL);
				genModel.setProviderRootExtendsClass(null);

				if (genModel.eResource().getURI().isPlatformResource()) {
					URI cdoMFURI = getCDOMFUri(genModel);
					if (URIConverter.INSTANCE.exists(cdoMFURI, Collections.EMPTY_MAP)) {
						URIConverter.INSTANCE.delete(cdoMFURI, Collections.EMPTY_MAP);
					}

				}
			}
		}
		return cur;
	}

	public String getEClassItemIconPath(GenClass cur) throws IOException {
		String r = "/org.eclipse.emf.ecoretools.design/icons/full/obj16/empty.gif";
		if (cur != null && EMFPlugin.IS_RESOURCES_BUNDLE_AVAILABLE) {
			String icon = cur.getItemIconFileName();
			IFile f = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(icon));
			if (f.exists() && f.isAccessible()) {
				r = icon;
			}
		}
		return r;
	}

}