/*******************************************************************************
 * Copyright (c) 2006, 2018 IBM Corporation 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:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bug 245897
 *	 E.D.Willink Bug 298128
 *******************************************************************************/

package org.eclipse.ocl.uml.internal;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.ocl.types.BagType;
import org.eclipse.ocl.types.CollectionType;
import org.eclipse.ocl.types.OrderedSetType;
import org.eclipse.ocl.types.PrimitiveType;
import org.eclipse.ocl.types.SequenceType;
import org.eclipse.ocl.types.SetType;
import org.eclipse.ocl.uml.UMLEnvironment;
import org.eclipse.ocl.uml.options.UMLParsingOptions;
import org.eclipse.ocl.uml.util.OCLUMLUtil;
import org.eclipse.ocl.util.ObjectUtil;
import org.eclipse.ocl.utilities.ExpressionInOCL;
import org.eclipse.ocl.utilities.OCLFactory;
import org.eclipse.ocl.utilities.UMLReflection;
import org.eclipse.uml2.uml.Association;
import org.eclipse.uml2.uml.BehavioredClassifier;
import org.eclipse.uml2.uml.CallOperationAction;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.DataType;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.EnumerationLiteral;
import org.eclipse.uml2.uml.Feature;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.MultiplicityElement;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.ParameterDirectionKind;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Reception;
import org.eclipse.uml2.uml.SendSignalAction;
import org.eclipse.uml2.uml.Signal;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.TypedElement;
import org.eclipse.uml2.uml.UMLFactory;

/**
 * Implementation of the UML reflection service for the UML environment.
 * 
 * @author Christian W. Damus (cdamus)
 */
