/**
 * 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.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.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.text.WordUtils;
import org.eclipse.bpmn2.CallActivity;
import org.eclipse.bpmn2.Event;
import org.eclipse.bpmn2.Gateway;
import org.eclipse.bpmn2.ScriptTask;
import org.eclipse.bpmn2.SequenceFlow;
import org.eclipse.bpmn2.ServiceTask;
import org.eclipse.bpmn2.Task;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.dsl.semantic.common.types.LMultiplicity;
import org.eclipse.osbp.dsl.semantic.common.types.LReference;
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 String name) {
    String recommended = name;
    String _replace = recommended.replace("_", " ");
    recommended = _replace;
    String _replace_1 = recommended.replace("  ", " ");
    recommended = _replace_1;
    String _stripAccents = StringUtils.stripAccents(recommended);
    recommended = _stripAccents;
    String _capitalize = WordUtils.capitalize(recommended);
    recommended = _capitalize;
    String _replace_2 = recommended.replace(" ", "");
    recommended = _replace_2;
    return recommended;
  }
  
  public static String getBpmItemRecommendedName(final BlipItem blipItem) {
    String bpmItemName = "";
    if ((blipItem instanceof BlipEvent)) {
      Event _event = ((BlipEvent)blipItem).getEvent();
      String _name = _event.getName();
      bpmItemName = _name;
    } else {
      if ((blipItem instanceof BlipSplitGateway)) {
        Gateway _gateway = ((BlipSplitGateway)blipItem).getGateway();
        String _name_1 = _gateway.getName();
        bpmItemName = _name_1;
      } else {
        if ((blipItem instanceof BlipUserTask)) {
          Task _task = ((BlipUserTask)blipItem).getTask();
          String _name_2 = _task.getName();
          bpmItemName = _name_2;
        } else {
          if ((blipItem instanceof BlipCallActivity)) {
            CallActivity _callActivity = ((BlipCallActivity)blipItem).getCallActivity();
            String _name_3 = _callActivity.getName();
            bpmItemName = _name_3;
          } else {
            if ((blipItem instanceof BlipScript)) {
              ScriptTask _task_1 = ((BlipScript)blipItem).getTask();
              String _name_4 = _task_1.getName();
              bpmItemName = _name_4;
            } else {
              if ((blipItem instanceof BlipServiceTask)) {
                ServiceTask _task_2 = ((BlipServiceTask)blipItem).getTask();
                String _name_5 = _task_2.getName();
                bpmItemName = _name_5;
              } else {
                if ((blipItem instanceof BlipOutGoing)) {
                  SequenceFlow _sequenceFlow = ((BlipOutGoing)blipItem).getSequenceFlow();
                  String _name_6 = _sequenceFlow.getName();
                  bpmItemName = _name_6;
                }
              }
            }
          }
        }
      }
    }
    return BlipHelper.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();
      }
      String _dtoPath_2 = _dtoPath_1.getDtoPath();
      boolean _isEmpty = _dtoPath_2.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)) {
            String _name = ((LDtoReferenceImpl)feature).getName();
            attributeName = _name;
          }
          if ((feature instanceof LDtoInheritedReferenceImpl)) {
            LReference _inheritedFeature = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature();
            String _name_1 = _inheritedFeature.getName();
            attributeName = _name_1;
          }
          boolean _notEquals_1 = (!Objects.equal(attributeName, null));
          if (_notEquals_1) {
            boolean _and = false;
            boolean _equals = attributeName.equals(dtoChildName);
            if (!_equals) {
              _and = false;
            } else {
              _and = (feature instanceof LDtoAbstractReference);
            }
            if (_and) {
              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;
      boolean _and_1 = false;
      boolean _notEquals = (!Objects.equal(operativeDto, null));
      if (!_notEquals) {
        _and_1 = false;
      } else {
        String _name = operativeDto.getName();
        boolean _notEquals_1 = (!Objects.equal(_name, null));
        _and_1 = _notEquals_1;
      }
      if (!_and_1) {
        _and = false;
      } else {
        String _name_1 = operativeDto.getName();
        BlipDtoPath _dtoPath = null;
        if (blipItem!=null) {
          _dtoPath=blipItem.getDtoPath();
        }
        boolean _equals = _name_1.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_2 = operativeDto.getName();
        String _plus = (_name_2 + ".");
        boolean _startsWith = dtoPath.startsWith(_plus);
        boolean _not_1 = (!_startsWith);
        if (_not_1) {
          return null;
        } else {
          String _name_3 = operativeDto.getName();
          String _plus_1 = (_name_3 + ".");
          int _length = _plus_1.length();
          String _substring = dtoPath.substring(_length);
          dtoPath = _substring;
          final String[] dtoChildNames = dtoPath.split("\\.");
          for (final String dtoChildName : dtoChildNames) {
            LDto _referencedLDto = BlipHelper.getReferencedLDto(operativeDto, dtoChildName);
            operativeDto = _referencedLDto;
          }
        }
      }
      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;
      boolean _and_1 = false;
      boolean _notEquals = (!Objects.equal(operativeDto, null));
      if (!_notEquals) {
        _and_1 = false;
      } else {
        String _name = operativeDto.getName();
        boolean _notEquals_1 = (!Objects.equal(_name, null));
        _and_1 = _notEquals_1;
      }
      if (!_and_1) {
        _and = false;
      } else {
        String _name_1 = operativeDto.getName();
        BlipDtoPath _dtoPath = null;
        if (blipItem!=null) {
          _dtoPath=blipItem.getDtoPath();
        }
        boolean _equals = _name_1.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_2 = operativeDto.getName();
        String _plus = (_name_2 + ".");
        String _replace = _dtoPath_2.replace(_plus, "");
        final String[] dtoChildNames = _replace.split("\\.");
        for (final String dtoChildName : dtoChildNames) {
          {
            LDtoAbstractReference _dtoFeature = BlipHelper.getDtoFeature(operativeDto, dtoChildName);
            dtoFeature = _dtoFeature;
            LDto _referencedLDto = BlipHelper.getReferencedLDto(operativeDto, dtoChildName);
            operativeDto = _referencedLDto;
          }
        }
      }
    }
    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);
      String _name = baseDto.getName();
      BlipHelper.recursiveCompleteBlipItem_DtoPath(results, _name, 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);
      LDto _get = dtoStack.get(_minus);
      previousDto = _get;
    }
    EList<LDtoFeature> _features = actualDto.getFeatures();
    for (final LDtoFeature feature : _features) {
      {
        LDto referencedDto = ((LDto) null);
        LMultiplicity multiplicity = ((LMultiplicity) null);
        String attributeName = "";
        if ((feature instanceof LDtoReferenceImpl)) {
          LDto _type = ((LDtoReferenceImpl)feature).getType();
          referencedDto = _type;
          String _name = ((LDtoReferenceImpl)feature).getName();
          attributeName = _name;
          LMultiplicity _multiplicity = ((LDtoReferenceImpl)feature).getMultiplicity();
          multiplicity = _multiplicity;
        }
        if ((feature instanceof LDtoInheritedReferenceImpl)) {
          LDto _type_1 = ((LDtoInheritedReferenceImpl)feature).getType();
          referencedDto = _type_1;
          LReference _inheritedFeature = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature();
          String _name_1 = _inheritedFeature.getName();
          attributeName = _name_1;
          LReference _inheritedFeature_1 = ((LDtoInheritedReferenceImpl)feature).getInheritedFeature();
          LMultiplicity _multiplicity_1 = _inheritedFeature_1.getMultiplicity();
          multiplicity = _multiplicity_1;
        }
        boolean _notEquals = (!Objects.equal(referencedDto, null));
        if (_notEquals) {
          StringConcatenation _builder = new StringConcatenation();
          String _name_2 = actualDto.getName();
          _builder.append(_name_2, "");
          _builder.append(".");
          String _name_3 = referencedDto.getName();
          _builder.append(_name_3, "");
          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_1 = parentNames[_minus_1];
          _builder_1.append(_get_1, "");
          _builder_1.append(".");
          _builder_1.append(attributeName, "");
          String lastAttributeNames = _builder_1.toString();
          boolean _or = false;
          boolean _equals = Objects.equal(previousDto, null);
          if (_equals) {
            _or = true;
          } else {
            String _name_4 = previousDto.getName();
            String _name_5 = referencedDto.getName();
            boolean _equals_1 = _name_4.equals(_name_5);
            boolean _not = (!_equals_1);
            _or = _not;
          }
          if (_or) {
            boolean _and = false;
            boolean _and_1 = false;
            boolean _notEquals_1 = (!Objects.equal(multiplicity, null));
            if (!_notEquals_1) {
              _and_1 = false;
            } else {
              boolean _contains = parentName.contains(lastAttributeNames);
              boolean _not_1 = (!_contains);
              _and_1 = _not_1;
            }
            if (!_and_1) {
              _and = false;
            } else {
              String _dtoStackNames = BlipHelper.dtoStackNames(dtoStack);
              boolean _contains_1 = _dtoStackNames.contains(lastDtoNames);
              boolean _not_2 = (!_contains_1);
              _and = _not_2;
            }
            if (_and) {
              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(".");
      LDto _next = iterator.next();
      String _name = _next.getName();
      _builder.append(_name, "");
      names = _builder.toString();
    }
    return names;
  }
}