/**
 * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), 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:
 *         Florian Pirchner - Initial implementation
 */
package org.eclipse.osbp.dsl.dto.xtext.jvmmodel;

import com.google.common.base.Objects;
import com.google.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import org.eclipse.emf.common.util.EList;
import org.eclipse.osbp.dsl.dto.xtext.extensions.AnnotationExtension;
import org.eclipse.osbp.dsl.dto.xtext.extensions.DtoModelExtensions;
import org.eclipse.osbp.dsl.dto.xtext.jvmmodel.TypeHelper;
import org.eclipse.osbp.dsl.semantic.common.types.LAnnotationDef;
import org.eclipse.osbp.dsl.semantic.common.types.LAnnotationTarget;
import org.eclipse.osbp.dsl.semantic.common.types.LAttribute;
import org.eclipse.osbp.dsl.semantic.common.types.LAttributeMatchingConstraint;
import org.eclipse.osbp.dsl.semantic.common.types.LDataType;
import org.eclipse.osbp.dsl.semantic.common.types.LDatatypeConstraint;
import org.eclipse.osbp.dsl.semantic.common.types.LFeature;
import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue;
import org.eclipse.osbp.dsl.semantic.common.types.LOperation;
import org.eclipse.osbp.dsl.semantic.common.types.LReference;
import org.eclipse.osbp.dsl.semantic.common.types.LResultFilter;
import org.eclipse.osbp.dsl.semantic.common.types.LResultFilters;
import org.eclipse.osbp.dsl.semantic.common.types.LScalarType;
import org.eclipse.osbp.dsl.semantic.common.types.LType;
import org.eclipse.osbp.dsl.semantic.dto.LDto;
import org.eclipse.osbp.dsl.semantic.dto.LDtoAbstractAttribute;
import org.eclipse.osbp.dsl.semantic.dto.LDtoAttribute;
import org.eclipse.osbp.dsl.semantic.dto.LDtoInheritedAttribute;
import org.eclipse.osbp.dsl.semantic.dto.LDtoInheritedReference;
import org.eclipse.osbp.dsl.semantic.dto.LDtoReference;
import org.eclipse.osbp.dsl.semantic.entity.LBean;
import org.eclipse.osbp.dsl.semantic.entity.LBeanAttribute;
import org.eclipse.osbp.dsl.semantic.entity.LBeanReference;
import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute;
import org.eclipse.osbp.dsl.semantic.entity.LEntityReference;
import org.eclipse.osbp.runtime.common.annotations.AsGrid;
import org.eclipse.osbp.runtime.common.annotations.AsKanbanOrdering;
import org.eclipse.osbp.runtime.common.annotations.AsKanbanState;
import org.eclipse.osbp.runtime.common.annotations.AsTable;
import org.eclipse.osbp.runtime.common.annotations.CreateAt;
import org.eclipse.osbp.runtime.common.annotations.CreateBy;
import org.eclipse.osbp.runtime.common.annotations.Dirty;
import org.eclipse.osbp.runtime.common.annotations.Dispose;
import org.eclipse.osbp.runtime.common.annotations.DomainDescription;
import org.eclipse.osbp.runtime.common.annotations.DomainKey;
import org.eclipse.osbp.runtime.common.annotations.DomainReference;
import org.eclipse.osbp.runtime.common.annotations.ExtraStyle;
import org.eclipse.osbp.runtime.common.annotations.Filter;
import org.eclipse.osbp.runtime.common.annotations.FilterDepth;
import org.eclipse.osbp.runtime.common.annotations.Hidden;
import org.eclipse.osbp.runtime.common.annotations.HistIsCurrent;
import org.eclipse.osbp.runtime.common.annotations.HistIsCustomVersion;
import org.eclipse.osbp.runtime.common.annotations.HistValidUntil;
import org.eclipse.osbp.runtime.common.annotations.HistorizedObject;
import org.eclipse.osbp.runtime.common.annotations.Id;
import org.eclipse.osbp.runtime.common.annotations.OnKanbanCard;
import org.eclipse.osbp.runtime.common.annotations.Range;
import org.eclipse.osbp.runtime.common.annotations.ReadOnly;
import org.eclipse.osbp.runtime.common.annotations.SideKick;
import org.eclipse.osbp.runtime.common.annotations.TargetEnumConstraint;
import org.eclipse.osbp.runtime.common.annotations.TargetEnumConstraints;
import org.eclipse.osbp.runtime.common.annotations.TimedependentObject;
import org.eclipse.osbp.runtime.common.annotations.UIGroup;
import org.eclipse.osbp.runtime.common.annotations.UniqueEntry;
import org.eclipse.osbp.runtime.common.annotations.UpdateAt;
import org.eclipse.osbp.runtime.common.annotations.UpdateBy;
import org.eclipse.osbp.runtime.common.annotations.Version;
import org.eclipse.xtext.common.types.JvmAnnotationReference;
import org.eclipse.xtext.common.types.JvmFeature;
import org.eclipse.xtext.common.types.JvmField;
import org.eclipse.xtext.common.types.JvmGenericType;
import org.eclipse.xtext.common.types.JvmMember;
import org.eclipse.xtext.common.types.JvmOperation;
import org.eclipse.xtext.common.types.JvmType;
import org.eclipse.xtext.common.types.JvmTypeReference;
import org.eclipse.xtext.common.types.util.TypeReferences;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;

