/**
 * 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.strategy.jvmmodel;

import javax.inject.Inject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.osbp.ecview.extension.api.IFocusingEnhancer;
import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
import org.eclipse.osbp.utils.annotation.CommonUtils;
import org.eclipse.osbp.utils.constants.GeneratorConstants;
import org.eclipse.osbp.xtext.strategy.FocusingEnhancer;
import org.eclipse.osbp.xtext.strategy.FocusingStrategy;
import org.eclipse.osbp.xtext.strategy.StrategyPackage;
import org.eclipse.osbp.xtext.strategy.constants.StrategyConstants;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.common.types.JvmAnnotationReference;
import org.eclipse.xtext.common.types.JvmFormalParameter;
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.JvmTypeReference;
import org.eclipse.xtext.common.types.JvmVisibility;
import org.eclipse.xtext.xbase.compiler.output.ITreeAppendable;
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor;
import org.eclipse.xtext.xbase.jvmmodel.JvmAnnotationReferenceBuilder;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypeReferenceBuilder;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.osgi.service.component.annotations.Component;

@SuppressWarnings("all")
public class StrategyDSLFocusingEnhancerCreator {
  @Inject
  @Extension
  private JvmTypesBuilder _jvmTypesBuilder;
  
  @Inject
  @Extension
  private StrategyConstants _strategyConstants;
  
  @Inject
  @Extension
  private CommonUtils _commonUtils;
  
  private JvmAnnotationReferenceBuilder _annotationTypesBuilder;
  
  private JvmTypeReferenceBuilder _typeReferenceBuilder;
  
  public void createFocusingEnhancer(final StrategyPackage pckg, final FocusingEnhancer focusingEnhancer, final IJvmDeclaredTypeAcceptor acceptor, final JvmAnnotationReferenceBuilder annotationTypesBuilder, final JvmTypeReferenceBuilder typeReferenceBuilder) {
    this.createFocusingEnhancer(pckg, focusingEnhancer, acceptor, annotationTypesBuilder, typeReferenceBuilder, false);
  }
  
  public void createFocusingEnhancer(final StrategyPackage pckg, final FocusingEnhancer focusingEnhancer, final IJvmDeclaredTypeAcceptor acceptor, final JvmAnnotationReferenceBuilder annotationTypesBuilder, final JvmTypeReferenceBuilder typeReferenceBuilder, final boolean osdefault) {
    this._annotationTypesBuilder = annotationTypesBuilder;
    this._typeReferenceBuilder = typeReferenceBuilder;
    StringConcatenation _builder = new StringConcatenation();
    String _name = pckg.getName();
    _builder.append(_name, "");
    _builder.append(".");
    String _strategyClassName = this.getStrategyClassName(focusingEnhancer, osdefault);
    _builder.append(_strategyClassName, "");
    JvmGenericType clsStrategy = this._jvmTypesBuilder.toClass(focusingEnhancer, _builder.toString());
    EList<JvmTypeReference> _superTypes = clsStrategy.getSuperTypes();
    JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(IFocusingEnhancer.class);
    _superTypes.add(_typeRef);
    final Procedure1<JvmGenericType> _function = new Procedure1<JvmGenericType>() {
      public void apply(final JvmGenericType it) {
        StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.setDocumentation(it, GeneratorConstants.GENERATED_CLASSES_DOCUMENTATION);
        JvmAnnotationReference annotationRef = StrategyDSLFocusingEnhancerCreator.this._annotationTypesBuilder.annotationRef(Component.class);
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("ecview.focusing.enhancer.id=");
        String _strategyClassName = StrategyDSLFocusingEnhancerCreator.this.getStrategyClassName(focusingEnhancer, osdefault);
        _builder.append(_strategyClassName, "");
        final String propContent = _builder.toString();
        if (osdefault) {
          String[] propContents = new String[2];
          propContents[0] = propContent;
          propContents[1] = "ecview.focusing.enhancer.default=true";
          StrategyDSLFocusingEnhancerCreator.this._commonUtils.addAnnAttrArr(annotationRef, focusingEnhancer, "property", propContents);
        } else {
          StrategyDSLFocusingEnhancerCreator.this._commonUtils.addAnnAttr(annotationRef, focusingEnhancer, "property", propContent);
        }
        EList<JvmAnnotationReference> _annotations = it.getAnnotations();
        StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
        StrategyDSLFocusingEnhancerCreator.this.toOperations(it, focusingEnhancer);
      }
    };
    acceptor.<JvmGenericType>accept(clsStrategy, _function);
  }
  
  public void toOperations(final JvmGenericType type, final FocusingEnhancer focusingEnhancer) {
    EList<JvmMember> _members = type.getMembers();
    JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(Void.TYPE);
    final Procedure1<JvmOperation> _function = new Procedure1<JvmOperation>() {
      public void apply(final JvmOperation it) {
        EList<JvmAnnotationReference> _annotations = it.getAnnotations();
        JvmAnnotationReference _annotationRef = StrategyDSLFocusingEnhancerCreator.this._annotationTypesBuilder.annotationRef(Override.class);
        StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
        it.setVisibility(JvmVisibility.PUBLIC);
        EList<JvmFormalParameter> _parameters = it.getParameters();
        JvmTypeReference _typeRef = StrategyDSLFocusingEnhancerCreator.this._typeReferenceBuilder.typeRef(YStrategyLayout.class);
        JvmFormalParameter _parameter = StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.toParameter(focusingEnhancer, "yLayout", _typeRef);
        StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        final Procedure1<ITreeAppendable> _function = new Procedure1<ITreeAppendable>() {
          public void apply(final ITreeAppendable it) {
            String _enhanceFocusingBody = StrategyDSLFocusingEnhancerCreator.this.getEnhanceFocusingBody(focusingEnhancer);
            it.append(_enhanceFocusingBody);
          }
        };
        StrategyDSLFocusingEnhancerCreator.this._jvmTypesBuilder.setBody(it, _function);
      }
    };
    JvmOperation _method = this._jvmTypesBuilder.toMethod(focusingEnhancer, "enhanceFocusing", _typeRef, _function);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
  }
  
  public String getEnhanceFocusingBody(final FocusingEnhancer focusingEnhancer) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("yLayout.getFocusingStrategies().clear();");
    String body = _builder.toString();
    int idx = 1;
    EList<FocusingStrategy> _focusingStrategies = focusingEnhancer.getFocusingStrategies();
    for (final FocusingStrategy focusingStrategy : _focusingStrategies) {
      {
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(body, "");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("YDelegatingFocusingStrategy yStgy");
        _builder_1.append(idx, "");
        _builder_1.append(" = YECviewFactory.eINSTANCE.createYDelegatingFocusingStrategy();");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("yStgy");
        _builder_1.append(idx, "");
        _builder_1.append(".setDelegateStrategyId(\"");
        String _ecviewFocusingId = focusingStrategy.getEcviewFocusingId();
        _builder_1.append(_ecviewFocusingId, "");
        _builder_1.append("\");");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("yLayout.getFocusingStrategies().add(yStgy");
        _builder_1.append(idx, "");
        _builder_1.append(");");
        body = _builder_1.toString();
        idx++;
      }
    }
    return body;
  }
  
  public String getStrategyClassName(final FocusingEnhancer focusingEnhancer, final boolean osdefault) {
    CharSequence focusingEnhancerClassName = this.getNotDefaultStrategyClassName(focusingEnhancer);
    if (osdefault) {
      CharSequence _defaultStrategyClassName = this.getDefaultStrategyClassName();
      focusingEnhancerClassName = _defaultStrategyClassName;
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append(focusingEnhancerClassName, "");
    return _builder.toString();
  }
  
  public CharSequence getNotDefaultStrategyClassName(final FocusingEnhancer focusingEnhancer) {
    StringConcatenation _builder = new StringConcatenation();
    String _name = focusingEnhancer.getName();
    _builder.append(_name, "");
    _builder.append(this._strategyConstants.FOCUSING_ENHANCER_PREFIX, "");
    return _builder;
  }
  
  public CharSequence getDefaultStrategyClassName() {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("Default");
    _builder.append(this._strategyConstants.FOCUSING_ENHANCER_PREFIX, "");
    return _builder;
  }
}