/**
 * 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.blip.common;

import com.google.common.base.Objects;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.bpm.NamingConvention;
import org.eclipse.osbp.dsl.semantic.common.types.LMultiplicity;
import org.eclipse.osbp.dsl.semantic.common.types.LType;
import org.eclipse.osbp.dsl.semantic.dto.LAutoInheritDto;
import org.eclipse.osbp.dsl.semantic.dto.LDto;
import org.eclipse.osbp.dsl.semantic.dto.LDtoAbstractReference;
import org.eclipse.osbp.dsl.semantic.dto.LDtoFeature;
import org.eclipse.osbp.dsl.semantic.dto.impl.LDtoInheritedReferenceImpl;
import org.eclipse.osbp.dsl.semantic.dto.impl.LDtoReferenceImpl;
import org.eclipse.osbp.dsl.semantic.entity.LEntity;
import org.eclipse.osbp.xtext.blip.Blip;
import org.eclipse.osbp.xtext.blip.BlipCallActivity;
import org.eclipse.osbp.xtext.blip.BlipDto;
import org.eclipse.osbp.xtext.blip.BlipDtoPath;
import org.eclipse.osbp.xtext.blip.BlipEvent;
import org.eclipse.osbp.xtext.blip.BlipItem;
import org.eclipse.osbp.xtext.blip.BlipOutGoing;
import org.eclipse.osbp.xtext.blip.BlipScript;
import org.eclipse.osbp.xtext.blip.BlipServiceTask;
import org.eclipse.osbp.xtext.blip.BlipSplitGateway;
import org.eclipse.osbp.xtext.blip.BlipUserTask;
import org.eclipse.osbp.xtext.blip.BlipWorkload;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;

@SuppressWarnings("all")
public class BlipHelper {
  public static String getBpmItemRecommendedName(final BlipItem blipItem) {
    String bpmItemName = "";
    if ((blipItem instanceof BlipEvent)) {
      bpmItemName = ((BlipEvent)blipItem).getEvent().getName();
    } else {
      if ((blipItem instanceof BlipSplitGateway)) {
        bpmItemName = ((BlipSplitGateway)blipItem).getGateway().getName();
      } else {
        if ((blipItem instanceof BlipUserTask)) {
          bpmItemName = ((BlipUserTask)blipItem).getTask().getName();
        } else {
          if ((blipItem instanceof BlipCallActivity)) {
            bpmItemName = ((BlipCallActivity)blipItem).getCallActivity().getName();
          } else {
            if ((blipItem instanceof BlipScript)) {
              bpmItemName = ((BlipScript)blipItem).getTask().getName();
            } else {
              if ((blipItem instanceof BlipServiceTask)) {
                bpmItemName = ((BlipServiceTask)blipItem).getTask().getName();
              } else {
                if ((blipItem instanceof BlipOutGoing)) {
                  bpmItemName = ((BlipOutGoing)blipItem).getSequenceFlow().getName();
                }
              }
            }
          }
        }
      }
    }
    return NamingConvention.getBpmItemRecommendedName(bpmItemName);
  }
  
  public static boolean isOperativeDtoDefined(final BlipItem blipItem) {
    boolean _and = false;
    BlipDtoPath _dtoPath = null;
    if (blipItem!=null) {
      _dtoPath=blipItem.getDtoPath();
    }
    boolean _notEquals = (!Objects.equal(_dtoPath, null));
    if (!_notEquals) {
      _and = false;
    } else {
      BlipDtoPath _dtoPath_1 = null;
      if (blipItem!=null) {
        _dtoPath_1=blipItem.getDtoPath();
      }
      boolean _isEmpty = _dtoPath_1.getDtoPath().isEmpty();
      boolean _not = (!_isEmpty);
      _and = _not;
    }
    return _and;
  }
  
  public static LDtoAbstractReference getDtoFeature(final LDto operativeDto, final String dtoChildName) {
    boolean _notEquals = (!Objects.equal(operativeDto, null));
    if (_notEquals) {
      EList<LDtoFeature> _features = operativeDto.getFeatures();
      for (final LDtoFeature feature : _features) {
        {
          String attributeName = ((String) null);
          if ((feature instanceof LDtoReferenceImpl)) {
            attributeName = ((LDtoReferenceImpl)feature).getName();
          }
          if ((feature instanceof LDtoInheritedReferenceImpl)) {
            attributeName = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature().getName();
          }
          boolean _notEquals_1 = (!Objects.equal(attributeName, null));
          if (_notEquals_1) {
            if ((attributeName.equals(dtoChildName) && (feature instanceof LDtoAbstractReference))) {
              return ((LDtoAbstractReference) feature);
            }
          }
        }
      }
    }
    return null;
  }
  
  public static LDto getPureOperativeLDto(final BlipItem blipItem) {
    boolean _isOperativeDtoDefined = BlipHelper.isOperativeDtoDefined(blipItem);
    if (_isOperativeDtoDefined) {
      EObject _eContainer = null;
      if (blipItem!=null) {
        _eContainer=blipItem.eContainer();
      }
      BlipWorkload _workload = null;
      if (((Blip) _eContainer)!=null) {
        _workload=((Blip) _eContainer).getWorkload();
      }
      BlipDto _source = null;
      if (_workload!=null) {
        _source=_workload.getSource();
      }
      LDto _dtoRef = null;
      if (_source!=null) {
        _dtoRef=_source.getDtoRef();
      }
      LDto operativeDto = _dtoRef;
      boolean _and = false;
      if (!((!Objects.equal(operativeDto, null)) && (!Objects.equal(operativeDto.getName(), null)))) {
        _and = false;
      } else {
        String _name = operativeDto.getName();
        BlipDtoPath _dtoPath = null;
        if (blipItem!=null) {
          _dtoPath=blipItem.getDtoPath();
        }
        boolean _equals = _name.equals(_dtoPath);
        boolean _not = (!_equals);
        _and = _not;
      }
      if (_and) {
        BlipDtoPath _dtoPath_1 = null;
        if (blipItem!=null) {
          _dtoPath_1=blipItem.getDtoPath();
        }
        String dtoPath = _dtoPath_1.getDtoPath();
        String _name_1 = operativeDto.getName();
        String _plus = (_name_1 + ".");
        boolean _startsWith = dtoPath.startsWith(_plus);
        boolean _not_1 = (!_startsWith);
        if (_not_1) {
          return null;
        } else {
          String _name_2 = operativeDto.getName();
          dtoPath = dtoPath.substring((_name_2 + ".").length());
          final String[] dtoChildNames = dtoPath.split("\\.");
          for (final String dtoChildName : dtoChildNames) {
            operativeDto = BlipHelper.getReferencedLDto(operativeDto, dtoChildName);
          }
        }
      }
      return operativeDto;
    }
    return null;
  }
  
  public static LDtoAbstractReference getDtoFeature(final BlipItem blipItem) {
    LDtoAbstractReference dtoFeature = ((LDtoAbstractReference) null);
    LDto operativeDto = ((LDto) null);
    boolean _isOperativeDtoDefined = BlipHelper.isOperativeDtoDefined(blipItem);
    if (_isOperativeDtoDefined) {
      EObject _eContainer = null;
      if (blipItem!=null) {
        _eContainer=blipItem.eContainer();
      }
      BlipWorkload _workload = null;
      if (((Blip) _eContainer)!=null) {
        _workload=((Blip) _eContainer).getWorkload();
      }
      BlipDto _source = null;
      if (_workload!=null) {
        _source=_workload.getSource();
      }
      LDto _dtoRef = null;
      if (_source!=null) {
        _dtoRef=_source.getDtoRef();
      }
      operativeDto = _dtoRef;
      boolean _and = false;
      if (!((!Objects.equal(operativeDto, null)) && (!Objects.equal(operativeDto.getName(), null)))) {
        _and = false;
      } else {
        String _name = operativeDto.getName();
        BlipDtoPath _dtoPath = null;
        if (blipItem!=null) {
          _dtoPath=blipItem.getDtoPath();
        }
        boolean _equals = _name.equals(_dtoPath);
        boolean _not = (!_equals);
        _and = _not;
      }
      if (_and) {
        BlipDtoPath _dtoPath_1 = null;
        if (blipItem!=null) {
          _dtoPath_1=blipItem.getDtoPath();
        }
        String _dtoPath_2 = _dtoPath_1.getDtoPath();
        String _name_1 = operativeDto.getName();
        String _plus = (_name_1 + ".");
        final String[] dtoChildNames = _dtoPath_2.replace(_plus, "").split("\\.");
        for (final String dtoChildName : dtoChildNames) {
          {
            dtoFeature = BlipHelper.getDtoFeature(operativeDto, dtoChildName);
            operativeDto = BlipHelper.getReferencedLDto(operativeDto, dtoChildName);
          }
        }
      }
    }
    return dtoFeature;
  }
  
  public static LEntity getOperativeEntity(final BlipItem blipItem) {
    LDto dto = blipItem.getOperativeLDto();
    if ((dto instanceof LAutoInheritDto)) {
      LType _wrappedType = ((LAutoInheritDto)dto).getWrappedType();
      if ((_wrappedType instanceof LEntity)) {
        LType _wrappedType_1 = ((LAutoInheritDto)dto).getWrappedType();
        return ((LEntity) _wrappedType_1);
      }
    }
    return null;
  }
  
  public static LDto getOperativeLDto(final BlipItem blipItem) {
    final LDto operativeDto = BlipHelper.getPureOperativeLDto(blipItem);
    boolean _equals = Objects.equal(operativeDto, null);
    if (_equals) {
      EObject _eContainer = null;
      if (blipItem!=null) {
        _eContainer=blipItem.eContainer();
      }
      BlipWorkload _workload = null;
      if (((Blip) _eContainer)!=null) {
        _workload=((Blip) _eContainer).getWorkload();
      }
      BlipDto _source = null;
      if (_workload!=null) {
        _source=_workload.getSource();
      }
      LDto _dtoRef = null;
      if (_source!=null) {
        _dtoRef=_source.getDtoRef();
      }
      return _dtoRef;
    } else {
      return operativeDto;
    }
  }
  
  public static LDto getReferencedLDto(final LDto operativeDto, final String dtoChildName) {
    LDtoAbstractReference dtoFeature = BlipHelper.getDtoFeature(operativeDto, dtoChildName);
    boolean _notEquals = (!Objects.equal(dtoFeature, null));
    if (_notEquals) {
      return dtoFeature.getType();
    }
    return null;
  }
  
  public static List<String> getAvailableDtoPaths(final BlipItem blipItem) {
    EObject _eContainer = blipItem.eContainer();
    return BlipHelper.getAvailableDtoPaths(((Blip) _eContainer));
  }
  
  public static List<String> getAvailableDtoPaths(final Blip blip) {
    ArrayList<String> results = CollectionLiterals.<String>newArrayList();
    BlipWorkload _workload = null;
    if (blip!=null) {
      _workload=blip.getWorkload();
    }
    BlipDto _source = null;
    if (_workload!=null) {
      _source=_workload.getSource();
    }
    LDto _dtoRef = null;
    if (_source!=null) {
      _dtoRef=_source.getDtoRef();
    }
    final LDto baseDto = _dtoRef;
    boolean _notEquals = (!Objects.equal(baseDto, null));
    if (_notEquals) {
      final LinkedList<LDto> dtoStack = CollectionLiterals.<LDto>newLinkedList(baseDto);
      BlipHelper.recursiveCompleteBlipItem_DtoPath(results, baseDto.getName(), dtoStack);
    }
    return results;
  }
  
  /**
   * TODO: find a more meaningful solution to find unnecessary recursive dto paths
   */
  private static void recursiveCompleteBlipItem_DtoPath(final List<String> results, final String parentName, final LinkedList<LDto> dtoStack) {
    final String proposal = parentName;
    results.add(proposal);
    final LDto actualDto = dtoStack.getLast();
    LDto previousDto = ((LDto) null);
    int _size = dtoStack.size();
    boolean _greaterThan = (_size > 1);
    if (_greaterThan) {
      int _size_1 = dtoStack.size();
      int _minus = (_size_1 - 2);
      previousDto = dtoStack.get(_minus);
    }
    EList<LDtoFeature> _features = actualDto.getFeatures();
    for (final LDtoFeature feature : _features) {
      {
        LDto referencedDto = ((LDto) null);
        LMultiplicity multiplicity = ((LMultiplicity) null);
        String attributeName = "";
        if ((feature instanceof LDtoReferenceImpl)) {
          referencedDto = ((LDtoReferenceImpl)feature).getType();
          attributeName = ((LDtoReferenceImpl)feature).getName();
          multiplicity = ((LDtoReferenceImpl)feature).getMultiplicity();
        }
        if ((feature instanceof LDtoInheritedReferenceImpl)) {
          referencedDto = ((LDtoInheritedReferenceImpl)feature).getType();
          attributeName = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature().getName();
          multiplicity = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature().getMultiplicity();
        }
        boolean _notEquals = (!Objects.equal(referencedDto, null));
        if (_notEquals) {
          StringConcatenation _builder = new StringConcatenation();
          String _name = actualDto.getName();
          _builder.append(_name);
          _builder.append(".");
          String _name_1 = referencedDto.getName();
          _builder.append(_name_1);
          String lastDtoNames = _builder.toString();
          String[] parentNames = parentName.split("\\.");
          StringConcatenation _builder_1 = new StringConcatenation();
          final String[] _converted_parentNames = (String[])parentNames;
          int _size_2 = ((List<String>)Conversions.doWrapArray(_converted_parentNames)).size();
          int _minus_1 = (_size_2 - 1);
          String _get = parentNames[_minus_1];
          _builder_1.append(_get);
          _builder_1.append(".");
          _builder_1.append(attributeName);
          String lastAttributeNames = _builder_1.toString();
          if ((Objects.equal(previousDto, null) || (!previousDto.getName().equals(referencedDto.getName())))) {
            if ((((!Objects.equal(multiplicity, null)) && (!parentName.contains(lastAttributeNames))) && (!BlipHelper.dtoStackNames(dtoStack).contains(lastDtoNames)))) {
              dtoStack.addLast(referencedDto);
              int _size_3 = dtoStack.size();
              boolean _lessThan = (_size_3 < 32);
              if (_lessThan) {
                StringConcatenation _builder_2 = new StringConcatenation();
                _builder_2.append(parentName);
                _builder_2.append(".");
                _builder_2.append(attributeName);
                BlipHelper.recursiveCompleteBlipItem_DtoPath(results, _builder_2.toString(), dtoStack);
              } else {
                System.err.println("BREAKING recursive inspection of dto references due to meaningful depth!");
              }
              dtoStack.removeLast();
            }
          }
        }
      }
    }
  }
  
  private static String dtoStackNames(final LinkedList<LDto> dtoStack) {
    String names = "";
    final Iterator<LDto> iterator = dtoStack.iterator();
    while (iterator.hasNext()) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append(names);
      _builder.append(".");
      String _name = iterator.next().getName();
      _builder.append(_name);
      names = _builder.toString();
    }
    return names;
  }
}