/*
 *                                                                            
 *  Copyright (c) 2011 - 2019 - 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                                 
 *                                                                            
 *  Initial contribution:                                                      
 *     Loetz GmbH & Co. KG                              
 * 
 */
package org.eclipse.osbp.ide.core.ui.builder;

import org.eclipse.osbp.dsl.semantic.common.types.LTypedPackage;
import org.eclipse.osbp.dsl.semantic.dto.LDto;
import org.eclipse.osbp.dsl.semantic.dto.LDtoAttribute;
import org.eclipse.osbp.dsl.semantic.dto.util.NamingConventionsUtil;
import org.eclipse.osbp.dsl.semantic.service.LDTOService;
import org.eclipse.osbp.dsl.semantic.service.LServiceOperation;
import org.eclipse.osbp.dsl.semantic.service.OSBPServiceFactory;
import org.eclipse.osbp.ide.core.ui.builder.OSBPModelEnhancingBuilder.ServiceEnhancer.ServiceEnhancerContext;
import org.eclipse.xtext.common.types.JvmArrayType;
import org.eclipse.xtext.common.types.JvmFormalParameter;
import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference;
import org.eclipse.xtext.common.types.JvmGenericType;
import org.eclipse.xtext.common.types.JvmOperation;
import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
import org.eclipse.xtext.common.types.JvmTypeParameter;
import org.eclipse.xtext.common.types.JvmTypeReference;
import org.eclipse.xtext.common.types.JvmVisibility;
import org.eclipse.xtext.common.types.JvmWildcardTypeReference;
import org.eclipse.xtext.common.types.TypesFactory;
import org.eclipse.xtext.common.types.util.TypeReferences;
import org.eclipse.xtext.naming.IQualifiedNameProvider;
import org.eclipse.xtext.xbase.XAssignment;
import org.eclipse.xtext.xbase.XBinaryOperation;
import org.eclipse.xtext.xbase.XBlockExpression;
import org.eclipse.xtext.xbase.XCastedExpression;
import org.eclipse.xtext.xbase.XFeatureCall;
import org.eclipse.xtext.xbase.XMemberFeatureCall;
import org.eclipse.xtext.xbase.XNumberLiteral;
import org.eclipse.xtext.xbase.XReturnExpression;
import org.eclipse.xtext.xbase.XSetLiteral;
import org.eclipse.xtext.xbase.XStringLiteral;
import org.eclipse.xtext.xbase.XVariableDeclaration;
import org.eclipse.xtext.xbase.XbaseFactory;

/**
 * ServiceEnhancerHelper creates methods in the service model to handle stateClasses.
 */
public class ServiceEnhancerHelper { 
	
	private static final String NUMBER_OF = "numberOfStates";

	private static final String NEXT = "nextState";

	private static final String PREVIOUS = "previousState";

	private static final String ABSTRACT_DTO_SERVICE = "AbstractDTOService";

	private static final String JAVA_LANG = "java.lang";

	private static final String JAVA_LANG_LONG = "java.lang.Long";

	private static final String ORG_ECLIPSE_OSBP_RUNTIME_COMMON_FILTER_IJPQL = "org.eclipse.osbp.runtime.common.filter.IJPQL";

	private static final String JAVA_LANG_OBJECT = "java.lang.Object";

	private static final String JAVA_LANG_STRING = "java.lang.String";

	private static final String ORG_ECLIPSE_OSBP_JPA_SERVICES_JPQL = "org.eclipse.osbp.jpa.services.JPQL";

	/** The Constant ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL. */
	private static final String ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL = "org.eclipse.osbp.dsl.dto.lib.services.impl";

	/** The Constant JAVA_UTIL. */
	private static final String JAVA_UTIL = "java.util";

	/** The Constant ORG_ECLIPSE_XTEXT_XBASE_LIB. */
	private static final String ORG_ECLIPSE_XTEXT_XBASE_LIB = "org.eclipse.xtext.xbase.lib";