/**
 * This class is responsible to generate the Annotations defined in the entity model
 */
@SuppressWarnings("all")
public class AnnotationCompiler extends org.eclipse.osbp.dsl.common.xtext.jvmmodel.AnnotationCompiler {
  @Inject
  @Extension
  private JvmTypesBuilder _jvmTypesBuilder;
  
  @Inject
  @Extension
  private TypeHelper _typeHelper;
  
  @Inject
  @Extension
  private DtoModelExtensions _dtoModelExtensions;
  
  @Inject
  @Extension
  private AnnotationExtension _annotationExtension;
  
  @Inject
  private TypeReferences references;
  
  protected void _internalProcessAnnotation(final LDto dto, final JvmGenericType jvmType) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(dto.getResolvedAnnotations(), _function), _function_1), jvmType);
    boolean _isHistorized = dto.isHistorized();
    if (_isHistorized) {
      this._annotationExtension.addAnno(dto, jvmType, this._jvmTypesBuilder.toAnnotation(dto, HistorizedObject.class));
    } else {
      boolean _isTimedependent = dto.isTimedependent();
      if (_isTimedependent) {
        this._annotationExtension.addAnno(dto, jvmType, this._jvmTypesBuilder.toAnnotation(dto, TimedependentObject.class));
      }
    }
  }
  
  protected void _internalProcessAnnotation(final LDtoReference prop, final JvmGenericType jvmType) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(prop.getResolvedAnnotations(), _function), _function_1), jvmType);
  }
  
  protected void _internalProcessAnnotation(final LDtoReference prop, final JvmField field) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(prop.getResolvedAnnotations(), _function), _function_1), field);
    EList<JvmAnnotationReference> _annotations = field.getAnnotations();
    JvmAnnotationReference _annotation = this._jvmTypesBuilder.toAnnotation(prop, DomainReference.class);
    this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotation);
    boolean _isCascading = prop.isCascading();
    if (_isCascading) {
      this.toValidAnnotation(prop, field);
    }
    this.toPropertiesAnnotation(prop, this.mergeKeyAndValues(prop), field);
  }
  
  protected List<LKeyAndValue> mergeKeyAndValues(final LDtoInheritedAttribute att) {
    final ArrayList<LKeyAndValue> keyAndValues = CollectionLiterals.<LKeyAndValue>newArrayList();
    this.addDatatypeKeyAndValues(att.getInheritedFeature(), keyAndValues);
    keyAndValues.addAll(att.getInheritedFeature().getProperties());
    keyAndValues.addAll(att.getProperties());
    this.removeDuplicateKeys(keyAndValues);
    return keyAndValues;
  }
  
  protected List<LKeyAndValue> mergeKeyAndValues(final LDtoInheritedReference ref) {
    final ArrayList<LKeyAndValue> keyAndValues = CollectionLiterals.<LKeyAndValue>newArrayList();
    keyAndValues.addAll(ref.getInheritedFeature().getProperties());
    keyAndValues.addAll(ref.getProperties());
    this.removeDuplicateKeys(keyAndValues);
    return keyAndValues;
  }
  
  protected void _internalProcessAnnotation(final LDtoAttribute prop, final JvmField field) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(prop.getResolvedAnnotations(), _function), _function_1), field);
    if ((prop.isId() || prop.isUuid())) {
      EList<JvmAnnotationReference> _annotations = field.getAnnotations();
      JvmAnnotationReference _annotation = this._jvmTypesBuilder.toAnnotation(prop, Id.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotation);
    }
    boolean _isVersion = prop.isVersion();
    if (_isVersion) {
      EList<JvmAnnotationReference> _annotations_1 = field.getAnnotations();
      JvmAnnotationReference _annotation_1 = this._jvmTypesBuilder.toAnnotation(prop, Version.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_1, _annotation_1);
    }
    boolean _isDomainKey = prop.isDomainKey();
    if (_isDomainKey) {
      EList<JvmAnnotationReference> _annotations_2 = field.getAnnotations();
      JvmAnnotationReference _annotation_2 = this._jvmTypesBuilder.toAnnotation(prop, DomainKey.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_2, _annotation_2);
    }
    boolean _isDomainDescription = prop.isDomainDescription();
    if (_isDomainDescription) {
      EList<JvmAnnotationReference> _annotations_3 = field.getAnnotations();
      JvmAnnotationReference _annotation_3 = this._jvmTypesBuilder.toAnnotation(prop, DomainDescription.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_3, _annotation_3);
    }
    boolean _isDirty = prop.isDirty();
    if (_isDirty) {
      EList<JvmAnnotationReference> _annotations_4 = field.getAnnotations();
      JvmAnnotationReference _annotation_4 = this._jvmTypesBuilder.toAnnotation(prop, Dirty.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_4, _annotation_4);
    }
    boolean _isAttributeHidden = prop.isAttributeHidden();
    if (_isAttributeHidden) {
      EList<JvmAnnotationReference> _annotations_5 = field.getAnnotations();
      JvmAnnotationReference _annotation_5 = this._jvmTypesBuilder.toAnnotation(prop, Hidden.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_5, _annotation_5);
    }
    boolean _isAttributeReadOnly = prop.isAttributeReadOnly();
    if (_isAttributeReadOnly) {
      EList<JvmAnnotationReference> _annotations_6 = field.getAnnotations();
      JvmAnnotationReference _annotation_6 = this._jvmTypesBuilder.toAnnotation(prop, ReadOnly.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_6, _annotation_6);
    }
    String _extraStyle = prop.getExtraStyle();
    boolean _tripleNotEquals = (_extraStyle != null);
    if (_tripleNotEquals) {
      final JvmAnnotationReference styleAnnotation = this._jvmTypesBuilder.toAnnotation(prop, ExtraStyle.class);
      this._annotationExtension.addAnnAttr(styleAnnotation, prop, "name", prop.getExtraStyle());
      EList<JvmAnnotationReference> _annotations_7 = field.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_7, styleAnnotation);
    }
    this.toPropertiesAnnotation(prop, this.mergeKeyAndValues(prop), field);
    boolean _isValidAllowed = this.isValidAllowed(prop.getType());
    if (_isValidAllowed) {
      this.toValidAnnotation(prop, field);
    }
    super.toDatatypeBasedConstraintAnnotations(prop, field);
  }
  
  protected void _internalProcessAnnotation(final LDtoInheritedAttribute prop, final JvmField field) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(prop.getResolvedAnnotations(), _function), _function_1), field);
    if ((prop.getInheritedFeature().isId() || prop.getInheritedFeature().isUuid())) {
      EList<JvmAnnotationReference> _annotations = field.getAnnotations();
      JvmAnnotationReference _annotation = this._jvmTypesBuilder.toAnnotation(prop, Id.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotation);
    }
    boolean _isVersion = prop.getInheritedFeature().isVersion();
    if (_isVersion) {
      EList<JvmAnnotationReference> _annotations_1 = field.getAnnotations();
      JvmAnnotationReference _annotation_1 = this._jvmTypesBuilder.toAnnotation(prop, Version.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_1, _annotation_1);
    }
    boolean _isDomainKey = prop.getInheritedFeature().isDomainKey();
    if (_isDomainKey) {
      EList<JvmAnnotationReference> _annotations_2 = field.getAnnotations();
      JvmAnnotationReference _annotation_2 = this._jvmTypesBuilder.toAnnotation(prop, DomainKey.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_2, _annotation_2);
    }
    boolean _isDomainDescription = prop.getInheritedFeature().isDomainDescription();
    if (_isDomainDescription) {
      EList<JvmAnnotationReference> _annotations_3 = field.getAnnotations();
      JvmAnnotationReference _annotation_3 = this._jvmTypesBuilder.toAnnotation(prop, DomainDescription.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_3, _annotation_3);
    }
    boolean _isAttributeHidden = prop.getInheritedFeature().isAttributeHidden();
    if (_isAttributeHidden) {
      EList<JvmAnnotationReference> _annotations_4 = field.getAnnotations();
      JvmAnnotationReference _annotation_4 = this._jvmTypesBuilder.toAnnotation(prop, Hidden.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_4, _annotation_4);
    }
    boolean _isAttributeReadOnly = prop.getInheritedFeature().isAttributeReadOnly();
    if (_isAttributeReadOnly) {
      EList<JvmAnnotationReference> _annotations_5 = field.getAnnotations();
      JvmAnnotationReference _annotation_5 = this._jvmTypesBuilder.toAnnotation(prop, ReadOnly.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_5, _annotation_5);
    }
    String _extraStyle = prop.getInheritedFeature().getExtraStyle();
    boolean _tripleNotEquals = (_extraStyle != null);
    if (_tripleNotEquals) {
      final JvmAnnotationReference styleAnnotation = this._jvmTypesBuilder.toAnnotation(prop, ExtraStyle.class);
      this._annotationExtension.addAnnAttr(styleAnnotation, prop, "name", prop.getInheritedFeature().getExtraStyle());
      EList<JvmAnnotationReference> _annotations_6 = field.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_6, styleAnnotation);
    }
    this.toPropertiesAnnotation(prop, this.mergeKeyAndValues(prop), field);
    boolean _isValidAllowed = this.isValidAllowed(prop.getInheritedFeature().getType());
    if (_isValidAllowed) {
      this.toValidAnnotation(prop, field);
    }
    if (((prop.getInheritedFeature().getType() instanceof LBean) && ((LBean) prop.getInheritedFeature().getType()).isBeanOnTab())) {
      this.toBeanOnTabAnnotation(prop, field);
    }
    boolean _isFiltering = prop.getInheritedFeature().isFiltering();
    if (_isFiltering) {
      EList<JvmAnnotationReference> _annotations_7 = field.getAnnotations();
      JvmAnnotationReference _annotation_6 = this._jvmTypesBuilder.toAnnotation(prop, Filter.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_7, _annotation_6);
    }
    boolean _isRangeFiltering = prop.getInheritedFeature().isRangeFiltering();
    if (_isRangeFiltering) {
      EList<JvmAnnotationReference> _annotations_8 = field.getAnnotations();
      JvmAnnotationReference _annotation_7 = this._jvmTypesBuilder.toAnnotation(prop, Range.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_8, _annotation_7);
    }
    boolean _isUniqueEntry = prop.getInheritedFeature().isUniqueEntry();
    if (_isUniqueEntry) {
      EList<JvmAnnotationReference> _annotations_9 = field.getAnnotations();
      JvmAnnotationReference _annotation_8 = this._jvmTypesBuilder.toAnnotation(prop, UniqueEntry.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_9, _annotation_8);
    }
    LAttribute _inheritedFeature = prop.getInheritedFeature();
    if ((_inheritedFeature instanceof LEntityAttribute)) {
      LAttribute _inheritedFeature_1 = prop.getInheritedFeature();
      final LEntityAttribute att = ((LEntityAttribute) _inheritedFeature_1);
      if ((att.getEntity().isHistorized() || att.getEntity().isTimedependent())) {
        boolean _isHistorizedValidUntilAnnotation = this._annotationExtension.isHistorizedValidUntilAnnotation(att);
        if (_isHistorizedValidUntilAnnotation) {
          EList<JvmAnnotationReference> _annotations_10 = field.getAnnotations();
          JvmAnnotationReference _annotation_9 = this._jvmTypesBuilder.toAnnotation(prop, HistValidUntil.class);
          this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_10, _annotation_9);
        }
        boolean _isHistorizedIsCurrentAnnotation = this._annotationExtension.isHistorizedIsCurrentAnnotation(att);
        if (_isHistorizedIsCurrentAnnotation) {
          EList<JvmAnnotationReference> _annotations_11 = field.getAnnotations();
          JvmAnnotationReference _annotation_10 = this._jvmTypesBuilder.toAnnotation(prop, HistIsCurrent.class);
          this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_11, _annotation_10);
        }
        boolean _isHistorizedIsCustomVersionAnnotation = this._annotationExtension.isHistorizedIsCustomVersionAnnotation(att);
        if (_isHistorizedIsCustomVersionAnnotation) {
          EList<JvmAnnotationReference> _annotations_12 = field.getAnnotations();
          JvmAnnotationReference _annotation_11 = this._jvmTypesBuilder.toAnnotation(prop, HistIsCustomVersion.class);
          this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_12, _annotation_11);
        }
      }
      boolean _isOnKanbanCard = att.isOnKanbanCard();
      if (_isOnKanbanCard) {
        EList<JvmAnnotationReference> _annotations_13 = field.getAnnotations();
        JvmAnnotationReference _annotation_12 = this._jvmTypesBuilder.toAnnotation(prop, OnKanbanCard.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_13, _annotation_12);
      }
      boolean _isAsKanbanOrdering = att.isAsKanbanOrdering();
      if (_isAsKanbanOrdering) {
        EList<JvmAnnotationReference> _annotations_14 = field.getAnnotations();
        JvmAnnotationReference _annotation_13 = this._jvmTypesBuilder.toAnnotation(prop, AsKanbanOrdering.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_14, _annotation_13);
      }
      boolean _isAsKanbanState = att.isAsKanbanState();
      if (_isAsKanbanState) {
        EList<JvmAnnotationReference> _annotations_15 = field.getAnnotations();
        JvmAnnotationReference _annotation_14 = this._jvmTypesBuilder.toAnnotation(prop, AsKanbanState.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_15, _annotation_14);
      }
      boolean _annotationPresent = this.annotationPresent(att, this.references.findDeclaredType(UpdateBy.class, att));
      if (_annotationPresent) {
        EList<JvmAnnotationReference> _annotations_16 = field.getAnnotations();
        JvmAnnotationReference _annotation_15 = this._jvmTypesBuilder.toAnnotation(prop, UpdateBy.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_16, _annotation_15);
      }
      boolean _annotationPresent_1 = this.annotationPresent(att, this.references.findDeclaredType(UpdateAt.class, att));
      if (_annotationPresent_1) {
        EList<JvmAnnotationReference> _annotations_17 = field.getAnnotations();
        JvmAnnotationReference _annotation_16 = this._jvmTypesBuilder.toAnnotation(prop, UpdateAt.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_17, _annotation_16);
      }
      boolean _annotationPresent_2 = this.annotationPresent(att, this.references.findDeclaredType(CreateBy.class, att));
      if (_annotationPresent_2) {
        EList<JvmAnnotationReference> _annotations_18 = field.getAnnotations();
        JvmAnnotationReference _annotation_17 = this._jvmTypesBuilder.toAnnotation(prop, CreateBy.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_18, _annotation_17);
      }
      boolean _annotationPresent_3 = this.annotationPresent(att, this.references.findDeclaredType(CreateAt.class, att));
      if (_annotationPresent_3) {
        EList<JvmAnnotationReference> _annotations_19 = field.getAnnotations();
        JvmAnnotationReference _annotation_18 = this._jvmTypesBuilder.toAnnotation(prop, CreateAt.class);
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_19, _annotation_18);
      }
      boolean _isIsGrouped = att.isIsGrouped();
      if (_isIsGrouped) {
        final JvmAnnotationReference groupAnnotation = this._jvmTypesBuilder.toAnnotation(prop, UIGroup.class);
        this._annotationExtension.addAnnAttr(groupAnnotation, prop, "name", att.getGroupName());
        EList<JvmAnnotationReference> _annotations_20 = field.getAnnotations();
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_20, groupAnnotation);
      }
    }
    this.toInheritedConstraintAnnotations(prop.getInheritedFeature(), field);
  }
  
  public boolean annotationPresent(final LEntityAttribute attribute, final JvmType type) {
    EList<LAnnotationDef> _resolvedAnnotations = attribute.getResolvedAnnotations();
    for (final LAnnotationDef anno : _resolvedAnnotations) {
      JvmType _annotationType = anno.getAnnotation().getAnnotationType();
      boolean _tripleEquals = (_annotationType == type);
      if (_tripleEquals) {
        return true;
      }
    }
    return false;
  }
  
  protected void _internalProcessAnnotation(final LDtoInheritedReference prop, final JvmField field) {
    final Function1<LAnnotationDef, Boolean> _function = (LAnnotationDef it) -> {
      boolean _isExclude = it.isExclude();
      return Boolean.valueOf((!_isExclude));
    };
    final Function1<LAnnotationDef, XAnnotation> _function_1 = (LAnnotationDef it) -> {
      return it.getAnnotation();
    };
    this._jvmTypesBuilder.translateAnnotationsTo(IterableExtensions.<LAnnotationDef, XAnnotation>map(IterableExtensions.<LAnnotationDef>filter(prop.getResolvedAnnotations(), _function), _function_1), field);
    EList<JvmAnnotationReference> _annotations = field.getAnnotations();
    JvmAnnotationReference _annotation = this._jvmTypesBuilder.toAnnotation(prop, DomainReference.class);
    this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotation);
    final LReference inheritedRef = prop.getInheritedFeature();
    if ((inheritedRef instanceof LEntityReference)) {
      LResultFilters _resultFilters = ((LEntityReference)inheritedRef).getResultFilters();
      boolean _notEquals = (!Objects.equal(_resultFilters, null));
      if (_notEquals) {
        this.addConstraintsAnno(((LEntityReference)inheritedRef).getResultFilters(), field, prop.getType());
      }
      boolean _isCascading = ((LEntityReference)inheritedRef).isCascading();
      if (_isCascading) {
        this.toValidAnnotation(prop, field);
      }
      this.toInheritedConstraintAnnotations(inheritedRef, field);
      this.toPropertiesAnnotation(prop, this.mergeKeyAndValues(prop), field);
      int _filterDepth = ((LEntityReference)inheritedRef).getFilterDepth();
      boolean _greaterEqualsThan = (_filterDepth >= 0);
      if (_greaterEqualsThan) {
        final JvmAnnotationReference anno = this._jvmTypesBuilder.toAnnotation(inheritedRef, FilterDepth.class);
        this._annotationExtension.addAnnAttr(anno, inheritedRef, "depth", Integer.valueOf(((LEntityReference)inheritedRef).getFilterDepth()));
        EList<JvmAnnotationReference> _annotations_1 = field.getAnnotations();
        this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_1, anno);
      }
    } else {
      if ((inheritedRef instanceof LBeanReference)) {
        LResultFilters _resultFilters_1 = ((LBeanReference)inheritedRef).getResultFilters();
        boolean _notEquals_1 = (!Objects.equal(_resultFilters_1, null));
        if (_notEquals_1) {
          this.addConstraintsAnno(((LBeanReference)inheritedRef).getResultFilters(), field, prop.getType());
        }
        boolean _isCascading_1 = ((LBeanReference)inheritedRef).isCascading();
        if (_isCascading_1) {
          this.toValidAnnotation(prop, field);
        }
        this.toInheritedConstraintAnnotations(inheritedRef, field);
        this.toPropertiesAnnotation(prop, this.mergeKeyAndValues(prop), field);
      }
    }
    boolean _isIsGrouped = inheritedRef.isIsGrouped();
    if (_isIsGrouped) {
      final JvmAnnotationReference groupAnnotation = this._jvmTypesBuilder.toAnnotation(prop, UIGroup.class);
      this._annotationExtension.addAnnAttr(groupAnnotation, prop, "name", inheritedRef.getGroupName());
      EList<JvmAnnotationReference> _annotations_2 = field.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_2, groupAnnotation);
    }
    boolean _isAsGrid = inheritedRef.isAsGrid();
    if (_isAsGrid) {
      EList<JvmAnnotationReference> _annotations_3 = field.getAnnotations();
      JvmAnnotationReference _annotation_1 = this._jvmTypesBuilder.toAnnotation(prop, AsGrid.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_3, _annotation_1);
    }
    boolean _isAsTable = inheritedRef.isAsTable();
    if (_isAsTable) {
      EList<JvmAnnotationReference> _annotations_4 = field.getAnnotations();
      JvmAnnotationReference _annotation_2 = this._jvmTypesBuilder.toAnnotation(prop, AsTable.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_4, _annotation_2);
    }
    boolean _isSideKick = inheritedRef.isSideKick();
    if (_isSideKick) {
      EList<JvmAnnotationReference> _annotations_5 = field.getAnnotations();
      JvmAnnotationReference _annotation_3 = this._jvmTypesBuilder.toAnnotation(prop, SideKick.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_5, _annotation_3);
    }
    boolean _isReferenceHidden = inheritedRef.isReferenceHidden();
    if (_isReferenceHidden) {
      EList<JvmAnnotationReference> _annotations_6 = field.getAnnotations();
      JvmAnnotationReference _annotation_4 = this._jvmTypesBuilder.toAnnotation(prop, Hidden.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_6, _annotation_4);
    }
    boolean _isReferenceReadOnly = inheritedRef.isReferenceReadOnly();
    if (_isReferenceReadOnly) {
      EList<JvmAnnotationReference> _annotations_7 = field.getAnnotations();
      JvmAnnotationReference _annotation_5 = this._jvmTypesBuilder.toAnnotation(prop, ReadOnly.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations_7, _annotation_5);
    }
  }
  
  public void addConstraintsAnno(final LResultFilters constraints, final JvmField jvmField, final LDto mapsTo) {
    final Function1<LResultFilter, Boolean> _function = (LResultFilter it) -> {
      return Boolean.valueOf((it instanceof LAttributeMatchingConstraint));
    };
    boolean _isEmpty = IterableExtensions.isEmpty(IterableExtensions.<LResultFilter>filter(constraints.getResultFilters(), _function));
    boolean _not = (!_isEmpty);
    if (_not) {
      final ArrayList<JvmAnnotationReference> innerAnnotations = CollectionLiterals.<JvmAnnotationReference>newArrayList();
      final Function1<LResultFilter, Boolean> _function_1 = (LResultFilter it) -> {
        return Boolean.valueOf((it instanceof LAttributeMatchingConstraint));
      };
      final Function1<LResultFilter, LAttributeMatchingConstraint> _function_2 = (LResultFilter it) -> {
        return ((LAttributeMatchingConstraint) it);
      };
      final Consumer<LAttributeMatchingConstraint> _function_3 = (LAttributeMatchingConstraint it) -> {
        final JvmTypeReference enumClassTypeRef = this.findReplacementEnum(it.getAttribute().getName(), mapsTo);
        boolean _notEquals = (!Objects.equal(enumClassTypeRef, null));
        if (_notEquals) {
          final JvmAnnotationReference innerAnno = this._jvmTypesBuilder.toAnnotation(constraints, TargetEnumConstraint.class);
          this._annotationExtension.addAnnAttr(innerAnno, it, "targetProperty", it.getAttribute().getName());
          this._annotationExtension.addAnnAttr(innerAnno, it, "enumClass", enumClassTypeRef);
          this._annotationExtension.addAnnAttr(innerAnno, it, "enumLiteral", it.getMatchingLiteral().getName());
          innerAnnotations.add(innerAnno);
        }
      };
      IterableExtensions.<LResultFilter, LAttributeMatchingConstraint>map(IterableExtensions.<LResultFilter>filter(constraints.getResultFilters(), _function_1), _function_2).forEach(_function_3);
      final JvmAnnotationReference mainAnno = this._jvmTypesBuilder.toAnnotation(constraints, TargetEnumConstraints.class);
      this._annotationExtension.addAnnAttr(mainAnno, constraints, "constraints", 
        innerAnnotations.<JvmAnnotationReference>toArray(new JvmAnnotationReference[((Object[])Conversions.unwrapArray(innerAnnotations, Object.class)).length]));
      EList<JvmAnnotationReference> _annotations = jvmField.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, mainAnno);
    }
  }
  
  /**
   * Iterates all attributes of the target dto. If a matching att name was found, the jvmType proxy will be returned.
   */
  public JvmTypeReference findReplacementEnum(final String property, final LDto mapsTo) {
    final Function1<LFeature, Boolean> _function = (LFeature it) -> {
      return Boolean.valueOf((it instanceof LDtoAbstractAttribute));
    };
    final Function1<LFeature, LDtoAbstractAttribute> _function_1 = (LFeature it) -> {
      return ((LDtoAbstractAttribute) it);
    };
    Iterable<LDtoAbstractAttribute> _map = IterableExtensions.map(IterableExtensions.filter(mapsTo.getAllFeatures(), _function), _function_1);
    for (final LDtoAbstractAttribute att : _map) {
      if ((att instanceof LDtoInheritedAttribute)) {
        LAttribute _inheritedFeature = ((LDtoInheritedAttribute)att).getInheritedFeature();
        String _name = null;
        if (_inheritedFeature!=null) {
          _name=_inheritedFeature.getName();
        }
        boolean _equals = _name.equals(property);
        if (_equals) {
          return this._dtoModelExtensions.toDtoTypeReference(att);
        }
      } else {
        boolean _equals_1 = att.getName().equals(property);
        if (_equals_1) {
          return this._dtoModelExtensions.toDtoTypeReference(att);
        }
      }
    }
    return null;
  }
  
  protected boolean _addDisposeFieldAnnotation(final LDto dto, final JvmField field) {
    return this._annotationExtension.addAnno(dto, field, this._jvmTypesBuilder.toAnnotation(dto, Dispose.class));
  }
  
  protected boolean _addDisposeFieldAnnotation(final LDto dto, final JvmOperation op) {
    return this._annotationExtension.addAnno(dto, op, this._jvmTypesBuilder.toAnnotation(dto, Dispose.class));
  }
  
  protected boolean _isValidAllowed(final LBean type) {
    return true;
  }
  
  protected void _toInheritedConstraintAnnotations(final LDtoInheritedAttribute prop, final JvmField jvmField) {
    final LAttribute feature = prop.getInheritedFeature();
    if ((feature instanceof LBeanAttribute)) {
      this.toInheritedConstraintAnnotations(feature, jvmField);
    } else {
      if ((feature instanceof LEntityAttribute)) {
        this.toInheritedConstraintAnnotations(feature, jvmField);
      }
    }
  }
  
  protected void _toInheritedConstraintAnnotations(final LBeanAttribute prop, final JvmField jvmField) {
    EList<LDatatypeConstraint> _constraints = prop.getConstraints();
    for (final LDatatypeConstraint c : _constraints) {
      this.toConstraintAnnotation(c, jvmField);
    }
    boolean _isEmpty = prop.getConstraints().isEmpty();
    if (_isEmpty) {
      super.toDatatypeBasedConstraintAnnotations(prop, jvmField);
    }
  }
  
  protected void _toInheritedConstraintAnnotations(final LBeanReference prop, final JvmField jvmField) {
    EList<LDatatypeConstraint> _constraints = prop.getConstraints();
    for (final LDatatypeConstraint c : _constraints) {
      this.toConstraintAnnotation(c, jvmField);
    }
  }
  
  protected void _toInheritedConstraintAnnotations(final LEntityAttribute prop, final JvmField jvmField) {
    EList<LDatatypeConstraint> _constraints = prop.getConstraints();
    for (final LDatatypeConstraint c : _constraints) {
      this.toConstraintAnnotation(c, jvmField);
    }
    boolean _isEmpty = prop.getConstraints().isEmpty();
    if (_isEmpty) {
      super.toDatatypeBasedConstraintAnnotations(prop, jvmField);
    }
  }
  
  protected void _toInheritedConstraintAnnotations(final LEntityReference prop, final JvmField jvmField) {
    EList<LDatatypeConstraint> _constraints = prop.getConstraints();
    for (final LDatatypeConstraint c : _constraints) {
      this.toConstraintAnnotation(c, jvmField);
    }
  }
  
  protected void internalProcessAnnotation(final LAnnotationTarget prop, final JvmMember field) {
    if (prop instanceof LDtoAttribute
         && field instanceof JvmField) {
      _internalProcessAnnotation((LDtoAttribute)prop, (JvmField)field);
      return;
    } else if (prop instanceof LDtoInheritedAttribute
         && field instanceof JvmField) {
      _internalProcessAnnotation((LDtoInheritedAttribute)prop, (JvmField)field);
      return;
    } else if (prop instanceof LDtoInheritedReference
         && field instanceof JvmField) {
      _internalProcessAnnotation((LDtoInheritedReference)prop, (JvmField)field);
      return;
    } else if (prop instanceof LDtoReference
         && field instanceof JvmField) {
      _internalProcessAnnotation((LDtoReference)prop, (JvmField)field);
      return;
    } else if (prop instanceof LDtoReference
         && field instanceof JvmGenericType) {
      _internalProcessAnnotation((LDtoReference)prop, (JvmGenericType)field);
      return;
    } else if (prop instanceof LDto
         && field instanceof JvmGenericType) {
      _internalProcessAnnotation((LDto)prop, (JvmGenericType)field);
      return;
    } else if (prop instanceof LAttribute
         && field instanceof JvmField) {
      _internalProcessAnnotation((LAttribute)prop, (JvmField)field);
      return;
    } else if (prop instanceof LReference
         && field instanceof JvmField) {
      _internalProcessAnnotation((LReference)prop, (JvmField)field);
      return;
    } else if (prop instanceof LOperation
         && field instanceof JvmOperation) {
      _internalProcessAnnotation((LOperation)prop, (JvmOperation)field);
      return;
    } else if (prop instanceof LType
         && field instanceof JvmGenericType) {
      _internalProcessAnnotation((LType)prop, (JvmGenericType)field);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(prop, field).toString());
    }
  }
  
  public boolean addDisposeFieldAnnotation(final LDto dto, final JvmFeature op) {
    if (op instanceof JvmOperation) {
      return _addDisposeFieldAnnotation(dto, (JvmOperation)op);
    } else if (op instanceof JvmField) {
      return _addDisposeFieldAnnotation(dto, (JvmField)op);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(dto, op).toString());
    }
  }
  
  public boolean isValidAllowed(final LScalarType type) {
    if (type instanceof LDataType) {
      return _isValidAllowed((LDataType)type);
    } else if (type instanceof LBean) {
      return _isValidAllowed((LBean)type);
    } else if (type != null) {
      return _isValidAllowed(type);
    } else if (type == null) {
      return _isValidAllowed((Void)null);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(type).toString());
    }
  }
  
  public void toInheritedConstraintAnnotations(final LFeature prop, final JvmField jvmField) {
    if (prop instanceof LDtoInheritedAttribute) {
      _toInheritedConstraintAnnotations((LDtoInheritedAttribute)prop, jvmField);
      return;
    } else if (prop instanceof LBeanAttribute) {
      _toInheritedConstraintAnnotations((LBeanAttribute)prop, jvmField);
      return;
    } else if (prop instanceof LBeanReference) {
      _toInheritedConstraintAnnotations((LBeanReference)prop, jvmField);
      return;
    } else if (prop instanceof LEntityAttribute) {
      _toInheritedConstraintAnnotations((LEntityAttribute)prop, jvmField);
      return;
    } else if (prop instanceof LEntityReference) {
      _toInheritedConstraintAnnotations((LEntityReference)prop, jvmField);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(prop, jvmField).toString());
    }
  }
}