/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License 2.0        
 * which accompanies this distribution, and is available at                  
 * https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 * SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 * 
 * 
 *  This copyright notice shows up in the generated Java code
 * 
 */

package org.eclipse.osbp.xtext.cubedsl.scoping

import java.util.ArrayList
import org.eclipse.emf.ecore.EObject
import org.eclipse.emf.ecore.EReference
import org.eclipse.emf.ecore.InternalEObject
import org.eclipse.osbp.dsl.semantic.common.types.LDataType
import org.eclipse.osbp.dsl.semantic.entity.LEntity
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute
import org.eclipse.osbp.dsl.semantic.entity.LEntityFeature
import org.eclipse.osbp.dsl.semantic.entity.LEntityReference
import org.eclipse.osbp.xtext.cubedsl.CubeAggregatorEnum
import org.eclipse.osbp.xtext.cubedsl.CubeDSLPackage
import org.eclipse.osbp.xtext.cubedsl.CubeDimension
import org.eclipse.osbp.xtext.cubedsl.CubeDimensionEntity
import org.eclipse.osbp.xtext.cubedsl.CubeDimensionEntityEntity
import org.eclipse.osbp.xtext.cubedsl.CubeDimensionUsage
import org.eclipse.osbp.xtext.cubedsl.CubeEntity
import org.eclipse.osbp.xtext.cubedsl.CubeHierarchy
import org.eclipse.osbp.xtext.cubedsl.CubeMeasure
import org.eclipse.osbp.xtext.cubedsl.CubePackage
import org.eclipse.osbp.xtext.cubedsl.CubeTypeEntity
import org.eclipse.xtext.common.types.impl.JvmParameterizedTypeReferenceImpl
import org.eclipse.xtext.scoping.IScope
import org.eclipse.xtext.scoping.Scopes
import javax.inject.Inject
import org.eclipse.osbp.dsl.common.xtext.extensions.ModelExtensions

/**
 * This class contains custom scoping description.
 * 
 * see : http://www.eclipse.org/Xtext/documentation.html#scoping
 * on how and when to use it 
 * 
 */
//class CubeDSLScopeProvider extends AbstractDeclarativeScopeProvider {
class CubeDSLScopeProvider extends AbstractCubeDSLScopeProvider /*XbaseWithAnnotationsScopeProvider*/ {
	@Inject extension ModelExtensions
	
	@Override
	override IScope getScope(EObject context, EReference reference) {
		if (reference == CubeDSLPackage.Literals.CUBE_DIMENSION_ENTITY_ENTITY__OVER_VALUE) {
			return getScope_CubeDimensionEntityEntityOverValue(context as CubeDimensionEntityEntity)
		} else if (reference == CubeDSLPackage.Literals.CUBE_DIMENSION_USAGE__OVER_VALUE) {
			return getScope_CubeDimensionUsage_OverValue(context as CubeDimensionUsage)
		} else if (reference == CubeDSLPackage.Literals.CUBE_MEASURE__MEASURE_COL) {
			return getScope_CubeMeasureCol(context as CubeMeasure)
		} else if ((reference == CubeDSLPackage.Literals.CUBE_LEVEL__LEVEL_COL_VALUE) ||
			(reference == CubeDSLPackage.Literals.CUBE_LEVEL__LEVEL_NAME_COL_VALUE) ||
			(reference == CubeDSLPackage.Literals.CUBE_LEVEL__LEVEL_CAPTION_COL_VALUE) ||
			(reference == CubeDSLPackage.Literals.CUBE_LEVEL__LEVEL_ORDINAL_COL_VALUE) ||
			(reference == CubeDSLPackage.Literals.CUBE_LEVEL_PROP__LEVEL_PROP_COL_VALUE)) {
			return getScope_CubeEntityColRef(context as EObject)
		} else if (reference == CubeDSLPackage.Literals.CUBE_ENTITY__KEY_VALUE) {
			return getScope_CubeEntity_KeyValue(context as CubeEntity)
		} else if (reference == CubeDSLPackage.Literals.CUBE_DIMENSION_USAGE__SOURCE_VALUE) {
			return getScope_CubeDimensionUsage_SourceValue(context as CubeDimensionUsage)
		} else {
			return super.getScope(context, reference)
		}

	}