	/** The dto name provider. */
	private IQualifiedNameProvider dtoNameProvider;
	
	/** The context. */
	private ServiceEnhancerContext context;
	
	/** The type refs. */
	private TypeReferences typeRefs;

	/**
	 * Instantiates a new service enhancer helper.
	 *
	 * @param dtoNameProvider the dto name provider
	 * @param context the context
	 * @param typeRefs the type refs
	 */
	public ServiceEnhancerHelper(IQualifiedNameProvider dtoNameProvider, ServiceEnhancerContext context, TypeReferences typeRefs) {
		this.dtoNameProvider = dtoNameProvider;
		this.context = context;
		this.typeRefs = typeRefs;
	}

	/**
	 * finds old operation.
	 *
	 * @param lService the l service
	 * @param opName the op name
	 */
	private LServiceOperation findOperation(LDTOService lService, String opName) {
		for(LServiceOperation op : lService.getOperations()) {
			if(opName.equals(op.getName())) {
				return op;
			}
		}
		return null;
	}

	/**
	 * Creates the state class methods.
	 *
	 * @param lService the l service
	 * @param lDto the l dto
	 * @param attribute the attribute
	 */
	public void createStateClassMethods(LDTOService lService, LDto lDto, LDtoAttribute attribute) {
		if(!lService.getOperations().contains(findOperation(lService, NEXT))) {
			lService.getOperations().add(createChangeStateClassMethod(lDto, attribute, NEXT));
		}
		if(!lService.getOperations().contains(findOperation(lService, PREVIOUS))) {
			lService.getOperations().add(createChangeStateClassMethod(lDto, attribute, PREVIOUS));
		}
		if(!lService.getOperations().contains(findOperation(lService, NUMBER_OF))) {
			lService.getOperations().add(createCountStateClassMethod(lService, lDto, attribute, NUMBER_OF));
		}
	}

	/**
	 * Creates the state class methods.
	 *
	 * @param lService the l service
	 * @param lDto the l dto
	 * @param attribute the attribute
	 * @param operationName the method name
	 * @return the l service operation
	 */
	private LServiceOperation createCountStateClassMethod(LDTOService lService, LDto lDto, LDtoAttribute attribute, String operationName) {
		String stateClassPackage = dtoNameProvider.getFullyQualifiedName(attribute.getType()).skipLast(1).toString();
		String stateClassName = dtoNameProvider.getFullyQualifiedName(attribute.getType()).getLastSegment();
		LServiceOperation operation = OSBPServiceFactory.eINSTANCE.createLServiceOperation();
		operation.setName(operationName);

		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para.setName(NamingConventionsUtil.toFirstLower(stateClassName));
		para.setParameterType(typeRefs.getTypeForName(JAVA_LANG_OBJECT, context.serviceResource));
		operation.getParams().add(para);

		XBlockExpression xBlock = XbaseFactory.eINSTANCE.createXBlockExpression();
		
		XVariableDeclaration query = createQueryVariable(lDto, attribute, stateClassPackage, stateClassName);
		xBlock.getExpressions().add(query);
		XVariableDeclaration result = createResultVariable(lService, lDto, query);
		xBlock.getExpressions().add(result);
		xBlock.getExpressions().add(createCountReturnStatement(result));
		
		operation.setBody(xBlock);
		operation.setType(typeRefs.getTypeForName(JAVA_LANG_LONG, context.serviceResource));
		return operation;
	}

