/**
 * 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 v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * 
 *  This copyright notice shows up in the generated Java code
 */
package org.eclipse.osbp.xtext.entitymock.scoping;

import com.google.common.base.Objects;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.osbp.dsl.semantic.common.types.LEnum;
import org.eclipse.osbp.dsl.semantic.common.types.LEnumLiteral;
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.entitymock.EntityMockAttributeByObject;
import org.eclipse.osbp.xtext.entitymock.EntityMockAttributeByReference;
import org.eclipse.osbp.xtext.entitymock.EntityMockAttributeFiller;
import org.eclipse.osbp.xtext.entitymock.EntityMockDSLPackage;
import org.eclipse.osbp.xtext.entitymock.EntityMockEntities;
import org.eclipse.osbp.xtext.entitymock.EntityMockEntity;
import org.eclipse.osbp.xtext.entitymock.EntityMockEntityNestedAttribute;
import org.eclipse.osbp.xtext.entitymock.EntityMockObject;
import org.eclipse.osbp.xtext.entitymock.EntityMockObjectArrayValue;
import org.eclipse.osbp.xtext.entitymock.EntityMockObjectEmbed;
import org.eclipse.osbp.xtext.entitymock.EntityMockObjectEnum;
import org.eclipse.osbp.xtext.entitymock.EntityMockObjectFunction;
import org.eclipse.osbp.xtext.entitymock.EntityMockObjectResourceValue;
import org.eclipse.osbp.xtext.entitymock.EntityMockReferencedObjectAttribute;
import org.eclipse.osbp.xtext.entitymock.EntityMockResource;
import org.eclipse.osbp.xtext.entitymock.EntityMockResourceAttribute;
import org.eclipse.osbp.xtext.entitymock.EntityMockResourceDataRow;
import org.eclipse.osbp.xtext.entitymock.IEntityMockObjectAttribute;
import org.eclipse.osbp.xtext.entitymock.scoping.AbstractEntityMockDSLScopeProvider;
import org.eclipse.xtext.resource.EObjectDescription;
import org.eclipse.xtext.resource.IEObjectDescription;
import org.eclipse.xtext.scoping.IScope;
import org.eclipse.xtext.scoping.impl.MapBasedScope;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.IterableExtensions;

/**
 * This class contains custom scoping description.
 * 
 * see : http://www.eclipse.org/Xtext/documentation.html#scoping
 * on how and when to use it
 */