	def IScope getScope_CubeDimensionUsage_SourceValue(CubeDimensionUsage cubeDimUsage) {
		var result = <EObject>newArrayList
		var eObj = cubeDimUsage.eContainer
		while (!(eObj instanceof CubePackage)) {
			eObj = eObj.eContainer
		}
		var cubePackage = (eObj as CubePackage)
		if (cubePackage !== null) {
			for (CubeDimension cubeDim : cubePackage.dimensions) {
				if (cubeDim.name !== null) {
					result.add(cubeDim)
				}
			}
		}
		return Scopes.scopeFor(result)
	}

	def getScope_CubeDimensionUsage_OverValue(CubeDimensionUsage cubeDimUsage) {
		var result = <EObject>newArrayList
		var dimEntities = <String>newArrayList
		var dimUsageSource = cubeDimUsage.getSourceValue
		var LEntity cubeEnt = cubeDimUsage.getCubeEntity
		if (dimUsageSource !== null) {
			for (CubeHierarchy cubeHierarchy : dimUsageSource.hierarchies) {
				dimEntities.add(cubeHierarchy.dimEntityName)
			}
			if (dimUsageSource.typeTime) {
				for (LEntityAttribute entityAttr : cubeEnt.allAttributes) {
					if (entityAttr.date) {
						result.add(entityAttr)
					}
				}
			}
		}
		if (cubeEnt !== null) {
			// If the cube entity is as the used entity for the dimension
			// only its attributes are used as foreign key 
			if (dimEntities.contains(cubeEnt.name)) {
				for (LEntityAttribute entityAttr : cubeEnt.allAttributes) {
					result.add(entityAttr)
				}
			} else {
				for (LEntityReference entityRef : cubeEnt.allReferences) {
					if (dimEntities.contains(entityRef.getTypeName)) {
						result.add(entityRef)
					}
				}
			}
		}
		return Scopes.scopeFor(result)
	}

	def ArrayList<EObject> getRefResultList(LEntity cubeEnt, ArrayList<EObject> result) {
		for (LEntityReference entityRef : cubeEnt.allReferences) {
			if (entityRef.name !== null) {
				result.add(entityRef)
			}
		}
		return result
	}

	def getCubeEntity(EObject childEObj) {
		var LEntity cubeEnt = null;
		var eObj = childEObj.eContainer
		while (!(eObj instanceof CubeTypeEntity)) {
			if (eObj !== null) {
				eObj = eObj.eContainer
			}
		}
		if (eObj !== null) {
			cubeEnt = (eObj as CubeTypeEntity).entityRef.entityValue
		}
		return cubeEnt
	}

	def getScope_CubeMeasureCol(CubeMeasure cubeMeasure) {
		var result = <EObject>newArrayList
		var LEntity cubeEnt = cubeMeasure.getCubeEntity
		if (cubeEnt !== null) {
			// if measure uses count aggregator only numeric entity attributes are provided
			if (cubeMeasure.aggregator !== null && (cubeMeasure.aggregator.equals(CubeAggregatorEnum.COUNT) ||
				cubeMeasure.aggregator.equals(CubeAggregatorEnum.DSC))) {
				result = cubeEnt.getRefResultList(result)
			} else {
				for (LEntityAttribute entityAttr : cubeEnt.allAttributes) {
					if (entityAttr.type !== null && entityAttr.entity.isNormalAttribute(entityAttr) &&
						entityAttr.type instanceof LDataType && isNumericOrWrapperType(entityAttr.type as LDataType)) {
						result.add(entityAttr)
					}
				}
			}
		}
		return Scopes.scopeFor(result)
	}