	/**
	 * Creates the change state class method.
	 *
	 * @param lService the l service
	 * @param lDto the l dto
	 * @param attribute the attribute
	 * @param operationName the method name
	 * @return the l service operation
	 */
	private LServiceOperation createChangeStateClassMethod(LDto lDto, LDtoAttribute attribute, String operationName) {
		String stateClassPackage = dtoNameProvider.getFullyQualifiedName(attribute.getType()).skipLast(1).toString();
		String stateClassName = dtoNameProvider.getFullyQualifiedName(attribute.getType()).getLastSegment();
		String dtoPackage = dtoNameProvider.getFullyQualifiedName(lDto).skipLast(1).toString();
		String dtoName = lDto.getName();
		LServiceOperation operation = OSBPServiceFactory.eINSTANCE.createLServiceOperation();
		operation.setName(operationName);
		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para.setName(NamingConventionsUtil.toFirstLower(lDto.getName()));
		para.setParameterType(typeRefs.getTypeForName(JAVA_LANG_OBJECT, context.serviceResource));
		operation.getParams().add(para);
		XBlockExpression xBlock = XbaseFactory.eINSTANCE.createXBlockExpression();
		
		XVariableDeclaration values = createValuesVariable(stateClassPackage, stateClassName);
		xBlock.getExpressions().add(values);
		XVariableDeclaration ordinal = createOrdinalVariable(attribute, dtoPackage, dtoName, stateClassPackage, stateClassName);
		xBlock.getExpressions().add(ordinal);
		if(NEXT.equals(operationName)) {
			xBlock.getExpressions().add(createOrdinalAssignment(ordinal, "operator_plus"));
		}
		if(PREVIOUS.equals(operationName)) {
			xBlock.getExpressions().add(createOrdinalAssignment(ordinal, "operator_minus"));
		}
		xBlock.getExpressions().add(createStateAssignment(attribute, dtoPackage, dtoName,
				stateClassPackage, stateClassName, values, ordinal));
		xBlock.getExpressions().add(createUpdate(dtoPackage, dtoName));
		
		operation.setBody(xBlock);
		operation.setType(typeRefs.getTypeForName(Void.TYPE, context.serviceResource));
		return operation;
	}

