/*******************************************************************************
 * Copyright (c) 2012, 2019 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.completeocl.cs2as;

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

import org.eclipse.emf.ecore.EObject;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.pivot.CompleteClass;
import org.eclipse.ocl.pivot.CompleteModel;
import org.eclipse.ocl.pivot.Constraint;
import org.eclipse.ocl.pivot.Element;
import org.eclipse.ocl.pivot.ExpressionInOCL;
import org.eclipse.ocl.pivot.Import;
import org.eclipse.ocl.pivot.Iteration;
import org.eclipse.ocl.pivot.LanguageExpression;
import org.eclipse.ocl.pivot.Model;
import org.eclipse.ocl.pivot.Operation;
import org.eclipse.ocl.pivot.Parameter;
import org.eclipse.ocl.pivot.PivotPackage;
import org.eclipse.ocl.pivot.Property;
import org.eclipse.ocl.pivot.Type;
import org.eclipse.ocl.pivot.internal.scoping.EnvironmentView;
import org.eclipse.ocl.pivot.internal.scoping.ScopeFilter;
import org.eclipse.ocl.pivot.utilities.ClassUtil;
import org.eclipse.ocl.pivot.utilities.NameUtil;
import org.eclipse.ocl.pivot.utilities.PivotUtil;
import org.eclipse.ocl.xtext.base.cs2as.CS2AS;
import org.eclipse.ocl.xtext.base.cs2as.CS2ASConversion;
import org.eclipse.ocl.xtext.base.cs2as.Continuation;
import org.eclipse.ocl.xtext.basecs.ConstraintCS;
import org.eclipse.ocl.xtext.basecs.ParameterCS;
import org.eclipse.ocl.xtext.basecs.PathElementCS;
import org.eclipse.ocl.xtext.basecs.PathNameCS;
import org.eclipse.ocl.xtext.completeoclcs.ClassifierContextDeclCS;
import org.eclipse.ocl.xtext.completeoclcs.CompleteOCLDocumentCS;
import org.eclipse.ocl.xtext.completeoclcs.ContextDeclCS;
import org.eclipse.ocl.xtext.completeoclcs.DefCS;
import org.eclipse.ocl.xtext.completeoclcs.DefOperationCS;
import org.eclipse.ocl.xtext.completeoclcs.DefPropertyCS;
import org.eclipse.ocl.xtext.completeoclcs.OperationContextDeclCS;
import org.eclipse.ocl.xtext.completeoclcs.PackageDeclarationCS;
import org.eclipse.ocl.xtext.completeoclcs.PropertyContextDeclCS;
import org.eclipse.ocl.xtext.completeoclcs.util.AbstractCompleteOCLCSContainmentVisitor;
import org.eclipse.ocl.xtext.essentialoclcs.ExpSpecificationCS;

public class CompleteOCLCSContainmentVisitor extends AbstractCompleteOCLCSContainmentVisitor
{
	public class OperationDeclScopeFilter implements ScopeFilter
	{
		protected final @NonNull OperationContextDeclCS csElement;

		public OperationDeclScopeFilter(@NonNull OperationContextDeclCS csElement) {
			this.csElement = csElement;
		}

		@Override
		public boolean matches(@NonNull EnvironmentView environmentView, @NonNull Object object) {
			if (object instanceof Iteration) {
				return false;
			}
			if (object instanceof Operation) {
				Element owningElement = null;
				EObject csContainer = csElement.eContainer();
				List<PathElementCS> csPathElements = csElement.getOwnedPathName().getOwnedPathElements();
				if (csPathElements.size() > 1) {
					owningElement = csPathElements.get(csPathElements.size()-2).basicGetReferredElement();
				} else if (csContainer instanceof ClassifierContextDeclCS) {
					owningElement = ((ClassifierContextDeclCS)csContainer).getReferredClass();
				}
				if (!(owningElement instanceof Type)) {
					return false;
				}
				CompleteModel completeModel = environmentView.getEnvironmentFactory().getCompleteModel();
				CompleteClass owningCompleteClass = completeModel.getCompleteClass((Type) owningElement);
				Operation candidateOperation = (Operation)object;
				Type candidateClass = candidateOperation.getOwningClass();
				if (candidateClass == null) {
					return false;
				}
				CompleteClass candidateCompleteClass = completeModel.getCompleteClass(candidateClass);
				if (candidateCompleteClass != owningCompleteClass) {
					return false;
				}
				List<Parameter> candidateParameters = candidateOperation.getOwnedParameters();
				List<ParameterCS> csParameters = csElement.getOwnedParameters();
				assert csParameters != null;
				int iMax = csParameters.size();
				if (iMax != candidateParameters.size()) {
					return false;
				}
				return true;
			}
			else {
				return false;
			}
		}
	}

	public CompleteOCLCSContainmentVisitor(@NonNull CS2ASConversion context) {
		super(context);
	}

	private org.eclipse.ocl.pivot.@NonNull Class contextClass(org.eclipse.ocl.pivot.@NonNull Class modelClass,
			@NonNull List<@NonNull ContextDeclCS> contextDecls) {
		List<@NonNull ConstraintCS> allInvariants = new ArrayList<>();
		List<@NonNull ClassifierContextDeclCS> classifierContextDecls = new ArrayList<>();
		List<@NonNull OperationContextDeclCS> operationContextDecls = new ArrayList<>();
		List<@NonNull PropertyContextDeclCS> propertyContextDecls = new ArrayList<>();
		List<@NonNull DefOperationCS> defOperations = new ArrayList<>();
		List<@NonNull DefPropertyCS> defProperties = new ArrayList<>();
		for (@NonNull ContextDeclCS contextDecl : contextDecls) {
			if (contextDecl instanceof ClassifierContextDeclCS) {
				ClassifierContextDeclCS classifierContextDecl = (ClassifierContextDeclCS)contextDecl;
				classifierContextDecls.add(classifierContextDecl);
				allInvariants.addAll(ClassUtil.nullFree(classifierContextDecl.getOwnedInvariants()));
				for (@NonNull DefCS csDef : ClassUtil.nullFree(classifierContextDecl.getOwnedDefinitions())) {
					if (csDef instanceof DefOperationCS) {
						defOperations.add((DefOperationCS) csDef);
					}
					else if (csDef instanceof DefPropertyCS) {
						defProperties.add((DefPropertyCS) csDef);
					}
				}
			}
			else if (contextDecl instanceof OperationContextDeclCS) {
				operationContextDecls.add((OperationContextDeclCS) contextDecl);
			}
			else if (contextDecl instanceof PropertyContextDeclCS) {
				PropertyContextDeclCS propertyContextDecl = (PropertyContextDeclCS) contextDecl;
				propertyContextDecls.add(propertyContextDecl);
				//	allInvariants.addAll(ClassUtil.nullFree(propertyContextDecl.getOwnedDerivedInvariants()));
			}
		}
		List<@NonNull Operation> contextOperations = new ArrayList<>();
		for (@NonNull OperationContextDeclCS operationContextDecl : operationContextDecls) {
			Operation contextOperation = contextOperation(operationContextDecl);
			contextOperations.add(contextOperation);
		}
		for (@NonNull DefOperationCS defOperation : defOperations) {
			Operation contextOperation = PivotUtil.getPivot(Operation.class, defOperation);
			if (contextOperation != null) {
				contextOperations.add(contextOperation);
			}
		}
		Collections.sort(contextOperations, NameUtil.NAMEABLE_COMPARATOR);
		List<@NonNull Property> contextProperties = new ArrayList<>();
		for (@NonNull PropertyContextDeclCS propertyContextDecl : propertyContextDecls) {
			Property contextProperty = contextProperty(propertyContextDecl);
			contextProperties.add(contextProperty);
		}
		for (@NonNull DefPropertyCS defProperty : defProperties) {
			Property contextProperty = PivotUtil.getPivot(Property.class, defProperty);
			if (contextProperty != null) {
				contextProperties.add(contextProperty);
			}
		}
		Collections.sort(contextProperties, NameUtil.NAMEABLE_COMPARATOR);
		ClassifierContextDeclCS csElement = classifierContextDecls.size() > 0 ? classifierContextDecls.get(0) : null;
		org.eclipse.ocl.pivot.Class contextClass = context.refreshModelElement(org.eclipse.ocl.pivot.Class.class, PivotPackage.Literals.CLASS, csElement);
		contextClass.setName(modelClass.getName());
		context.refreshPivotList(Constraint.class, contextClass.getOwnedInvariants(), allInvariants);
		helper.refreshList(contextClass.getOwnedOperations(), contextOperations);
		helper.refreshList(contextClass.getOwnedProperties(), contextProperties);
		context.refreshComments(contextClass, csElement);
		for (@NonNull ContextDeclCS contextDecl : contextDecls) {
			if (contextDecl instanceof ClassifierContextDeclCS) {
				context.installPivotUsage(contextDecl, contextClass);
			}
		}
		return contextClass;
	}

	private @NonNull Operation contextOperation(@NonNull OperationContextDeclCS operationContextDecl) {
		Operation contextOperation = context.refreshModelElement(Operation.class, PivotPackage.Literals.OPERATION, operationContextDecl);
		Operation modelOperation = operationContextDecl.getReferredOperation();
		if (modelOperation != null) {
			helper.refreshName(contextOperation, ClassUtil.nonNullModel(modelOperation.getName()));
			helper.setType(contextOperation, modelOperation.getType(), modelOperation.isIsRequired());
			List<ExpSpecificationCS> ownedBodies = operationContextDecl.getOwnedBodies();
			ExpSpecificationCS ownedBody = ownedBodies.size() > 0 ? ownedBodies.get(0) : null;
			LanguageExpression languageExpression = ownedBody != null ? PivotUtil.getPivot(LanguageExpression.class,  ownedBody) : null;
			contextOperation.setBodyExpression(languageExpression);
			context.refreshPivotList(Parameter.class, contextOperation.getOwnedParameters(), operationContextDecl.getOwnedParameters());
			context.refreshPivotList(Constraint.class, contextOperation.getOwnedPreconditions(), operationContextDecl.getOwnedPreconditions());
			context.refreshPivotList(Constraint.class, contextOperation.getOwnedPostconditions(), operationContextDecl.getOwnedPostconditions());
		}
		context.refreshComments(contextOperation, operationContextDecl);
		return contextOperation;
	}

	private org.eclipse.ocl.pivot.@NonNull Package contextPackage(org.eclipse.ocl.pivot.@NonNull Package modelPackage,
			@NonNull List<@NonNull PackageDeclarationCS> packageDecls, @NonNull List<@NonNull ContextDeclCS> contextDecls) {
		List<@NonNull ConstraintCS> packageInvariants = new ArrayList<>();
		List<@NonNull ContextDeclCS> allContextDecls = new ArrayList<>(contextDecls);
		for (@NonNull PackageDeclarationCS packageDecl : packageDecls) {
			packageInvariants.addAll(ClassUtil.nullFree(packageDecl.getOwnedInvariants()));
			allContextDecls.addAll(ClassUtil.nullFree(packageDecl.getOwnedContexts()));
		}
		Set<org.eclipse.ocl.pivot.@NonNull Class> modelClasses = new HashSet<>();
		for (@NonNull ContextDeclCS contextDecl : allContextDecls) {
			org.eclipse.ocl.pivot.Class modelClass = getReferredClass(contextDecl);
			if (modelClass != null) {
				modelClasses.add(modelClass);
			}
		}
		List<org.eclipse.ocl.pivot.@NonNull Class> sortedModelClasses = new ArrayList<>(modelClasses);
		Collections.sort(sortedModelClasses, NameUtil.NAMEABLE_COMPARATOR);
		List<org.eclipse.ocl.pivot.@NonNull Class> contextClasses = new ArrayList<>();
		for (org.eclipse.ocl.pivot.@NonNull Class modelClass : sortedModelClasses) {
			List<@NonNull ContextDeclCS> selectedContexts = new ArrayList<>();
			for (@NonNull ContextDeclCS csContext : allContextDecls) {
				org.eclipse.ocl.pivot.Class asClass = getReferredClass(csContext);
				if (modelClass == asClass) {
					selectedContexts.add(csContext);
				}
			}
			org.eclipse.ocl.pivot.Class contextClass = contextClass(modelClass, selectedContexts);
			contextClasses.add(contextClass);
		}
		PackageDeclarationCS csElement = packageDecls.size() > 0 ? packageDecls.get(0) : null;
		org.eclipse.ocl.pivot.Package contextPackage = context.refreshModelElement(org.eclipse.ocl.pivot.Package.class, PivotPackage.Literals.PACKAGE, csElement);
		contextPackage.setName(modelPackage.getName());
		contextPackage.setURI(modelPackage.getURI());
		helper.refreshList(contextPackage.getOwnedClasses(), contextClasses);
		context.refreshComments(contextPackage, csElement);
		for (int i = 1; i < packageDecls.size(); i++) {
			csElement = packageDecls.get(i);
			context.installPivotUsage(csElement, contextPackage);
		}
		return contextPackage;
	}

	private org.eclipse.ocl.pivot.@Nullable Package contextPackageParent(@NonNull Map<org.eclipse.ocl.pivot.@NonNull Package, org.eclipse.ocl.pivot.@NonNull Package> modelPackage2contextPackage,
			org.eclipse.ocl.pivot.@NonNull Package modelPackage, Map<org.eclipse.ocl.pivot.@Nullable Package, @NonNull List<org.eclipse.ocl.pivot.@NonNull Package>> contextPackage2childContextPackages) {
		org.eclipse.ocl.pivot.Package contextPackage = modelPackage2contextPackage.get(modelPackage);
		assert contextPackage != null;
		org.eclipse.ocl.pivot.Package parentContextPackage = null;
		org.eclipse.ocl.pivot.Package parentModelPackage = modelPackage.getOwningPackage();
		if (parentModelPackage != null) {
			parentContextPackage = modelPackage2contextPackage.get(parentModelPackage);
			if (parentContextPackage == null) {
				parentContextPackage = context.refreshModelElement(org.eclipse.ocl.pivot.Package.class, PivotPackage.Literals.PACKAGE, null);
				parentContextPackage.setName(modelPackage.getName());
				parentContextPackage.setURI(modelPackage.getURI());
				modelPackage2contextPackage.put(parentModelPackage, parentContextPackage);
			}
			contextPackageParent(modelPackage2contextPackage, parentModelPackage, contextPackage2childContextPackages);
		}
		List<org.eclipse.ocl.pivot.@NonNull Package> childContextPackages = contextPackage2childContextPackages.get(parentContextPackage);			// null key for Model root
		if (childContextPackages == null) {
			childContextPackages = new ArrayList<>();
			contextPackage2childContextPackages.put(parentContextPackage, childContextPackages);
		}
		if (!childContextPackages.contains(contextPackage)) {
			childContextPackages.add(contextPackage);
		}
		return parentContextPackage;
	}

	private @NonNull Property contextProperty(@NonNull PropertyContextDeclCS propertyContextDecl) {
		Property contextProperty = context.refreshModelElement(Property.class, PivotPackage.Literals.PROPERTY, propertyContextDecl);
		Property modelProperty = propertyContextDecl.getReferredProperty();
		if (modelProperty != null) {
			helper.refreshName(contextProperty, ClassUtil.nonNullModel(modelProperty.getName()));
			helper.setType(contextProperty, modelProperty.getType(), modelProperty.isIsRequired());
			List<ExpSpecificationCS> ownedDefaultExpressions = propertyContextDecl.getOwnedDefaultExpressions();
			int size = ownedDefaultExpressions.size();
			if (size > 1) {
				context.addError(propertyContextDecl, "Only one init/derive value allowed");
			}
			ExpSpecificationCS ownedDefaultExpression = size > 0 ? ownedDefaultExpressions.get(0) : null;
			LanguageExpression languageExpression = ownedDefaultExpression != null ? PivotUtil.getPivot(LanguageExpression.class,  ownedDefaultExpression) : null;
			contextProperty.setOwnedExpression(languageExpression);
		}
		context.refreshComments(contextProperty, propertyContextDecl);
		return contextProperty;
	}

	private org.eclipse.ocl.pivot.@Nullable Class getReferredClass(ContextDeclCS csContext) {
		if (csContext instanceof ClassifierContextDeclCS) {
			return ((ClassifierContextDeclCS)csContext).getReferredClass();
		}
		else if (csContext instanceof OperationContextDeclCS) {
			Operation modelOperation = ((OperationContextDeclCS)csContext).getReferredOperation();
			return modelOperation != null ? modelOperation.getOwningClass() : null;
		}
		else if (csContext instanceof PropertyContextDeclCS) {
			Property modelProperty = ((PropertyContextDeclCS)csContext).getReferredProperty();
			return modelProperty != null ? modelProperty.getOwningClass() : null;
		}
		return null;
	}

	private org.eclipse.ocl.pivot.@Nullable Package getReferredPackage(@NonNull ContextDeclCS csContext) {
		org.eclipse.ocl.pivot.Class modelClass = getReferredClass(csContext);
		return modelClass != null ? modelClass.getOwningPackage() : null;
	}

	@Override
	public Continuation<?> visitClassifierContextDeclCS(@NonNull ClassifierContextDeclCS csElement) {
		return null;
	}

	@Override
	public Continuation<?> visitCompleteOCLDocumentCS(@NonNull CompleteOCLDocumentCS csElement) {
		//
		//	Locate the model packages that need context packages
		//
		Set<org.eclipse.ocl.pivot.@NonNull Package> modelPackages = new HashSet<>();
		List<@NonNull PackageDeclarationCS> ownedPackages = ClassUtil.nullFree(csElement.getOwnedPackages());
		for (@NonNull PackageDeclarationCS csPackage : ownedPackages) {
			org.eclipse.ocl.pivot.Package modelPackage = csPackage.getReferredPackage();
			if (modelPackage != null) {
				modelPackages.add(modelPackage);
				for (org.eclipse.ocl.pivot.Package parentModelPackage = modelPackage; (parentModelPackage = parentModelPackage.getOwningPackage()) != null; ) {
					modelPackages.add(parentModelPackage);
				}
			}
		}
		List<@NonNull ContextDeclCS> ownedContexts = ClassUtil.nullFree(csElement.getOwnedContexts());
		for (@NonNull ContextDeclCS csContext : ownedContexts) {
			org.eclipse.ocl.pivot.Package modelPackage = getReferredPackage(csContext);
			if (modelPackage != null) {
				modelPackages.add(modelPackage);
				for (org.eclipse.ocl.pivot.Package parentModelPackage = modelPackage; (parentModelPackage = parentModelPackage.getOwningPackage()) != null; ) {
					modelPackages.add(parentModelPackage);
				}
			}
		}
		//
		//	Refresh the context packages
		//
		Map<org.eclipse.ocl.pivot.@NonNull Package, org.eclipse.ocl.pivot.@NonNull Package> modelPackage2contextPackage = new HashMap<>();
		for (org.eclipse.ocl.pivot.@NonNull Package modelPackage : modelPackages) {
			List<@NonNull PackageDeclarationCS> selectedPackageDecls = new ArrayList<>();
			for (@NonNull PackageDeclarationCS csPackage : ownedPackages) {
				org.eclipse.ocl.pivot.Package asPackage = csPackage.getReferredPackage();
				if (modelPackage == asPackage) {
					selectedPackageDecls.add(csPackage);
				}
			}
			List<@NonNull ContextDeclCS> selectedContexts = new ArrayList<>();
			for (@NonNull ContextDeclCS csContext : ownedContexts) {
				org.eclipse.ocl.pivot.Package asPackage = getReferredPackage(csContext);
				if (modelPackage == asPackage) {
					selectedContexts.add(csContext);
				}
			}
			org.eclipse.ocl.pivot.Package contextPackage = contextPackage(modelPackage, selectedPackageDecls, selectedContexts);
			org.eclipse.ocl.pivot.Package oldPackage = modelPackage2contextPackage.put(modelPackage, contextPackage);
			assert oldPackage == null;
		}
		//
		//	Identify the context package ancestry corresponding to the model package ancestry.
		//	(Use null as the root Package).
		//
		Map<org.eclipse.ocl.pivot.@Nullable Package, @NonNull List<org.eclipse.ocl.pivot.@NonNull Package>> contextPackage2childContextPackages = new HashMap<>();
		for (org.eclipse.ocl.pivot.@NonNull Package modelPackage : modelPackages) {
			contextPackageParent(modelPackage2contextPackage, modelPackage, contextPackage2childContextPackages);
		}
		//
		//	Refresh the context package ancestry.
		//
		Model contextRoot = refreshRoot(Model.class, PivotPackage.Literals.MODEL, csElement);
		for (org.eclipse.ocl.pivot.@Nullable Package contextPackage : contextPackage2childContextPackages.keySet()) {
			List<org.eclipse.ocl.pivot.@NonNull Package> childContextPackages = contextPackage2childContextPackages.get(contextPackage);
			assert childContextPackages != null;
			Collections.sort(childContextPackages, NameUtil.NAMEABLE_COMPARATOR);
			if (contextPackage != null) {
				helper.refreshList(contextPackage.getOwnedPackages(), childContextPackages);
			}
			else {
				helper.refreshList(contextRoot.getOwnedPackages(), childContextPackages);
			}
		}
		context.refreshPivotList(Import.class, contextRoot.getOwnedImports(), csElement.getOwnedImports());
		return null;
	}

	@Override
	public Continuation<?> visitDefOperationCS(@NonNull DefOperationCS csElement) {
		@NonNull Operation contextOperation = refreshNamedElement(Operation.class, PivotPackage.Literals.OPERATION, csElement);
		context.refreshPivotList(Parameter.class, contextOperation.getOwnedParameters(), csElement.getOwnedParameters());
		ExpressionInOCL pivotSpecification = PivotUtil.getPivot(ExpressionInOCL.class, csElement.getOwnedSpecification());
		contextOperation.setBodyExpression(pivotSpecification);
		return null;
	}

	@Override
	public Continuation<?> visitDefPropertyCS(@NonNull DefPropertyCS csElement) {
		@NonNull Property contextProperty = refreshNamedElement(Property.class, PivotPackage.Literals.PROPERTY, csElement);
		contextProperty.setIsDerived(true);
		contextProperty.setIsReadOnly(true);
		contextProperty.setIsTransient(true);
		contextProperty.setIsVolatile(true);
		contextProperty.setIsResolveProxies(false);
		ExpressionInOCL pivotSpecification = PivotUtil.getPivot(ExpressionInOCL.class, csElement.getOwnedSpecification());
		contextProperty.setOwnedExpression(pivotSpecification);
		return null;
	}

	@Override
	public Continuation<?> visitOperationContextDeclCS(@NonNull OperationContextDeclCS csElement) {
		PathNameCS pathName = csElement.getOwnedPathName();
		assert pathName != null;
		CS2AS.setElementType(pathName, PivotPackage.Literals.OPERATION, csElement, new OperationDeclScopeFilter(csElement));
		return null;
	}

	@Override
	public Continuation<?> visitPackageDeclarationCS(@NonNull PackageDeclarationCS csElement) {
		return null;
	}

	@Override
	public Continuation<?> visitPropertyContextDeclCS(@NonNull PropertyContextDeclCS csElement) {
		PathNameCS pathName = csElement.getOwnedPathName();
		assert pathName != null;
		CS2AS.setElementType(pathName, PivotPackage.Literals.PROPERTY, csElement, null);
		return null;
	}
}