	def IScope getScope_CubeEntityColRef(EObject context) {
		var result = <EObject>newArrayList
		var eObj = context
		while (!((eObj instanceof CubeDimensionEntity) || (eObj instanceof CubeDimensionEntityEntity) ||
			(eObj instanceof CubeTypeEntity))) {
			if (eObj !== null) {
				eObj = eObj.eContainer
			}
		}
		if (eObj !== null) {
			var LEntity cubeEnt = null;
			if (eObj instanceof CubeDimensionEntityEntity) {
				cubeEnt = (eObj as CubeDimensionEntityEntity).entityRef.entityValue
			} else if (eObj instanceof CubeDimensionEntity) {
				cubeEnt = (eObj as CubeDimensionEntity).entityRef.entityValue
			} else if (eObj instanceof CubeTypeEntity) {
				cubeEnt = (eObj as CubeTypeEntity).entityRef.entityValue
			}
			result = cubeEnt.getAttrResultList(result)
		}
		return Scopes.scopeFor(result)
	}

	def IScope getScope_CubeDimensionEntityEntityOverValue(CubeDimensionEntityEntity cubeDimEntityEntity) {
		var result = <EObject>newArrayList
		var eObj = cubeDimEntityEntity.eContainer
		while (!(eObj instanceof CubeDimensionEntity)) {
			if (eObj !== null) {
				eObj = eObj.eContainer
			}
		}
		if (eObj !== null) {
			if (eObj instanceof CubeDimensionEntity) {
				result = cubeDimEntityEntity.getJoinableRefsResultList((eObj as CubeDimensionEntity), result)
			}
		}
		return Scopes.scopeFor(result)
	}

	def IScope getScope_CubeEntity_KeyValue(CubeEntity entity) {
		var result = <EObject>newArrayList
		if (entity !== null) {
			result = entity.entityValue.getAttrResultList(result)
		}
		return Scopes.scopeFor(result)
	}

	def getJoinableRefsResultList(CubeDimensionEntityEntity cubeDimEntityEntity, CubeDimensionEntity entity,
		ArrayList<EObject> result) {
		if (entity !== null && entity.entityRef !== null && entity.entityRef.entityValue !== null &&
			entity.entityRef.entityValue.name !== null) {
			var LEntity cubeEnt = entity.entityRef.entityValue
			for (LEntityReference lEntRef : cubeEnt.allReferences) {
				if (cubeDimEntityEntity.entityRef !== null && cubeDimEntityEntity.entityRef.entityValue !== null &&
					cubeDimEntityEntity.entityRef.entityValue.name !== null &&
					cubeDimEntityEntity.entityRef.entityValue.name.equals(lEntRef.type.name)) {
					result.add(lEntRef)
				}
			}
		}
		return result;
	}

	def getAttrResultList(LEntity cubeEnt, ArrayList<EObject> result) {
		if (cubeEnt !== null) {
			for (LEntityAttribute entityAttr : cubeEnt.allAttributes) {
				if (entityAttr.name !== null) {
					result.add(entityAttr)
				}
			}
		}
		return result;
	}

	def getAllFeaturesResultList(LEntity cubeEnt, ArrayList<EObject> result) {
		if (cubeEnt !== null) {
			for (LEntityFeature entityFeature : cubeEnt.allFeatures) {
				if (entityFeature.name !== null) {
					result.add(entityFeature)
				}
			}
		}
		return result;
	}

	def getDimEntityName(CubeHierarchy cubeHierarchy) {
		if (cubeHierarchy !== null && cubeHierarchy.cubeDimEntity !== null &&
			cubeHierarchy.cubeDimEntity.entityRef !== null &&
			cubeHierarchy.cubeDimEntity.entityRef.entityValue !== null) {
				return cubeHierarchy.cubeDimEntity.entityRef.entityValue.name
			}
		}

		def getTypeName(LEntityReference entityRef) {
			if (entityRef.type.name !== null && entityRef.type.name !== null) {
				return entityRef.type.name
			}
		}

		def isDate(LEntityAttribute entityAttr) {
			return (entityAttr.type instanceof LDataType && (entityAttr.type as LDataType).date)
		}
	}