	/**
	 * Creates the query variable.
	 *
	 * @param dto the dto
	 * @param attribute the attribute
	 * @param stateClassPackage the state class package
	 * @param stateClassName the state class name
	 * @return the x variable declaration
	 */
	private XVariableDeclaration createQueryVariable(LDto dto, LDtoAttribute attribute,	String stateClassPackage, String stateClassName) {
		// val query
		XVariableDeclaration varDecl = XbaseFactory.eINSTANCE.createXVariableDeclaration();
		varDecl.setName("query");
		varDecl.setWriteable(true);
		
		// right
		XFeatureCall right = XbaseFactory.eINSTANCE.createXFeatureCall();
		
		// feature(right)
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType dtoServiceType = TypesFactory.eINSTANCE.createJvmGenericType();
		dtoServiceType.setPackageName(ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL);
		dtoServiceType.setSimpleName(ABSTRACT_DTO_SERVICE);
		oper.setDeclaringType(dtoServiceType);
		oper.setSimpleName("createJPQL");
		oper.setReturnType(typeRefs.getTypeForName(ORG_ECLIPSE_OSBP_JPA_SERVICES_JPQL, context.serviceResource));
		
		// parameters(feature(right))
		JvmFormalParameter para1 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para1.setParameterType(typeRefs.getTypeForName(JAVA_LANG_STRING, context.serviceResource));
		oper.getParameters().add(para1);
		JvmFormalParameter para2 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		JvmParameterizedTypeReference ptr = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setPackageName(JAVA_UTIL);
		gt.setSimpleName("Map");
		ptr.setType(gt);
		ptr.getArguments().add(typeRefs.getTypeForName(JAVA_LANG_STRING, context.serviceResource));
		ptr.getArguments().add(typeRefs.getTypeForName(JAVA_LANG_OBJECT, context.serviceResource));
		para2.setParameterType(ptr);
		oper.getParameters().add(para2);
		right.setFeature(oper);
		// feature(right) end
		
		// featureCallArguments(right)
		// first element
		XStringLiteral queryString = XbaseFactory.eINSTANCE.createXStringLiteral();
		queryString.setValue(String.format("select count(t) from %s t where t.%s = :%s", dto.getWrappedType().getName(), attribute.getName(), "StateClass"+stateClassName));
		right.getFeatureCallArguments().add(queryString);
		// second element
		XSetLiteral set = XbaseFactory.eINSTANCE.createXSetLiteral();
		// binary operation(second element)
		XBinaryOperation binOp = XbaseFactory.eINSTANCE.createXBinaryOperation();
		// left operand(binary operation(second element))
		XStringLiteral left2 = XbaseFactory.eINSTANCE.createXStringLiteral();
		left2.setValue("StateClass"+stateClassName);
		binOp.setLeftOperand(left2);
		// right operand(binary operation(second element))
		XFeatureCall right2 = XbaseFactory.eINSTANCE.createXFeatureCall();
		// feature(right operand(binary operation(second element)))
		JvmFormalParameter para5 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para5.setName(NamingConventionsUtil.toFirstLower(stateClassName));
		para5.setParameterType(typeRefs.getTypeForName(JAVA_LANG_OBJECT, context.serviceResource));
		right2.setFeature(para5);
		binOp.setRightOperand(right2);
		// right operand end
		
		// feature(binary operation(second element)))
		JvmOperation mapOperation = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType mapType = TypesFactory.eINSTANCE.createJvmGenericType();
		mapType.setPackageName(ORG_ECLIPSE_XTEXT_XBASE_LIB);
		mapType.setSimpleName("ObjectExtensions");
		mapOperation.setDeclaringType(mapType);
		mapOperation.setSimpleName("operator_mappedTo");
		mapOperation.setDeprecated(false);
		mapOperation.setVisibility(JvmVisibility.PUBLIC);
		mapOperation.setStatic(true);
		// parameter1(feature(binary operation(second element))))
		JvmFormalParameter para3 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para3.setParameterType(createObjectType("A"));
		mapOperation.getParameters().add(para3);
		// parameter2(feature(binary operation(second element))))
		JvmFormalParameter para4 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para4.setParameterType(createObjectType("B"));
		mapOperation.getParameters().add(para4);
		// return type(feature(binary operation(second element))))
		JvmParameterizedTypeReference retType = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		// arguments(return type(feature(binary operation(second element)))))
		retType.getArguments().add(createObjectType("A"));
		retType.getArguments().add(createObjectType("B"));
		// type(return type(feature(binary operation(second element)))))
		JvmGenericType gt1 = TypesFactory.eINSTANCE.createJvmGenericType();
		gt1.setPackageName(ORG_ECLIPSE_XTEXT_XBASE_LIB);
		gt1.setSimpleName("Pair");
		// type parameters(type(return type(feature(binary operation(second element))))))
		JvmTypeParameter tp1 = TypesFactory.eINSTANCE.createJvmTypeParameter();
		tp1.setName("K");
		gt1.getTypeParameters().add(tp1);
		JvmTypeParameter tp2 = TypesFactory.eINSTANCE.createJvmTypeParameter();
		tp2.setName("V");
		gt1.getTypeParameters().add(tp2);
		retType.setType(gt1);
		// return type end 
		mapOperation.setReturnType(retType);
		binOp.setFeature(mapOperation);
		// binary operation end
		set.getElements().add(binOp);
		right.getFeatureCallArguments().add(set);
		right.setExplicitOperationCall(true);
		varDecl.setRight(right);
		return varDecl;
	}