public class UMLReflectionImpl
    implements
    UMLReflection<Package, Classifier, Operation, Property, EnumerationLiteral, Parameter, State, CallOperationAction, SendSignalAction, Constraint> {

	private static Set<String> ECORE_INTEGER_TYPES = new java.util.HashSet<String>(
		Arrays.asList(EcorePackage.Literals.EINT.getName(),
			EcorePackage.Literals.EINTEGER_OBJECT.getName(),
			EcorePackage.Literals.ELONG.getName(),
			EcorePackage.Literals.ELONG_OBJECT.getName(),
			EcorePackage.Literals.ESHORT.getName(),
			EcorePackage.Literals.ESHORT_OBJECT.getName(),
			EcorePackage.Literals.EBIG_INTEGER.getName()));

	private static Set<String> ECORE_REAL_TYPES = new java.util.HashSet<String>(
		Arrays.asList(EcorePackage.Literals.EFLOAT.getName(),
			EcorePackage.Literals.EFLOAT_OBJECT.getName(),
			EcorePackage.Literals.EDOUBLE.getName(),
			EcorePackage.Literals.EDOUBLE_OBJECT.getName(),
			EcorePackage.Literals.EBIG_DECIMAL.getName()));

	private static Set<String> ECORE_BOOLEAN_TYPES = new java.util.HashSet<String>(
		Arrays.asList(EcorePackage.Literals.EBOOLEAN.getName(),
			EcorePackage.Literals.EBOOLEAN_OBJECT.getName()));
	
    private final UMLEnvironment env;
    
    public UMLReflectionImpl(UMLEnvironment env) {
        this.env = env;
    }
    
    final java.lang.Class<? extends Association> getAssociationClassType() {
        return env.getValue(UMLParsingOptions.ASSOCIATION_CLASS_TYPE);
    }
    
    /**
     * Default implementation just gets the name of the named element's
     * {@link org.eclipse.emf.ecore.EObject#eClass() metaclass} or, if it is a
     * {@link TypedElement}, the name of its type.
     */
    public String getDescription(Object namedElement) {
        if (namedElement instanceof TypedElement) {
            Type type = ((TypedElement) namedElement).getType();
            return (type == null) ? OCLStandardLibraryImpl.INSTANCE
                .getOclVoid().getName()
                : type.getName();
        } else if (namedElement instanceof EnumerationLiteral) {
            return ((EnumerationLiteral) namedElement).getEnumeration()
                .getName();
        } else if (namedElement == null) {
            return null;
        }

        return ((EObject) namedElement).eClass().getName();
    }
    
    public String getName(Object namedElement) {
        return (namedElement instanceof NamedElement)?
            ((NamedElement) namedElement).getName() : null;
    }
    
    public String getQualifiedName(Object namedElement) {
        return (namedElement instanceof NamedElement)?
            ((NamedElement) namedElement).getQualifiedName() : null;
    }
    
    public Classifier getOCLType(Object metaElement) {
        Classifier result = null;
        
        if (metaElement instanceof TypedElement) {
            TypedElement typedElement = (TypedElement) metaElement;
            result = (Classifier) typedElement.getType();
            
            if (result == null) {
                // absence of a type in UML indicates void type
                result = OCLStandardLibraryImpl.INSTANCE.getOclVoid();
            }
            
            if (isMany(typedElement)) {
                result = getOCLCollectionType(
                        result,
                        isOrdered(typedElement),
                        isUnique(typedElement));
            } else {
                result = getOCLType(result);
            }
        } else if (metaElement instanceof Operation) {
            // Operations are not TypedElements!
            Operation operation = (Operation) metaElement;
            result = (Classifier) operation.getType();
            
            if (result == null) {
                // absence of a type in UML indicates void type
                result = OCLStandardLibraryImpl.INSTANCE.getOclVoid();
            }
            
            if (isMany(operation)) {
                result = getOCLCollectionType(
                        result,
                        isOrdered(operation),
                        isUnique(operation));
            } else {
                result = getOCLType(result);
            }
        } else if (metaElement instanceof Classifier) {
            result = getOCLType((Classifier) metaElement);
        }
        
        return result;
    }
    
    public boolean isMany(Object metaElement) {
        if (metaElement instanceof MultiplicityElement) {
            return ((MultiplicityElement) metaElement).isMultivalued();
        } else if (metaElement instanceof Operation) {
            int upper = ((Operation) metaElement).getUpper();
            return (upper > 1) || (upper < 0);
        }
        
        return false;
    }
    
    /**
     * Queries whether the specified {@link MultiplicityElement} or
     * {@link Operation} is unique.
     * 
     * @param metaElement a multiplicity-element or operation
     * @return whether it is unique
     */
    protected boolean isUnique(Object metaElement) {
        if (metaElement instanceof MultiplicityElement) {
            return ((MultiplicityElement) metaElement).isUnique();
        } else if (metaElement instanceof Operation) {
            return ((Operation) metaElement).isUnique();
        }
        
        return false;
    }
    
    /**
     * Queries whether the specified {@link MultiplicityElement} or
     * {@link Operation} is ordered.
     * 
     * @param metaElement a multiplicity-element or operation
     * @return whether it is ordered
     */
    protected boolean isOrdered(Object metaElement) {
        if (metaElement instanceof MultiplicityElement) {
            return ((MultiplicityElement) metaElement).isOrdered();
        } else if (metaElement instanceof Operation) {
            return ((Operation) metaElement).isOrdered();
        }
        
        return false;
    }
    
    public Classifier asOCLType(Classifier modelType) {
        return getOCLType(modelType);
    }
    
    public Package getNestingPackage(Package pkg) {
        return pkg.getNestingPackage();
    }
    
    public List<Package> getNestedPackages(Package pkg) {
        return pkg.getNestedPackages();
    }
    
    public Package getPackage(Classifier classifier) {
        return classifier.getNearestPackage();
    }
    
    public List<Classifier> getClassifiers(Package pkg) {
        EList<Type> types = pkg.getOwnedTypes();
        List<Classifier> result = new java.util.ArrayList<Classifier>(types.size());
        
        for (Type t : types) {
            if (t instanceof Classifier) {
                result.add((Classifier) t);
            }
        }
        
        return result;
    }
    
    public Classifier getOwningClassifier(Object feature) {
        Classifier result = null;
        
        if (feature instanceof Feature) {
            result = (Classifier) ((Feature) feature).getOwner();
        }
        
        if (result instanceof Class) {
            Classifier shadowed = OCLStandardLibraryImpl.getRealClassifier(
                (Class) result);
            
            if (shadowed != null) {
                result = shadowed;
            }
        }
        
        return result;
    }
    
    public List<Parameter> getParameters(Operation operation) {
        List<Parameter> result = new java.util.ArrayList<Parameter>(
                operation.getOwnedParameters().size());
        
        for (Parameter p : operation.getOwnedParameters()) {
            if (p.getDirection() != ParameterDirectionKind.RETURN_LITERAL) {
                result.add(p);
            }
        }
        
        return result;
    }
    
    public Operation createOperation(String name, Classifier resultType,
            List<String> paramNames, List<Classifier> paramTypes) {
        
        Operation result = UMLFactory.eINSTANCE.createOperation();
        result.setName(name);
        
        // OCL can only define query operations
        result.setIsQuery(true);
        
        if (resultType != null) {
            result.setType(resultType);
        }
        
        int i = 0;
        for (String pname : paramNames) {
            result.createOwnedParameter(pname, paramTypes.get(i++));
        }
        
        return result;
    }
    
    public List<Operation> getOperations(Classifier classifier) {
        return OCLUMLUtil.getAllOperations(classifier);
    }
    
    public Property createProperty(String name, Classifier resultType) {
        Property result = UMLFactory.eINSTANCE.createProperty();
        
        result.setName(name);
        result.setType(resultType);
        
        return result;
    }
    
    public List<Property> getAttributes(Classifier classifier) {
        return OCLUMLUtil.getAllAttributes(classifier);
    }
    
    public Collection<? extends Classifier> getAllSupertypes(
            Classifier classifier) {
        
        return classifier.allParents();
    }
    
    public boolean isQuery(Operation operation) {
        return operation.isQuery();
    }
    
    public boolean isStatic(Object feature) {
        return (feature instanceof Feature) && ((Feature) feature).isStatic();
    }
    
    public boolean setIsStatic(Object feature, boolean isStatic) {
        if (!(feature instanceof Feature))
        	return false;
        ((Feature) feature).setIsStatic(isStatic);
        return true;
    }

    public boolean isAssociationClass(Classifier classifier) {
        return getAssociationClassType().isInstance(classifier);
    }
    
    public Classifier getAssociationClass(Property property) {
        return getAssociationClassType().isInstance(property.getAssociation())?
                property.getAssociation() : null;
    }
    
    public List<Property> getMemberEnds(Classifier associationClass) {
        if (getAssociationClassType().isInstance(associationClass)) {
            return ((Association) associationClass).getMemberEnds();
        }
        
        return Collections.emptyList();
    }

    public boolean isOperation(Object metaElement) {
        return metaElement instanceof Operation;
    }

	public boolean isPackage(Object metaElement) {
        return metaElement instanceof Package;
	}
    
    public boolean isProperty(Object metaElement) {
        return metaElement instanceof Property;
    }
    
    public boolean isClassifier(Object metaElement) {
        return metaElement instanceof Classifier;
    }
    
    public boolean isClass(Object metaElement) {
        return metaElement instanceof Class;
    }

	public boolean isConstraint(Object metaElement) {
        return metaElement instanceof Constraint;
	}
    
    public boolean isDataType(Object metaElement) {
        return metaElement instanceof DataType;
    }
    
    public boolean isStereotype(Classifier type) {
        return type instanceof Stereotype;
    }
    
    public Object getStereotypeApplication(Object baseElement,
            Classifier stereotype) {
        Object result = null;
        
        if (baseElement instanceof Element) {
            Element element = (Element) baseElement;
            Stereotype stereo = (Stereotype) stereotype;
            
            if (element.isStereotypeApplied(stereo)) {
                result = element.getStereotypeApplication(stereo);
            }
 
    		if (result == null) {
    			// maybe some specializing stereotype is applied?

				List<Stereotype> applied = element
					.getAppliedSubstereotypes(stereo);
				if (!applied.isEmpty()) {
					return element.getStereotypeApplication(applied.get(0));
				}
    		}
       }
        
        return result;
    }
    
    public boolean isEnumeration(Classifier type) {
        return type instanceof Enumeration;
    }

    public Classifier getEnumeration(EnumerationLiteral enumerationLiteral) {
        return enumerationLiteral.getEnumeration();
    }

    public List<EnumerationLiteral> getEnumerationLiterals(Classifier enumerationType) {
        return ((Enumeration) enumerationType).getOwnedLiterals();
    }
    
    public EnumerationLiteral getEnumerationLiteral(Classifier enumerationType,
            String literalName) {
        return ((Enumeration) enumerationType).getOwnedLiteral(literalName);
    }
    
    public boolean isComparable(Classifier type) {
        if ((type instanceof PrimitiveType<?>)
            || (type.getOperation("<", null, null) != null)) { //$NON-NLS-1$
            
            return true;
        }
        
        EClassifier eclassifier = env.getEClassifier(type, null);
        
        return (eclassifier != null)
            && Comparable.class.isAssignableFrom(eclassifier.getInstanceClass());
    }
    
    public Operation getOperation(CallOperationAction callOperationAction) {
        return callOperationAction.getOperation();
    }
    
    public Classifier getSignal(SendSignalAction sendSignalAction) {
        return sendSignalAction.getSignal();
    }
    
    public String getStereotype(Constraint constraint) {
        EList<String> keywords = constraint.getKeywords();
        return keywords.isEmpty()? null : keywords.get(0);
    }
    
    public void setStereotype(Constraint constraint, String stereotype) {
        // first, clear existing keywords (there wouldn't usually be any)
        for (String keyword : constraint.getKeywords()) {
            constraint.removeKeyword(keyword);
        }
        
        constraint.addKeyword(stereotype);
    }
    
    public String getConstraintName(Constraint constraint) {
        return constraint.getName();
    }
    
    public void setConstraintName(Constraint constraint, String name) {
        constraint.setName(name);
    }
    
    public ExpressionInOCL<Classifier, Parameter>
    getSpecification(Constraint constraint) {
        
        if (constraint.getSpecification() instanceof ExpressionInOCL<?, ?>) {
            return (org.eclipse.ocl.uml.ExpressionInOCL) constraint.getSpecification();
        }
        
        return null;
    }
    
    public void setSpecification(
            Constraint constraint,
            org.eclipse.ocl.utilities.ExpressionInOCL<Classifier, Parameter> specification) {
        
        constraint.setSpecification(
            (org.eclipse.ocl.uml.ExpressionInOCL) specification);
    }
    
    public Constraint getConstraint(
            ExpressionInOCL<Classifier, Parameter> specification) {
        EObject container = specification.eContainer();
        
        if (container instanceof Constraint) {
            return (Constraint) container;
        }
        
        return null;
    }
    
    public List<Element> getConstrainedElements(Constraint constraint) {
        return constraint.getConstrainedElements();
    }

	public void addConstrainedElement(Constraint constraint, EObject constrainedElement) {
		constraint.getConstrainedElements().add((Element) constrainedElement);
	}
    
    public List<Property> getQualifiers(Property property) {
        return property.getQualifiers();
    }

    public Classifier getCommonSuperType(Classifier type1, Classifier type2) {
    
        if (ObjectUtil.equal(type1, type2)) {
            return type2;
        }
        
        if (type1.conformsTo(type2)) {
            return type2;
        }
        if (type2.conformsTo(type1)) {
            return type1;
        }
        List<Classifier> type1Ancestors = new ArrayList<Classifier>(
                type1.allParents());
        
        List<Classifier> type2Ancestors = new ArrayList<Classifier>(
                type2.allParents());
        
        type1Ancestors.retainAll(type2Ancestors);
        if (!type1Ancestors.isEmpty()) {
            // the least common ancestor type will be the first, because UML
            //   computes the ancestors starting with the immediate parents
            return type1Ancestors.get(0);
        }
    
        return null;
    }

    public int getRelationship(Classifier type1, Classifier type2) {
        if (ObjectUtil.equal(type1, type2)) {
            return SAME_TYPE;
        }
        
        if (type2.conformsTo(type1)) {
            return STRICT_SUPERTYPE;
        } else if (type1.conformsTo(type2)) {
            return STRICT_SUBTYPE;
        } else if ((type2 instanceof BehavioredClassifier) && (type1 instanceof Interface)) {
            for (Interface i : ((BehavioredClassifier) type2).getAllImplementedInterfaces()) {
                if (i.conformsTo(type1)) {
                    return STRICT_SUPERTYPE;
                }
            }
        } else if ((type1 instanceof BehavioredClassifier) && (type2 instanceof Interface)) {
            for (Interface i : ((BehavioredClassifier) type1).getAllImplementedInterfaces()) {
                if (i.conformsTo(type2)) {
                    return STRICT_SUBTYPE;
                }
            }
        }
    
        return UNRELATED_TYPE;
    }

    /**
     * Translator from primitive UML types to OCL types
     * 
     * @param dataType a data type in the UML metamodel
     * @return the corresponding OCL classifier
     */
    private Classifier getOCLTypeFor(DataType dataType) {
    
        // First check if it is already an OCL data type (Enumerations represent
        //    themselves)
        if (dataType instanceof Enumeration) {
            return dataType;
        }
        if (dataType instanceof CollectionType<?, ?>) {
            return dataType;
        }
        if (dataType instanceof PrimitiveType<?>) {
            return dataType;
        }
    
        if (dataType instanceof org.eclipse.uml2.uml.PrimitiveType) {
            // Boolean -> OCL_BOOLEAN
            if (PrimitiveType.BOOLEAN_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getBoolean();
            } else if (PrimitiveType.REAL_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getReal();
            } else if (PrimitiveType.STRING_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getString();
            } else if (PrimitiveType.INTEGER_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getInteger();
            } else if (PrimitiveType.UNLIMITED_NATURAL_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getUnlimitedNatural();
            } else if (SequenceType.SINGLETON_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getSequence();
            } else if (SetType.SINGLETON_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getSet();
            } else if (BagType.SINGLETON_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getBag();
            } else if (OrderedSetType.SINGLETON_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getOrderedSet();
            } else if (CollectionType.SINGLETON_NAME.equals(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getCollection();
            } else if ("Object".equals(dataType.getName())) { //$NON-NLS-1$
                return OCLStandardLibraryImpl.INSTANCE.getOclAny();
            } else if (ECORE_INTEGER_TYPES.contains(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getInteger();
            } else if (ECORE_REAL_TYPES.contains(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getReal();
            } else if (ECORE_BOOLEAN_TYPES.contains(dataType.getName())) {
                return OCLStandardLibraryImpl.INSTANCE.getBoolean();
            } else if ("EString".equals(dataType.getName())) { //$NON-NLS-1$
                return OCLStandardLibraryImpl.INSTANCE.getString();
            }
        }
        
        // All other data types map to themselves
        return dataType;
    }

    /**
     * Obtains the appropriate OCL type for a {@link Classifier}, if it
     * corresponds to an OCL primitive type.
     * 
     * @param type the type to convert to an OCL type
     * @return the corresponding OCL type
     */ 
    Classifier getOCLType(Classifier type) {
        Classifier resultType = type;
    
        if (resultType instanceof DataType) {
            resultType = getOCLTypeFor((DataType) resultType);
        }
        
        return resultType;
    }

    /**
     * Obtains the appropriate OCL collection type for a {@link Classifier}, 
     * according to the collection's orderedness and uniqueness.  The mapping is
     * as follows:
     * <ul>
     *   <li>ordered, unique: ordered set type</li>
     *   <li>ordered, non-unique: sequence type</li>
     *   <li>non-ordered, unique: set type</li>
     *   <li>non-ordered, non-unique: bag type</li>
     * </ul>
     * <p>
     * Note that the collection's element <code>type</code> is mapped to an
     * OCL primitive type where possible.
     * </p>
     * 
     * @param type the type to get the corresponding OCL collection type for
     * @param isOrdered whether the OCL type should be ordered
     * @param isUnique whether the OCL type should be unique
     * 
     * @return the corresponding OCL type
     * 
     * @see #getOCLType(Classifier)
     */ 
    Classifier getOCLCollectionType(Classifier type,
            boolean isOrdered, boolean isUnique) {
        Classifier resultType = type;
    
        if (resultType instanceof DataType) {
            resultType = getOCLTypeFor((DataType) resultType);
        }
        
        OCLFactory oclFactory = OCLFactoryImpl.INSTANCE;
        
        if (isOrdered) {
            if (isUnique) {
                resultType = (Classifier) oclFactory.createOrderedSetType(resultType);
            } else {
                resultType = (Classifier) oclFactory.createSequenceType(resultType);
            }
        } else {
            if (isUnique) {
                resultType = (Classifier) oclFactory.createSetType(resultType);
            } else {
                resultType = (Classifier) oclFactory.createBagType(resultType);
            }
        }
        
        return resultType;
    }

    public List<Classifier> getSignals(Classifier owner) {
        if (owner instanceof Class) {
            List<Reception> receptions = OCLUMLUtil.getAllReceptions((Class) owner);
            
            if (!receptions.isEmpty()) {
                List<Classifier> result = new java.util.ArrayList<Classifier>(
                        receptions.size());
                
                for (Reception r : receptions) {
                    if (r.getSignal() != null) {
                        result.add(r.getSignal());
                    }
                }
                
                return result;
            }
        }
        
        return Collections.emptyList();
    }

    public CallOperationAction createCallOperationAction(Operation operation) {
        CallOperationAction result = UMLFactory.eINSTANCE.createCallOperationAction();
        result.setOperation(operation);
        return result;
    }

    public SendSignalAction createSendSignalAction(Classifier signal) {
        SendSignalAction result = UMLFactory.eINSTANCE.createSendSignalAction();
        result.setSignal((Signal) signal);
        return result;
    }

    public Constraint createConstraint() {
        return UMLFactory.eINSTANCE.createConstraint();
    }

    public ExpressionInOCL<Classifier, Parameter> createExpressionInOCL() {
        return org.eclipse.ocl.uml.UMLFactory.eINSTANCE.createExpressionInOCL();
    }
    
    public void setName(
    		org.eclipse.ocl.utilities.TypedElement<Classifier> element,
    		String name) {
    	element.setName(name);
    }
    
    public void setType(
    		org.eclipse.ocl.utilities.TypedElement<Classifier> element,
    		Classifier type) {
    	element.setType(type);
    }
}