@SuppressWarnings("all")
public class EntityMockDSLScopeProvider extends AbstractEntityMockDSLScopeProvider {
  @Override
  public IScope getScope(final EObject context, final EReference reference) {
    IScope _xblockexpression = null;
    {
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_OBJECT_ARRAY_VALUE__ENUMERATION)) {
        return this.getScope_MockObjectEnum(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_OBJECT_ITEM_VALUE__DATAROW)) {
        return this.getScope_MockObjectEnumValue(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_REFERENCED_OBJECT_ATTRIBUTE__EMBEDDED)) {
        return this.getScope_MockObjectEmbed(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_REFERENCED_OBJECT_ATTRIBUTE__ATTRIBUTE)) {
        return this.getScope_MockObjectAttribute(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_BY_OBJECT__ATTRIBUTE_REF)) {
        return this.getEntityAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY__ITERATOR)) {
        return this.getEntityAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_FILLER__ATTRIBUTE_REF)) {
        return this.getEntityAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY_FUNCTION__ATTRIBUTE_REF)) {
        return this.getEntityAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY_FUNCTION_PARAMETER__ATTRIBUTE_REF)) {
        return this.getNestedAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY_FUNCTION_PARAMETER__NESTED_ATTRIBUTE)) {
        return this.getNestedAttributes(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY_NESTED_ATTRIBUTE__ATTRIBUTE)) {
        return this.getNestedAttributesAttribute(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ENTITY_NESTED_ATTRIBUTE__REFERENCE)) {
        return this.getEntityReferences(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_BY_REFERENCE__ATTRIBUTE_REF)) {
        return this.getEntityReferences(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_BY_OBJECT__ATTRIBUTE_REF)) {
        boolean _matched = false;
        if (context instanceof EntityMockAttributeByObject) {
          _matched=true;
          EObject _eContainer = ((EntityMockAttributeByObject)context).eContainer();
          return MapBasedScope.createScope(IScope.NULLSCOPE, 
            this.getEntityAttributes(((EntityMockEntity) _eContainer), null));
        }
        if (!_matched) {
          if (context instanceof EntityMockEntity) {
            _matched=true;
            return MapBasedScope.createScope(IScope.NULLSCOPE, 
              this.getEntityAttributes(((EntityMockEntity) context), null));
          }
        }
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_FILLER__ATTRIBUTE_REF)) {
        boolean _matched_1 = false;
        if (context instanceof EntityMockAttributeFiller) {
          _matched_1=true;
          EObject _eContainer = ((EntityMockAttributeFiller)context).eContainer();
          return MapBasedScope.createScope(IScope.NULLSCOPE, 
            this.getEntityAttributes(((EntityMockEntity) _eContainer), null));
        }
        if (!_matched_1) {
          if (context instanceof EntityMockEntities) {
            _matched_1=true;
            return MapBasedScope.createScope(IScope.NULLSCOPE, 
              this.getEntityAttributes(((EntityMockEntities) context), null));
          }
        }
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_BY_REFERENCE__ATTRIBUTE_REF)) {
        boolean _matched_2 = false;
        if (context instanceof EntityMockAttributeByReference) {
          _matched_2=true;
          EObject _eContainer = ((EntityMockAttributeByReference)context).eContainer();
          return MapBasedScope.createScope(IScope.NULLSCOPE, 
            this.getEntityAttributes(((EntityMockEntity) _eContainer), null));
        }
        if (!_matched_2) {
          if (context instanceof EntityMockEntities) {
            _matched_2=true;
            return MapBasedScope.createScope(IScope.NULLSCOPE, 
              this.getEntityAttributes(((EntityMockEntities) context), null));
          }
        }
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_ATTRIBUTE_BY_REFERENCE__MOCKED_ENTITY)) {
        return this.getScope_MockAttributeReferencedMockedEntity(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_OBJECT_RESOURCE_VALUE__RESOURCE_ATTRIBUTE)) {
        return this.getScope_MockAttributeResourceAttribute(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_BY_RESOURCE_ATTRIBUTE__RESOURCE_ATTRIBUTE)) {
        return this.getScope_MockEntityResourceAttribute(context);
      }
      if ((reference == EntityMockDSLPackage.Literals.ENTITY_MOCK_BY_RESOURCE_ATTRIBUTE__ATTRIBUTE_REF)) {
        return this.getEntityAttributes(context);
      }
      _xblockexpression = super.getScope(context, reference);
    }
    return _xblockexpression;
  }
  
  public LEntity getEntityRef(final EObject context) {
    EObject eObj = context;
    while (((eObj != null) && (!(eObj instanceof EntityMockEntity)))) {
      eObj = eObj.eContainer();
    }
    if ((eObj != null)) {
      return ((EntityMockEntity) eObj).getEntityRef();
    } else {
      return null;
    }
  }
  
  public IScope getNestedAttributesAttribute(final EObject context) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    LEntityReference reference = ((EntityMockEntityNestedAttribute) context).getReference();
    if (((reference != null) && (!Objects.equal(reference.getType(), null)))) {
      List<LEntityAttribute> _allAttributes = reference.getType().getAllAttributes();
      for (final LEntityAttribute a : _allAttributes) {
        result.add(EObjectDescription.create(a.getName(), a));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  public IScope getNestedAttributes(final EObject context) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    LEntity entity = this.getEntityRef(context);
    if ((entity != null)) {
      List<LEntityFeature> _allFeatures = entity.getAllFeatures();
      for (final LEntityFeature f : _allFeatures) {
        boolean _matched = false;
        if (f instanceof LEntityAttribute) {
          _matched=true;
          result.add(EObjectDescription.create(((LEntityAttribute)f).getName(), f));
        }
        if (!_matched) {
          if (f instanceof LEntityReference) {
            _matched=true;
            result.add(EObjectDescription.create(((LEntityReference)f).getName(), f));
          }
        }
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  public IScope getEntityAttributes(final EObject context) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    LEntity entity = this.getEntityRef(context);
    if ((entity != null)) {
      List<LEntityAttribute> _allAttributes = entity.getAllAttributes();
      for (final LEntityAttribute attr : _allAttributes) {
        result.add(EObjectDescription.create(attr.getName(), attr));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  public IScope getEntityReferences(final EObject context) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    LEntity entity = this.getEntityRef(context);
    if ((entity != null)) {
      List<LEntityReference> _allReferences = entity.getAllReferences();
      for (final LEntityReference ref : _allReferences) {
        String _name = ref.getName();
        boolean _tripleNotEquals = (_name != null);
        if (_tripleNotEquals) {
          result.add(EObjectDescription.create(ref.getName(), ((LEntityReference) ref)));
        }
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available entity attributes contained in EntityMockEntities and add them to result
   */
  public ArrayList<IEObjectDescription> getEntityAttributes(final EntityMockEntities mockEntities, final ArrayList<IEObjectDescription> result) {
    ArrayList<IEObjectDescription> iresult = result;
    if ((iresult == null)) {
      iresult = CollectionLiterals.<IEObjectDescription>newArrayList();
    }
    if ((mockEntities != null)) {
      EList<EntityMockEntity> _entities = mockEntities.getEntities();
      for (final EntityMockEntity mockEntity : _entities) {
        iresult = this.getEntityAttributes(mockEntity, iresult);
      }
    }
    return iresult;
  }
  
  /**
   * get all available entity attributes contained in EntityMockEntity and add them to result
   */
  public ArrayList<IEObjectDescription> getEntityAttributes(final EntityMockEntity mockEntity, final ArrayList<IEObjectDescription> result) {
    ArrayList<IEObjectDescription> iresult = result;
    if ((iresult == null)) {
      iresult = CollectionLiterals.<IEObjectDescription>newArrayList();
    }
    if ((mockEntity != null)) {
      iresult = this.getEntityAttributes(mockEntity.getEntityRef(), iresult);
    }
    return iresult;
  }
  
  /**
   * get all available entity attributes contained in LEntity and add them to result
   */
  public ArrayList<IEObjectDescription> getEntityAttributes(final LEntity entity, final ArrayList<IEObjectDescription> result) {
    ArrayList<IEObjectDescription> iresult = result;
    if ((iresult == null)) {
      iresult = CollectionLiterals.<IEObjectDescription>newArrayList();
    }
    if ((entity != null)) {
      List<LEntityAttribute> _allAttributes = entity.getAllAttributes();
      for (final LEntityAttribute attribute : _allAttributes) {
        String _name = attribute.getName();
        boolean _tripleNotEquals = (_name != null);
        if (_tripleNotEquals) {
          iresult.add(EObjectDescription.create(attribute.getName(), attribute));
        }
      }
    }
    return iresult;
  }
  
  /**
   * get all available mock objects and add them as an IScope
   */
  public IScope getScope_MockObjectEmbed(final EObject object) {
    final ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EntityMockReferencedObjectAttribute emroa = ((EntityMockReferencedObjectAttribute) null);
    if ((object instanceof EntityMockReferencedObjectAttribute)) {
      emroa = ((EntityMockReferencedObjectAttribute)object);
    }
    if ((object instanceof EntityMockAttributeByObject)) {
      emroa = ((EntityMockAttributeByObject)object).getReference();
    }
    EntityMockObject mockObject = emroa.getTemplate().getObject();
    this.getScope_MockObjectRecursiveEmbed(result, mockObject);
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available mock objects recursively and add them to result
   */
  public void getScope_MockObjectRecursiveEmbed(final List<IEObjectDescription> result, final EntityMockObject mockObject) {
    if ((mockObject != null)) {
      EList<IEntityMockObjectAttribute> _attributes = mockObject.getAttributes();
      for (final IEntityMockObjectAttribute attribute : _attributes) {
        if ((attribute instanceof EntityMockObjectEmbed)) {
          result.add(EObjectDescription.create(((EntityMockObjectEmbed)attribute).getName(), attribute));
          this.getScope_MockObjectRecursiveEmbed(result, ((EntityMockObjectEmbed)attribute).getObject());
        }
      }
    }
  }
  
  /**
   * get all available enumerations and attributes of a mock object recursively and add them as an IScope
   */
  public IScope getScope_MockObjectAttribute(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EntityMockReferencedObjectAttribute emroa = ((EntityMockReferencedObjectAttribute) null);
    if ((object instanceof EntityMockReferencedObjectAttribute)) {
      emroa = ((EntityMockReferencedObjectAttribute)object);
    }
    if ((object instanceof EntityMockAttributeByObject)) {
      emroa = ((EntityMockAttributeByObject)object).getReference();
    }
    EntityMockObject mockObject = emroa.getTemplate().getObject();
    boolean _isEmpty = emroa.getEmbedded().isEmpty();
    boolean _not = (!_isEmpty);
    if (_not) {
      mockObject = IterableExtensions.<EntityMockObjectEmbed>last(emroa.getEmbedded()).getObject();
    }
    if ((mockObject != null)) {
      EList<EntityMockObjectEnum> _enumerations = mockObject.getEnumerations();
      for (final EntityMockObjectEnum enumeration : _enumerations) {
        result.add(
          EObjectDescription.create(((EntityMockObjectEnum) enumeration).getName(), ((EntityMockObjectEnum) enumeration)));
      }
      EList<IEntityMockObjectAttribute> _attributes = mockObject.getAttributes();
      for (final IEntityMockObjectAttribute attribute : _attributes) {
        if ((attribute instanceof EntityMockObjectEmbed)) {
        } else {
          result.add(
            EObjectDescription.create(((IEntityMockObjectAttribute) attribute).getName(), ((IEntityMockObjectAttribute) attribute)));
        }
      }
      EList<EntityMockObjectFunction> _calculations = mockObject.getCalculations();
      for (final EntityMockObjectFunction calculation : _calculations) {
        result.add(
          EObjectDescription.create(((EntityMockObjectFunction) calculation).getName(), ((EntityMockObjectFunction) calculation)));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available enumerations of a mock object and add them as an IScope
   */
  public IScope getScope_MockObjectEnum(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EObject mockObject = object.eContainer();
    if ((mockObject instanceof EntityMockObject)) {
      EList<EntityMockObjectEnum> _enumerations = ((EntityMockObject)mockObject).getEnumerations();
      for (final EntityMockObjectEnum objectEnum : _enumerations) {
        result.add(
          EObjectDescription.create(((EntityMockObjectEnum) objectEnum).getName(), ((EntityMockObjectEnum) objectEnum)));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available enumeration values of a mock object enumeration and add them as an IScope
   */
  public IScope getScope_MockObjectEnumValue(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EObject mockValueItem = object;
    while (((!(mockValueItem instanceof EntityMockObjectArrayValue)) && (mockValueItem != null))) {
      mockValueItem = mockValueItem.eContainer();
    }
    if ((mockValueItem instanceof EntityMockObjectArrayValue)) {
      LEnum _usingResource = ((EntityMockObjectArrayValue)mockValueItem).getEnumeration().getUsingResource();
      if ((_usingResource instanceof EntityMockResource)) {
        LEnum _usingResource_1 = ((EntityMockObjectArrayValue)mockValueItem).getEnumeration().getUsingResource();
        final EntityMockResource resource = ((EntityMockResource) _usingResource_1);
        EList<EntityMockResourceDataRow> _datarows = resource.getDatarows();
        for (final EntityMockResourceDataRow datarow : _datarows) {
          result.add(
            EObjectDescription.create(((EntityMockResourceDataRow) datarow).getName(), ((EntityMockResourceDataRow) datarow)));
        }
      } else {
        final LEnum lenum = ((EntityMockObjectArrayValue)mockValueItem).getEnumeration().getUsingResource();
        EList<LEnumLiteral> _literals = lenum.getLiterals();
        for (final LEnumLiteral datarow_1 : _literals) {
          result.add(EObjectDescription.create(datarow_1.getName(), datarow_1));
        }
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available mocked entities fitting the referencing entity attribute and add them as an IScope
   */
  public IScope getScope_MockAttributeReferencedMockedEntity(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EntityMockAttributeByReference attributeByReference = ((EntityMockAttributeByReference) null);
    if ((object instanceof EntityMockAttributeByReference)) {
      attributeByReference = ((EntityMockAttributeByReference)object);
    }
    if ((attributeByReference != null)) {
      LEntity requested_entityRef = attributeByReference.getAttributeRef().getType();
      if ((requested_entityRef != null)) {
        EObject mockEntities = object.eContainer();
        while (((!(mockEntities instanceof EntityMockEntities)) && (!Objects.equal(mockEntities, null)))) {
          mockEntities = mockEntities.eContainer();
        }
        if ((mockEntities instanceof EntityMockEntities)) {
          EList<EntityMockEntity> _entities = ((EntityMockEntities)mockEntities).getEntities();
          for (final EntityMockEntity mockEntity : _entities) {
            boolean _equals = requested_entityRef.equals(mockEntity.getEntityRef());
            if (_equals) {
              result.add(
                EObjectDescription.create(((EntityMockEntity) mockEntity).getName(), ((EntityMockEntity) mockEntity)));
            }
          }
        }
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available enumeration values of a mock object enumeration and add them as an IScope
   */
  public IScope getScope_MockAttributeResourceAttribute(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EObject objectResourceValue = object;
    while (((!(objectResourceValue instanceof EntityMockObjectResourceValue)) && (objectResourceValue != null))) {
      objectResourceValue = objectResourceValue.eContainer();
    }
    if ((objectResourceValue instanceof EntityMockObjectResourceValue)) {
      LEnum _usingResource = ((EntityMockObjectResourceValue)objectResourceValue).getResourceEnum().getUsingResource();
      if ((_usingResource instanceof EntityMockResource)) {
        LEnum _usingResource_1 = ((EntityMockObjectResourceValue)objectResourceValue).getResourceEnum().getUsingResource();
        final EntityMockResource resource = ((EntityMockResource) _usingResource_1);
        EList<EntityMockResourceAttribute> _attributes = resource.getAttributes();
        for (final EntityMockResourceAttribute attribute : _attributes) {
          result.add(
            EObjectDescription.create(((EntityMockResourceAttribute) attribute).getName(), ((EntityMockResourceAttribute) attribute)));
        }
      } else {
        final LEnum lenum = ((EntityMockObjectResourceValue)objectResourceValue).getResourceEnum().getUsingResource();
        result.add(EObjectDescription.create("name", lenum));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
  
  /**
   * get all available enumeration values of a mock object enumeration and add them as an IScope
   */
  public IScope getScope_MockEntityResourceAttribute(final EObject object) {
    ArrayList<IEObjectDescription> result = CollectionLiterals.<IEObjectDescription>newArrayList();
    EObject mockEntity = object;
    while (((!(mockEntity instanceof EntityMockEntity)) && (mockEntity != null))) {
      mockEntity = mockEntity.eContainer();
    }
    if ((mockEntity instanceof EntityMockEntity)) {
      EList<EntityMockResourceAttribute> _attributes = ((EntityMockEntity)mockEntity).getByResource().getAttributes();
      for (final EntityMockResourceAttribute attribute : _attributes) {
        result.add(
          EObjectDescription.create(((EntityMockResourceAttribute) attribute).getName(), ((EntityMockResourceAttribute) attribute)));
      }
    }
    return MapBasedScope.createScope(IScope.NULLSCOPE, result);
  }
}