	/**
	 * Creates the result variable.
	 *
	 * @param lService the l service
	 * @param dto the dto
	 * @param query the query
	 * @return the x variable declaration
	 */
	private XVariableDeclaration createResultVariable(LDTOService lService, LDto dto, XVariableDeclaration query) {
		// val result
		XVariableDeclaration varDecl = XbaseFactory.eINSTANCE.createXVariableDeclaration();
		varDecl.setName("result");
		varDecl.setWriteable(true);

		// right
		XMemberFeatureCall right = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		
		// feature(right)
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType dtoServiceType = TypesFactory.eINSTANCE.createJvmGenericType();
		dtoServiceType.setPackageName(ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL);
		dtoServiceType.setSimpleName(ABSTRACT_DTO_SERVICE);
		oper.setDeclaringType(dtoServiceType);
		oper.setSimpleName("findValues");
		// return type(feature(right))
		// arguments(return type(feature(right)))
		JvmParameterizedTypeReference retType = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		JvmWildcardTypeReference wildCard = TypesFactory.eINSTANCE.createJvmWildcardTypeReference();
		retType.getArguments().add(wildCard);
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setPackageName(JAVA_UTIL);
		gt.setSimpleName("List");
		retType.setType(gt);
		oper.setReturnType(retType);
		oper.setVisibility(JvmVisibility.PUBLIC);
		
		// parameters(feature(right))
		JvmFormalParameter para1 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para1.setParameterType(typeRefs.getTypeForName(ORG_ECLIPSE_OSBP_RUNTIME_COMMON_FILTER_IJPQL, context.serviceResource));
		oper.getParameters().add(para1);
		right.setFeature(oper);
		// feature(right) end
		
		// member call arguments(right)
		XFeatureCall fCallArg = XbaseFactory.eINSTANCE.createXFeatureCall();
		fCallArg.setFeature(query);
		right.getMemberCallArguments().add(fCallArg);
		
		// member call target(right)
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		JvmGenericType thiz = TypesFactory.eINSTANCE.createJvmGenericType();
		thiz.setPackageName(getServicePackageName(dto));
		thiz.setSimpleName(lService.getName());
		thiz.setVisibility(JvmVisibility.PUBLIC);
		
		fCall.setFeature(thiz);
		right.setMemberCallTarget(fCall);
		
		right.setExplicitOperationCall(true);
		varDecl.setRight(right);
		return varDecl;
	}

	/**
	 * Creates the count return statement.
	 *
	 * @param result the result
	 * @return the x return expression
	 */
	private XReturnExpression createCountReturnStatement(XVariableDeclaration result) {
		XReturnExpression xReturn = XbaseFactory.eINSTANCE.createXReturnExpression();
		XCastedExpression xCasted = XbaseFactory.eINSTANCE.createXCastedExpression();

		XMemberFeatureCall target = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setPackageName(JAVA_UTIL);
		gt.setSimpleName("List");
		oper.setDeclaringType(gt);
		oper.setSimpleName("get");
		oper.setReturnType(createObjectType("E"));
		oper.setVisibility(JvmVisibility.PUBLIC);
		oper.setAbstract(true);

		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para.setParameterType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		oper.getParameters().add(para);
		target.setFeature(oper);
		target.setExplicitOperationCall(true);
		
		XNumberLiteral index = XbaseFactory.eINSTANCE.createXNumberLiteral();
		index.setValue("00");
		target.getMemberCallArguments().add(index);
		
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		fCall.setFeature(result);
		target.setMemberCallTarget(fCall);
		
		xCasted.setTarget(target);
		xCasted.setType(typeRefs.getTypeForName(JAVA_LANG_LONG, context.serviceResource));
		xReturn.setExpression(xCasted);
		return xReturn;
	}
	
	/**
	 * Creates the values variable.
	 *
	 * @param stateClassPackage the state class package
	 * @param stateClassName the state class name
	 * @return the x variable declaration
	 * var values = Idee.values
	 */
	private XVariableDeclaration createValuesVariable(String stateClassPackage, String stateClassName) {
		XVariableDeclaration varDecl = XbaseFactory.eINSTANCE.createXVariableDeclaration();
		varDecl.setName("values");
		varDecl.setWriteable(true);
		XMemberFeatureCall right = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType stateClassType = TypesFactory.eINSTANCE.createJvmGenericType();
		stateClassType.setPackageName(stateClassPackage);
		stateClassType.setSimpleName(stateClassName);
		oper.setDeclaringType(stateClassType);
		oper.setSimpleName("values");
		JvmTypeReference stateClassTypeRef = typeRefs.getTypeForName(stateClassPackage+"."+stateClassName, context.serviceResource);
		JvmGenericArrayTypeReference arrayType = typeRefs.createArrayType(stateClassTypeRef);
		oper.setReturnType(arrayType);
		right.setFeature(oper);
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		JvmGenericType fCallType = TypesFactory.eINSTANCE.createJvmGenericType();
		fCallType.setSimpleName(stateClassName);
		fCallType.setPackageName(stateClassPackage);
		fCall.setFeature(fCallType);
		fCall.setTypeLiteral(true);
		right.setMemberCallTarget(fCall);
		varDecl.setRight(right);
		return varDecl;
	}

