/**
 * 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.autowirehelper.utils;

import com.google.common.base.Objects;
import com.google.common.collect.Iterables;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import javax.inject.Inject;
import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.dsl.semantic.common.types.LDataType;
import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue;
import org.eclipse.osbp.dsl.semantic.common.types.LScalarType;
import org.eclipse.osbp.dsl.semantic.dto.LDto;
import org.eclipse.osbp.dsl.semantic.dto.LDtoAbstractAttribute;
import org.eclipse.osbp.dsl.semantic.dto.LDtoFeature;
import org.eclipse.osbp.dsl.semantic.dto.LDtoInheritedAttribute;
import org.eclipse.osbp.dsl.semantic.dto.LDtoInheritedReference;
import org.eclipse.osbp.dsl.semantic.entity.LEntity;
import org.eclipse.osbp.ecview.dsl.extensions.BindableTypeResolver;
import org.eclipse.osbp.ecview.dsl.extensions.OperationExtensions;
import org.eclipse.osbp.ecview.dsl.extensions.TypeHelper;
import org.eclipse.osbp.ecview.semantic.uimodel.UiBeanSlot;
import org.eclipse.osbp.ecview.semantic.uimodel.UiLayout;
import org.eclipse.osbp.ecview.semantic.uimodel.UiModel;
import org.eclipse.osbp.ecview.semantic.uimodel.UiView;
import org.eclipse.osbp.ecview.semantic.uimodel.impl.UiViewImpl;
import org.eclipse.osbp.runtime.common.annotations.DomainDescription;
import org.eclipse.osbp.runtime.common.annotations.DomainKey;
import org.eclipse.osbp.runtime.common.annotations.FilterDepth;
import org.eclipse.osbp.runtime.common.annotations.Properties;
import org.eclipse.osbp.utils.common.EntityUtils;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.common.types.JvmAnnotationAnnotationValue;
import org.eclipse.xtext.common.types.JvmAnnotationReference;
import org.eclipse.xtext.common.types.JvmAnnotationValue;
import org.eclipse.xtext.common.types.JvmDeclaredType;
import org.eclipse.xtext.common.types.JvmField;
import org.eclipse.xtext.common.types.JvmIntAnnotationValue;
import org.eclipse.xtext.common.types.JvmMember;
import org.eclipse.xtext.common.types.JvmStringAnnotationValue;
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.naming.IQualifiedNameProvider;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.InputOutput;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ListExtensions;

@SuppressWarnings("all")
public class AutowireUtil {
  public static class Pair {
    public String key;
    
    public String value;
    
    public Pair(final String key, final String value) {
      this.key = key;
      this.value = value;
    }
  }
  
  @Inject
  @Extension
  private IQualifiedNameProvider _iQualifiedNameProvider;
  
  @Inject
  @Extension
  private TypeHelper _typeHelper;
  
  @Inject
  private TypeReferences typeReferences;
  
  public String generateId(final UiLayout layout) {
    final BindableTypeResolver resolver = new BindableTypeResolver();
    JvmType resolvedType = resolver.resolveType(layout.getAutoWireSource());
    String viewName = "";
    EObject parent = layout.eContainer();
    while ((!(parent instanceof UiModel))) {
      {
        if ((parent instanceof UiViewImpl)) {
          viewName = ((UiViewImpl) parent).getName();
        }
        parent = parent.eContainer();
      }
    }
    UiModel uimodel = ((UiModel) parent);
    StringConcatenation _builder = new StringConcatenation();
    String _packageName = uimodel.getPackageName();
    _builder.append(_packageName);
    {
      boolean _notEquals = (!Objects.equal(viewName, null));
      if (_notEquals) {
        _builder.append(".");
        _builder.append(viewName);
      }
    }
    {
      boolean _notEquals_1 = (!Objects.equal(resolvedType, null));
      if (_notEquals_1) {
        _builder.append(".");
        String _identifier = resolvedType.getIdentifier();
        _builder.append(_identifier);
      }
    }
    return _builder.toString();
  }
  
  public UiView getUiView(final UiLayout layout) {
    EObject parent = layout.eContainer();
    while ((!(parent instanceof UiViewImpl))) {
      parent = parent.eContainer();
    }
    if ((parent instanceof UiViewImpl)) {
      return ((UiViewImpl) parent);
    }
    return null;
  }
  
  public boolean isAttribute(final JvmType type, final String attribute, final String filterName) {
    LDto dto = EntityUtils.getDto(type);
    boolean _notEquals = (!Objects.equal(dto, null));
    if (_notEquals) {
      final Function1<LDtoAbstractAttribute, Boolean> _function = (LDtoAbstractAttribute it) -> {
        String _name = this.toName(it);
        return Boolean.valueOf(Objects.equal(_name, attribute));
      };
      LDtoAbstractAttribute attr = IterableExtensions.<LDtoAbstractAttribute>findFirst(dto.getAttributes(), _function);
      boolean _notEquals_1 = (!Objects.equal(attr, null));
      if (_notEquals_1) {
        LScalarType _datatype = this.toDatatype(attr);
        LDataType datatype = ((LDataType) _datatype);
        String _name = datatype.getName();
        return Objects.equal(_name, filterName);
      }
    }
    return false;
  }
  
  /**
   * Detects all the existing properties of the jvmtype corresponding attribute, the datatype of the attribute and references.
   */
  public List<AutowireUtil.Pair> toProperties(final JvmDeclaredType type, final String attributeName) {
    final List<AutowireUtil.Pair> result = this.toFieldProperties(type).get(attributeName);
    boolean _notEquals = (!Objects.equal(result, null));
    if (_notEquals) {
      for (final AutowireUtil.Pair prop : result) {
        prop.value = StringEscapeUtils.unescapeHtml(prop.value);
      }
    }
    List<AutowireUtil.Pair> _xifexpression = null;
    boolean _notEquals_1 = (!Objects.equal(result, null));
    if (_notEquals_1) {
      _xifexpression = result;
    } else {
      _xifexpression = CollectionLiterals.<AutowireUtil.Pair>newArrayList();
    }
    return _xifexpression;
  }
  
  /**
   * Detects all the existing properties of the jvmtype corresponding reference and the referenced dto.
   */
  public Map<String, List<AutowireUtil.Pair>> toFieldProperties(final JvmDeclaredType jvmType) {
    final Map<String, List<AutowireUtil.Pair>> propMap = CollectionLiterals.<String, List<AutowireUtil.Pair>>newHashMap();
    final Consumer<JvmField> _function = (JvmField it) -> {
      StringConcatenation _builder = new StringConcatenation();
      String _qualifiedName = jvmType.getQualifiedName();
      _builder.append(_qualifiedName);
      _builder.append(".");
      String _simpleName = it.getSimpleName();
      _builder.append(_simpleName);
      final String attrPropKey = _builder.toString();
      final List<AutowireUtil.Pair> values = CollectionLiterals.<AutowireUtil.Pair>newArrayList();
      propMap.put(attrPropKey, values);
      final Function1<JvmAnnotationReference, Boolean> _function_1 = (JvmAnnotationReference e) -> {
        final boolean result = e.getAnnotation().getIdentifier().equals(Properties.class.getName());
        return Boolean.valueOf(result);
      };
      final Consumer<JvmAnnotationReference> _function_2 = (JvmAnnotationReference it_1) -> {
        final JvmAnnotationReference ref = it_1;
        final Function1<JvmAnnotationValue, JvmAnnotationAnnotationValue> _function_3 = (JvmAnnotationValue it_2) -> {
          return ((JvmAnnotationAnnotationValue) it_2);
        };
        final Consumer<JvmAnnotationAnnotationValue> _function_4 = (JvmAnnotationAnnotationValue av) -> {
          final Consumer<JvmAnnotationReference> _function_5 = (JvmAnnotationReference it_2) -> {
            JvmAnnotationValue _get = it_2.getValues().get(0);
            final JvmStringAnnotationValue keyAn = ((JvmStringAnnotationValue) _get);
            JvmAnnotationValue _get_1 = it_2.getValues().get(1);
            final JvmStringAnnotationValue valueAn = ((JvmStringAnnotationValue) _get_1);
            String _get_2 = keyAn.getValues().get(0);
            String _get_3 = valueAn.getValues().get(0);
            AutowireUtil.Pair _pair = new AutowireUtil.Pair(_get_2, _get_3);
            values.add(_pair);
          };
          av.getValues().forEach(_function_5);
        };
        ListExtensions.<JvmAnnotationValue, JvmAnnotationAnnotationValue>map(ref.getValues(), _function_3).forEach(_function_4);
      };
      IterableExtensions.<JvmAnnotationReference>filter(it.getAnnotations(), _function_1).forEach(_function_2);
    };
    Iterables.<JvmField>filter(jvmType.getAllFeatures(), JvmField.class).forEach(_function);
    return propMap;
  }
  
  /**
   * Returns the depth of the filter for BeanReferenceFields
   */
  public int toFilterDepth(final JvmField field) {
    final Function1<JvmAnnotationReference, Boolean> _function = (JvmAnnotationReference e) -> {
      final boolean result = e.getAnnotation().getIdentifier().equals(FilterDepth.class.getName());
      return Boolean.valueOf(result);
    };
    final JvmAnnotationReference ref = IterableExtensions.<JvmAnnotationReference>findFirst(field.getAnnotations(), _function);
    if ((ref == null)) {
      return 0;
    }
    JvmAnnotationValue _get = ref.getValues().get(0);
    final JvmIntAnnotationValue depthVal = ((JvmIntAnnotationValue) _get);
    return (depthVal.getValues().get(0)).intValue();
  }
  
  /**
   * Detects all the existing properties of the jvmtype corresponding datatype of the attribute.
   */
  public LDataType toDataType(final JvmType type, final String attributeName) {
    LDto dto = EntityUtils.getDto(type);
    boolean _notEquals = (!Objects.equal(dto, null));
    if (_notEquals) {
      final Function1<LDtoAbstractAttribute, Boolean> _function = (LDtoAbstractAttribute it) -> {
        String _name = this.toName(it);
        return Boolean.valueOf(Objects.equal(_name, attributeName));
      };
      LDtoAbstractAttribute attr = IterableExtensions.<LDtoAbstractAttribute>findFirst(dto.getAttributes(), _function);
      boolean _notEquals_1 = (!Objects.equal(attr, null));
      if (_notEquals_1) {
        LScalarType dataType = this.toDatatype(attr);
        if ((dataType instanceof LDataType)) {
          LScalarType _datatype = this.toDatatype(attr);
          return ((LDataType) _datatype);
        }
      }
    }
    return null;
  }
  
  /**
   * Provides the datatype of the corresponding attribute.
   */
  public List<LKeyAndValue> toDataTypeProperties(final JvmType type, final String attributeName) {
    LDataType dataType = this.toDataType(type, attributeName);
    boolean _notEquals = (!Objects.equal(dataType, null));
    if (_notEquals) {
      return dataType.getProperties();
    }
    return CollectionLiterals.<LKeyAndValue>newArrayList();
  }
  
  public String toName(final LDtoFeature feature) {
    if ((feature instanceof LDtoInheritedAttribute)) {
      return ((LDtoInheritedAttribute)feature).getInheritedFeature().getName();
    } else {
      if ((feature instanceof LDtoInheritedReference)) {
        return ((LDtoInheritedReference)feature).getInheritedFeature().getName();
      } else {
        return feature.getName();
      }
    }
  }
  
  public LScalarType toDatatype(final LDtoAbstractAttribute att) {
    if ((att instanceof LDtoInheritedAttribute)) {
      return ((LDtoInheritedAttribute)att).getInheritedFeature().getType();
    } else {
      return att.getType();
    }
  }
  
  public boolean isBlob(final JvmType type, final String attribute) {
    LDto dto = EntityUtils.getDto(type);
    final Function1<LDtoAbstractAttribute, Boolean> _function = (LDtoAbstractAttribute it) -> {
      String _name = it.getName();
      return Boolean.valueOf(Objects.equal(_name, attribute));
    };
    Iterable<LDtoAbstractAttribute> attrs = IterableExtensions.<LDtoAbstractAttribute>filter(dto.getAttributes(), _function);
    for (final LDtoAbstractAttribute attr : attrs) {
      {
        LScalarType _type = attr.getType();
        LDataType datatype = ((LDataType) _type);
        InputOutput.<LDataType>println(datatype);
        return datatype.isAsBlob();
      }
    }
    return false;
  }
  
  public String getEntityName(final UiBeanSlot uiBeanSlot) {
    LEntity _entityFromDto = EntityUtils.getEntityFromDto(uiBeanSlot.getJvmType().getType());
    final LEntity entity = ((LEntity) _entityFromDto);
    String eName = null;
    boolean _equals = Objects.equal(entity, null);
    if (_equals) {
      JvmType _type = uiBeanSlot.getJvmType().getType();
      boolean _equals_1 = Objects.equal(_type, null);
      if (_equals_1) {
        eName = "";
      } else {
        JvmType _type_1 = uiBeanSlot.getJvmType().getType();
        boolean _notEquals = (!Objects.equal(_type_1, null));
        if (_notEquals) {
          eName = "";
        }
      }
    } else {
      eName = entity.getName();
    }
    return eName;
  }
  
  public boolean isClass(final JvmType type) {
    boolean _is = this.typeReferences.is(type, Class.class);
    if (_is) {
      return true;
    }
    return false;
  }
  
  public boolean isByteArray(final JvmType type) {
    boolean _is = this.typeReferences.is(type, byte[].class);
    if (_is) {
      return true;
    }
    return false;
  }
  
  public boolean isAllowed(final JvmType type, final JvmType beanType, final OperationExtensions.OperationInfo info) {
    boolean _isNumberWithDigits = this._typeHelper.isNumberWithDigits(type);
    if (_isNumberWithDigits) {
      return true;
    } else {
      boolean _isNumberWithoutDigits = this._typeHelper.isNumberWithoutDigits(type);
      if (_isNumberWithoutDigits) {
        return true;
      } else {
        boolean _isString = this._typeHelper.isString(type);
        if (_isString) {
          return true;
        } else {
          boolean _isDate = this._typeHelper.isDate(type);
          if (_isDate) {
            return true;
          } else {
            boolean _isByteArray = this.isByteArray(type);
            if (_isByteArray) {
              return true;
            } else {
              boolean _isBoolean = this._typeHelper.isBoolean(type);
              if (_isBoolean) {
                return true;
              } else {
                boolean _isEnum = this._typeHelper.isEnum(type);
                if (_isEnum) {
                  return true;
                } else {
                  boolean _isDomainReference = this._typeHelper.isDomainReference(info);
                  if (_isDomainReference) {
                    boolean _matched = false;
                    if (type instanceof JvmDeclaredType) {
                      _matched=true;
                      if ((this.isAnnotationOf(((JvmDeclaredType) type), DomainKey.class) || 
                        this.isAnnotationOf(((JvmDeclaredType) type), DomainDescription.class))) {
                        return true;
                      }
                    }
                    return false;
                  } else {
                    if (((!Objects.equal(info.getField(), null)) && this._typeHelper.isCollection(info.getField()))) {
                      return true;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    return false;
  }
  
  private boolean isAnnotationOf(final JvmDeclaredType type, final Class<?> clazz) {
    EList<JvmMember> _members = type.getMembers();
    for (final JvmMember member : _members) {
      EList<JvmAnnotationReference> _annotations = member.getAnnotations();
      for (final JvmAnnotationReference annotation : _annotations) {
        boolean _equals = annotation.getAnnotation().getIdentifier().equals(clazz.getCanonicalName());
        if (_equals) {
          return true;
        }
      }
    }
    EList<JvmTypeReference> _superTypes = type.getSuperTypes();
    for (final JvmTypeReference superType : _superTypes) {
      JvmType _type = superType.getType();
      if ((_type instanceof JvmDeclaredType)) {
        JvmType _type_1 = superType.getType();
        return this.isAnnotationOf(((JvmDeclaredType) _type_1), clazz);
      }
    }
    return false;
  }
}