	/**
	 * Creates the ordinal variable.
	 *
	 * @param attribute the attribute
	 * @param dtoPackage the dto package
	 * @param dtoName the dto name
	 * @param stateClassPackage the state class package
	 * @param stateClassName the state class name
	 * @return the x variable declaration
	 * var ordinal = testEntityDto.idee.ordinal
	 */
	private XVariableDeclaration createOrdinalVariable(LDtoAttribute attribute, String dtoPackage, String dtoName, String stateClassPackage, String stateClassName) {
		XVariableDeclaration varDecl = XbaseFactory.eINSTANCE.createXVariableDeclaration();
		varDecl.setName("ordinal");
		varDecl.setWriteable(true);
		XMemberFeatureCall right = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		right.setFeature(createOrdinalOperation());
		right.setNullSafe(true);
		XMemberFeatureCall mfCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		JvmOperation oper2 = TypesFactory.eINSTANCE.createJvmOperation();
		oper2.setSimpleName(attribute.getName());
		oper2.setReturnType(typeRefs.getTypeForName(stateClassPackage+"."+stateClassName, context.serviceResource));
		oper2.setVisibility(JvmVisibility.PUBLIC);
		mfCall.setFeature(oper2);

		XCastedExpression casted = XbaseFactory.eINSTANCE.createXCastedExpression();
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para.setName(NamingConventionsUtil.toFirstLower(dtoName));
		para.setParameterType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		fCall.setFeature(para);
		casted.setTarget(fCall);
		casted.setType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		
		mfCall.setMemberCallTarget(casted);

		right.setMemberCallTarget(mfCall);
		varDecl.setRight(right);
		return varDecl;
	}

	/**
	 * Creates the ordinal assignment.
	 *
	 * @param ordinal the ordinal
	 * @param operator the operator
	 * @return the x assignment
	 * ordinal = ordinal + 01
	 */
	private XAssignment createOrdinalAssignment(XVariableDeclaration ordinal, String operator) {
		XAssignment xAssign = XbaseFactory.eINSTANCE.createXAssignment();
		
		xAssign.setFeature(ordinal);

		XBinaryOperation binOp = XbaseFactory.eINSTANCE.createXBinaryOperation();

		XFeatureCall left = XbaseFactory.eINSTANCE.createXFeatureCall();
		left.setFeature(ordinal);
		binOp.setLeftOperand(left);
		
		XNumberLiteral right = XbaseFactory.eINSTANCE.createXNumberLiteral();
		right.setValue("01");
		binOp.setRightOperand(right);

		JvmOperation plusOperation = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType plusType = TypesFactory.eINSTANCE.createJvmGenericType();
		plusType.setPackageName(ORG_ECLIPSE_XTEXT_XBASE_LIB);
		plusType.setSimpleName("IntegerExtensions");
		plusOperation.setDeclaringType(plusType);
		plusOperation.setSimpleName(operator);
		plusOperation.setDeprecated(false);
		plusOperation.setVisibility(JvmVisibility.PUBLIC);
		plusOperation.setStatic(true);

		JvmFormalParameter para1 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para1.setParameterType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		plusOperation.getParameters().add(para1);
		JvmFormalParameter para2 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para2.setParameterType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		plusOperation.getParameters().add(para2);

		plusOperation.setReturnType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		binOp.setFeature(plusOperation);

		xAssign.setValue(binOp);
		return xAssign;
	}

	/**
	 * Creates the state assignment.
	 *
	 * @param attribute the attribute
	 * @param dtoPackage the dto package
	 * @param dtoName the dto name
	 * @param stateClassPackage the state class package
	 * @param stateClassName the state class name
	 * @param values the values
	 * @param ordinal the ordinal
	 * @return the x assignment
	 * testEntityDto.idee = values.get( ordinal )
	 */
	private XAssignment createStateAssignment(LDtoAttribute attribute, String dtoPackage, String dtoName, String stateClassPackage, String stateClassName,
			XVariableDeclaration values, XVariableDeclaration ordinal) {
		XAssignment xAssign = XbaseFactory.eINSTANCE.createXAssignment();
		JvmOperation setterOperation = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType dtoType = TypesFactory.eINSTANCE.createJvmGenericType();
		dtoType.setPackageName(dtoPackage);
		dtoType.setSimpleName(dtoName);
		setterOperation.setDeclaringType(dtoType);
		setterOperation.setSimpleName("set" + NamingConventionsUtil.toFirstUpper(attribute.getName()));
		setterOperation.setReturnType(typeRefs.getTypeForName(Void.TYPE, context.serviceResource));
		setterOperation.setVisibility(JvmVisibility.PUBLIC);
		JvmFormalParameter para3 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para3.setName(attribute.getName());
		JvmParameterizedTypeReference tr = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		tr.setType(typeRefs.getTypeForName(stateClassPackage+"."+stateClassName, context.serviceResource).getType());
		para3.setParameterType(tr);
		setterOperation.getParameters().add(para3);
		xAssign.setFeature(setterOperation);

		XCastedExpression casted = XbaseFactory.eINSTANCE.createXCastedExpression();
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para.setName(NamingConventionsUtil.toFirstLower(dtoName));
		para.setParameterType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		fCall.setFeature(para);
		casted.setTarget(fCall);
		casted.setType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		
		xAssign.setAssignable(casted);
		
		XMemberFeatureCall mfCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		JvmOperation getterOperation = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType getType = TypesFactory.eINSTANCE.createJvmGenericType();
		getType.setPackageName(ORG_ECLIPSE_XTEXT_XBASE_LIB);
		getType.setSimpleName("ArrayExtensions");
		getterOperation.setDeclaringType(getType);
		getterOperation.setSimpleName("get");
		getterOperation.setDeprecated(false);
		getterOperation.setVisibility(JvmVisibility.PUBLIC);
		getterOperation.setStatic(true);

		JvmArrayType arrayType = TypesFactory.eINSTANCE.createJvmArrayType();
		JvmTypeParameter tp = TypesFactory.eINSTANCE.createJvmTypeParameter();
		tp.setName("T");
		tp.setArrayType(arrayType);

		getterOperation.getTypeParameters().add(tp);

		JvmFormalParameter para1 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		JvmParameterizedTypeReference ptr = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setSimpleName("T");
		ptr.setType(gt);
		JvmGenericArrayTypeReference arrayTypeRef = typeRefs.createArrayType(ptr);
		para1.setParameterType(arrayTypeRef);
		getterOperation.getParameters().add(para1);
		JvmFormalParameter para2 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para2.setParameterType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		getterOperation.getParameters().add(para2);
		getterOperation.setReturnType(typeRefs.getTypeForName(stateClassPackage+"."+stateClassName, context.serviceResource));
		mfCall.setFeature(getterOperation);
		mfCall.setExplicitOperationCall(true);

		XFeatureCall callTarget = XbaseFactory.eINSTANCE.createXFeatureCall();
		callTarget.setFeature(values);
		mfCall.setMemberCallTarget(callTarget);

		XFeatureCall callArgument = XbaseFactory.eINSTANCE.createXFeatureCall();
		callArgument.setFeature(ordinal);
		mfCall.getMemberCallArguments().add(callArgument);

		xAssign.setValue(mfCall);
		return xAssign;
	}

	private XMemberFeatureCall createUpdate(String dtoPackage, String dtoName) {
		XMemberFeatureCall update = XbaseFactory.eINSTANCE.createXMemberFeatureCall();
		update.setExplicitOperationCall(true);

		// feature
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		JvmGenericType dtoServiceType = TypesFactory.eINSTANCE.createJvmGenericType();
		dtoServiceType.setPackageName(ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL);
		dtoServiceType.setSimpleName(ABSTRACT_DTO_SERVICE);
		oper.setDeclaringType(dtoServiceType);
		oper.setSimpleName("update");
		oper.setReturnType(typeRefs.getTypeForName(Void.TYPE, context.serviceResource));
		oper.setVisibility(JvmVisibility.PUBLIC);
		
		// parameters(feature)
		JvmFormalParameter para = TypesFactory.eINSTANCE.createJvmFormalParameter();
		JvmParameterizedTypeReference paraType = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		JvmTypeParameter tp = TypesFactory.eINSTANCE.createJvmTypeParameter();
		tp.setName("DTO");
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setPackageName(ORG_ECLIPSE_OSBP_DSL_DTO_LIB_SERVICES_IMPL);
		gt.setSimpleName(ABSTRACT_DTO_SERVICE);
		tp.setDeclarator(gt);
		paraType.setType(tp);
		para.setParameterType(paraType);
		oper.getParameters().add(para);
		
		// memberCallTarget
		XCastedExpression casted = XbaseFactory.eINSTANCE.createXCastedExpression();
		XFeatureCall fCall = XbaseFactory.eINSTANCE.createXFeatureCall();
		JvmFormalParameter para2 = TypesFactory.eINSTANCE.createJvmFormalParameter();
		para2.setName(NamingConventionsUtil.toFirstLower(dtoName));
		para2.setParameterType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		fCall.setFeature(para2);
		casted.setTarget(fCall);
		casted.setType(typeRefs.getTypeForName(dtoPackage+"."+dtoName, context.serviceResource));
		update.setMemberCallTarget(casted);

		update.setFeature(oper);
		
		return update;
	}

	/**
	 * Creates a named object type reference.
	 *
	 * @param name the name
	 * @return the jvm formal parameter
	 */
	private JvmParameterizedTypeReference createObjectType(String name) {
		JvmParameterizedTypeReference paraType = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
		JvmTypeParameter tp = TypesFactory.eINSTANCE.createJvmTypeParameter();
		JvmGenericType gt = TypesFactory.eINSTANCE.createJvmGenericType();
		gt.setPackageName(JAVA_LANG);
		gt.setSimpleName("Object");
		tp.setDeclarator(gt);
		tp.setName(name);
		paraType.setType(tp);
		return paraType;
	}

	/**
	 * Creates the ordinal operation of an enum.
	 * -> currently not used
	 * @return the JvmOperation
	 */
	private JvmOperation createOrdinalOperation() {
		JvmOperation oper = TypesFactory.eINSTANCE.createJvmOperation();
		oper.setSimpleName("ordinal");
		JvmGenericType enumType = TypesFactory.eINSTANCE.createJvmGenericType();
		enumType.setPackageName(JAVA_LANG);
		enumType.setSimpleName("Enum");
		oper.setDeclaringType(enumType);
		oper.setReturnType(typeRefs.getTypeForName(Integer.TYPE, context.serviceResource));
		oper.setVisibility(JvmVisibility.PUBLIC);
		oper.setFinal(true);
		return oper;
	}

	/**
	 * Gets the service package name.
	 *
	 * @param lDto the dto
	 * @return the service package name
	 */
	public String getServicePackageName(LDto lDto) {
		LTypedPackage lSourceTypePkg = (LTypedPackage) lDto.eContainer();
		return lSourceTypePkg.getName() + ".service";
	}
}