/*******************************************************************************
 * Copyright (c) 2017 CEA LIST
 * 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:
 *     Imen BOUDHIBA (CEA LIST) imen.boudhiba@cea.fr - initial API and implementation
 *******************************************************************************/
package org.eclipse.efm.modeling.codegen.xlia.core;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

//import org.eclipse.efm.modeling.codegen.xlia.datatype.DataTypeCodeGenerator;

import org.eclipse.efm.modeling.codegen.xlia.util.PrettyPrintWriter;
import org.eclipse.efm.modeling.codegen.xlia.util.StatemachineContext;
import org.eclipse.efm.modeling.codegen.xlia.util.StatemachineContext.CONTEXT;
import org.eclipse.efm.modeling.codegen.xlia.util.UmlFactory;
import org.eclipse.emf.common.util.EList;
import org.eclipse.uml2.uml.Behavior;
import org.eclipse.uml2.uml.BehaviorExecutionSpecification;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.CombinedFragment;
import org.eclipse.uml2.uml.ConnectableElement;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.DataType;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.ExecutionOccurrenceSpecification;
import org.eclipse.uml2.uml.FunctionBehavior;
import org.eclipse.uml2.uml.Gate;
import org.eclipse.uml2.uml.Interaction;
import org.eclipse.uml2.uml.InteractionConstraint;
import org.eclipse.uml2.uml.InteractionFragment;
import org.eclipse.uml2.uml.InteractionOperand;
import org.eclipse.uml2.uml.Lifeline;
import org.eclipse.uml2.uml.Message;
import org.eclipse.uml2.uml.MessageOccurrenceSpecification;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.OpaqueExpression;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Signal;
import org.eclipse.uml2.uml.State;
import org.eclipse.uml2.uml.TimeObservation;
import org.eclipse.uml2.uml.Transition;
import org.eclipse.uml2.uml.ValueSpecification;

//import com.cea.aide.core.factory.Creator;
//import com.cea.aide.core.form.Verbatim;


public class InteractionCodeGenerator extends AbstractCodeGenerator {

	/**
	 * Constructor
	 */
	public InteractionCodeGenerator(MainCodeGenerator supervisor) {
		super(supervisor);
	}


	/**
	 * performTransform dispatcher for any element to a writer
	 * @param element
	 * @param writer
	 */
	public void performTransformImpl(Element element, PrettyPrintWriter writer) {
		if( element instanceof Interaction ) {
			transformInteraction((Interaction)element, writer);
		}

		else if( element instanceof Lifeline ) {
			transformLifeline((Lifeline)element, writer);
		}

		else if( element instanceof InteractionFragment )
		{
			if( element instanceof InteractionOperand ) {
				transformFragment((InteractionOperand)element, writer);
			}

			else if( element instanceof CombinedFragment ) {
				transformFragment((CombinedFragment)element, writer);
			}

//			else if( element instanceof ExecutionSpecification )
//			{
				if( element instanceof BehaviorExecutionSpecification ) {
					transformFragment(
							(BehaviorExecutionSpecification)element, writer);
				}
//			}

//			else if( element instanceof OccurrenceSpecification )
//			{
				if( element instanceof MessageOccurrenceSpecification ) {
					transformFragment(
							(MessageOccurrenceSpecification)element, writer);
				}
//			}
		}

		else if( element instanceof Message ) {
			transformMessage((Message)element, null, writer);
		}

		else {
			performTransformError(this, element);
		}
	}




	public void declareSignalMessageType(Signal signal, PrettyPrintWriter writer) {
	    writer.appendTab2("type ")
	        .append(signal.getName())
	        .appendEol(" struct {");
	        writer.appendTab3("var ")
            .appendEol( "string signature;" );

	    for (Property property : signal.getAllAttributes()) {
	        writer.appendTab3("var ")
	            .append( fSupervisor.fDataTypeFactory.typeName(property) )
	            .append(" ")
	            .append(property.getName())
	            .appendEol(";");
	    }

		writer.appendTab2Eol("}");
	}


	/**
	 * Lifeline Projection of dedicated Fragment Util
	 * @param lifeline
	 * @param fragments
	 * @return
	 */
	private ArrayList<InteractionFragment> coveredFragments(
			Lifeline lifeline, List<InteractionFragment> fragments) {
		ArrayList<InteractionFragment> coveredFragmentList = new ArrayList<InteractionFragment>();

		for( InteractionFragment iFragment : fragments ) {
			if (iFragment.getCovereds().contains(lifeline)) {
				if( !( iFragment instanceof ExecutionOccurrenceSpecification) ) {
					coveredFragmentList.add(iFragment);
				}
			}
		}

		return coveredFragmentList;
	}


	/**
	 * performTransform an Interaction element to a writer
	 * @param element
	 * @param writer
	 */
	public void transformInteraction(Interaction element, Collection<Lifeline> lifelines,
			StatemachineContext lfContext, PrettyPrintWriter writer) {

		writer.appendTabEol2(ClassCodeGenerator.XLIA_SYSTEM_1_0);

		writer.appendTab("system< and > ")
			.append(element.getName())
			.appendEol(" {");

		ArrayList<DataType> datatypes = new ArrayList<DataType>();
		ArrayList<Signal> signals = new ArrayList<Signal>();
		fSupervisor.fClassFactory.collectGlobalElement(element, datatypes, signals);

		PrettyPrintWriter writer2 = writer.itab2();

		Map<NamedElement, Boolean> declaredSignatures = new HashMap<NamedElement, Boolean>();
		writer.appendEol("@property: ");
		writer.appendTabEol("// GLOBAL DATA TYPES");
		for (DataType datatype : datatypes) {
			fSupervisor.fDataTypeFactory.performTransformImpl(datatype, writer2);
		}

//		for( Lifeline lifeline : lifelines ) {
//			ConnectableElement representedClass = lifeline.getRepresents();
//			if( representedClass instanceof Property ) {
//				Class clazz = (Class) (((Property)representedClass).getType());
//
//				for( Classifier classifier : clazz.getNestedClassifiers() ) {
//					if( classifier instanceof DataType ) {
//						if( ! classifier.getRedefinedClassifiers().isEmpty() ) {
//							writer.appendTab("type ").append(classifier.getName()).append(' ');
//
//							for (Classifier redefClassifier : classifier.getRedefinedClassifiers()) {
//								if( redefClassifier instanceof Type ) {
//									writer.append(typeName((Type)redefClassifier));
//									break;
//								}
//							}
//							writer.appendEol(";");
//						}
//					}
//				}
//			}
//		}


		writer.appendTabEol("// message");
		for( Message message : element.getMessages() ) {
			//declare signal structure
			NamedElement signature = message.getSignature();
			if( (signature instanceof Signal) && (declaredSignatures.get(signature) == null) ) {
				declaredSignatures.put(signature, Boolean.TRUE);

				if( ! ((Signal) signature).getAllAttributes().isEmpty() ) {
					declareSignalMessageType((Signal) signature, writer);
				}
			}
			// declare message
			//writer.appendTab2("message ") // TODO modif until Diversity support
			writer.appendTab2("signal ")
				.append(message.getName());

			if( (signature instanceof Signal)
				&& (! ((Signal) signature).getAllAttributes().isEmpty()) ) {
				writer.append("( " )
					.append(signature.getName())
					.append(" )");
			}

			writer.appendEol(";");
		}
		writer.appendTabEol("// end message");

		//function signatures vector
		writer.appendTabEol("// function signatures vector");
//		writer.appendTab2Eol("type FontionSignature struct {");
//		writer.appendTab3Eol("var string name;");
//		writer.appendTab3Eol("var string signature;");
//		writer.appendTab2Eol("}");

		writer.appendTab2Eol("public var vector<FonctionSignature> AllSignatures = {");
		for( Lifeline lifeline : lifelines ) {
			ConnectableElement representedClass = lifeline.getRepresents();
			if( representedClass instanceof Property ) {
				Class clazz = (Class) (((Property)representedClass).getType());

				for (int j = 0; j < clazz.getOperations().size(); j++ ) {
					Operation operation = clazz.getOperations().get(j);
					writer.appendTab3("{ \"").append(operation.getName()).append("\" , \"")
					.append(fSupervisor.fDataTypeFactory.typeName( operation.getReturnResult().getType()))
					.append(" ").append(operation.getName()).append("(");

					for(int i = 0; i < operation.getOwnedParameters().size()-1; i++){
						Parameter param = operation.getOwnedParameters().get(i);
						writer.append( fSupervisor.fDataTypeFactory.typeName(param.getType()) //param.getType().getName() //
								).append(" ").append(param.getName());
						if(i < operation.getOwnedParameters().size()-2 ){
						writer.append(", ");
						}
					}

					writer.append(")\" }");
					if(j < clazz.getOperations().size()-1 ){
						writer.appendEol(", ");
					}
				}


//				clazz.getOperations();
//				for (Operation operation : clazz.getOperations()) {
//					writer.appendTab3("{ \"").append(operation.getName()).append("\" , \"")
//					.append(operation.getReturnResult().getType().getName())
//					.append(" ").append(operation.getName()).append("(");
//					//int i=0;
//
//					for(int i = 0; i < operation.getOwnedParameters().size()-1; i++){
//						Parameter param = operation.getOwnedParameters().get(i);
//						writer.append(param.getType().getName()).append(" ").append(param.getName());
//						if(i < operation.getOwnedParameters().size()-2 ){
//						writer.append(", ");
//						}
//					}
//					writer.appendEol(")\" }");
//				}
			}
		}

		writer.appendTab2Eol("};");

		//function calls vectors
		writer.appendTabEol("// function calls vectors");
//		writer.appendTab2Eol("type CallStack struct {");
//		writer.appendTab3Eol("var string ID;");
//		writer.appendTab3Eol("var string PRE;");
//		writer.appendTab3Eol("var vector CALL;");
//		writer.appendTab3Eol("var string POST;");
//		writer.appendTab3Eol("var string INV;");
//		writer.appendTab2Eol("}");

		writer.appendTab2Eol("var integer callIndex = -1;");
		writer.appendTab2Eol("public var vector<CallData> AllCallsStack;");
		writer.appendTab2Eol("public var CallData currentCall;");

		writer.appendTab2Eol("public var vector EMPTY_VECTOR;");
		writer.appendTab2Eol("public const CallData EMPTY_CALL = { \"\" , \"\" , EMPTY_VECTOR , \"\" , \"\" };");
//		writer.appendTab2Eol("public var vector globalProgramCallset;");
//		writer.appendTab2Eol("public var vector globalProgramTrace;");
//		writer.appendTab2Eol("public var vector globalTypeParamCalls;");
//		writer.appendTab2Eol("public var vector globalAssertion;");
		writer.appendTabEol("// end function calls vectors");


		writer.appendEol("@composite: ");

		for( Lifeline alifeline : lifelines ) {

			transformWriteLifeline(alifeline, lfContext, writer2);
		}

		// Section moe
		//
		writer.appendEolTab_Eol("@moe:");
		// Section irun

		writer.appendTab2Eol("@irun{");
		writer.appendTab3Eol("currentCall = EMPTY_CALL;");
		writer.appendTab2Eol2("}");


		//route fifo | env messages

		String routeProtocol = (lifelines.size() < 2) ? "env" : "fifo";

		writer.appendEol("@com: ");
		writer.appendTabEol("// route: message fifo");
		for( Message message : element.getMessages() ) {
			//declare message fifo
			if(message.getSendEvent() instanceof Gate){
				writer.appendTab2("route<")
				.append("env");
			}
			else
			{
			writer.appendTab2("route<")
				.append(routeProtocol);
			}
			writer.append("> [ ")
				.append(message.getName());

			writer.appendEol("];");

		}
		writer.appendTabEol("// end route");


		writer.appendTab("} // end Interaction ")
			.appendEol2(element.getName());

//!@?DERADCODE: TO DELETE
//	if( lfContext == null ) {
//	}
//	else {
//		lfContext.initializeConstraintMap(element);
//
//		// A writer indenting with TAB + iTAB -> TAB2
//		PrettyPrintWriter writer2 = writer.itab2();
//
//		writer2.appendTab("////////////////////////////////////////////////////////////////////////////// Lifeline ")
//			.append(lfContext.coveredLifeline.getName())
//			.appendEol(" //////////////////////////////////////////////////////////////////////////////");
//
//		ArrayList<InteractionFragment> coveredFragmentList =
//				coveredFragments(lfContext.coveredLifeline, element.getFragments());
//
//		lfContext.isLastFragmentTransformation = false;
//		int coveredFragmentListCount = coveredFragmentList.size()-1;
//		for( InteractionFragment iFragment : coveredFragmentList ) {
//			if(coveredFragmentList.indexOf(iFragment) == coveredFragmentListCount){
//				//Transition tr_final = lfContext.createTransition(
//				//"tr_final", lfContext.currentState, lfContext.finalState);
//				lfContext.isLastFragmentTransformation = true;
//
////					lfContext.currentState = lfContext.finalState;
//			}
//
//			transformFragment(iFragment, lfContext, writer2);
//		}
//
//		//TODO DELETE Transition tr_final
////			Transition tr_final = lfContext.createTransition(
////					"tr_final", lfContext.currentState, lfContext.finalState);
//	}


	}


//	public String typeName(Type element) {
//		String typeString = element.getName();
//
//		if( element instanceof PrimitiveType ) {
//			typeString = typeString.toLowerCase();
//		}
//		else if( element instanceof Class ){
//			typeString = "machine" + "/*< " + typeString + " >*/";
//		}
//
//		return typeString;
//	}
//


	public void transformInteraction(Interaction element,  PrettyPrintWriter writer)
	{
		final StatemachineContext lfContext = new StatemachineContext(element, CONTEXT.INTERACTION);

		transformInteraction(element, element.getLifelines(), lfContext, writer);
	}


	/**
	 * performTransform a Fragment element to a writer
	 * @param element
	 * @param writer
	 */

	private void transformFragment(InteractionFragment element, PrettyPrintWriter writer)
	{
		for (Lifeline lifeline : element.getCovereds()) {
			StatemachineContext lfContext = new StatemachineContext(lifeline);

			transformFragment(element, lfContext);

			lfContext.toWriter(fSupervisor.fStatemachineFactory, writer);
		}
	}

	private void transformFragment(InteractionFragment iFragment,
			StatemachineContext lfContext) {
		if( iFragment instanceof CombinedFragment ) {
			transformCombinedFragment(
					(CombinedFragment)iFragment, lfContext);
		}

		else if( iFragment instanceof InteractionOperand ) {
			transformInteractionOperand(
					(InteractionOperand)iFragment, lfContext);
		}

		else if( iFragment instanceof MessageOccurrenceSpecification ) {
			transformMessageOccurrenceSpecification(
					(MessageOccurrenceSpecification)iFragment, lfContext);
		}

		else if( iFragment instanceof BehaviorExecutionSpecification ) {
			transformBehaviorExecutionSpecification(
					(BehaviorExecutionSpecification)iFragment, lfContext);
		}

		else if( iFragment instanceof ExecutionOccurrenceSpecification ) {
			transformExecutionOccurrenceSpecification(
					(ExecutionOccurrenceSpecification)iFragment, lfContext);
		}

		else {
			performTransformError(this, iFragment);
		}
	}

 // transform data constraint
	public void transformElementConstraints(
			Element element, Transition transition, StatemachineContext lfContext) {

		List<Constraint> constraints = lfContext.getElementConstraints(element);
		if( constraints != null ) {
			for (Constraint constraint : constraints) {
				UmlFactory.addEffectGuard(lfContext,
						element ,transition, constraint);
			};
		}
	}


	// transform timed constraint
		public void transformElementTimedConstraints(
				Element element, Transition transition, StatemachineContext lfContext) {

			List<Constraint> constraints = lfContext.getElementConstraints(element);
			if( constraints != null ) {
				for (Constraint constraint : constraints) {
					UmlFactory.setGuard(transition, constraint);
				};
			}
		}

	// transform TimeObservation
	public void transformElementTimeObservation(
			NamedElement element, Transition transition, StatemachineContext lfContext) {

		List<TimeObservation> timeObservations = lfContext.getTimeObservation(element);
		if( timeObservations != null ) {
			for (TimeObservation tObs : timeObservations) {
//				UmlFactory.setGuard(transition, tObs);
			};
		}
	}


	/**
	 * performTransform a InteractionOperand element
	 * @param element
	 * @param writer
	 */
	private void transformInteractionOperand(InteractionOperand element,
			StatemachineContext lfContext) {

		lfContext.initialState.setName("init_" + element.getName());
		lfContext.finalState.setName("final_" + element.getName());

		ArrayList<InteractionFragment> coveredFragmentList =
				coveredFragments(lfContext.coveredLifeline, element.getFragments());

		if( coveredFragmentList.isEmpty() ) {
			lfContext.performNoCoveredFragment();
		}
		else {
			lfContext.isLastFragmentTransformation = false;

			int coveredFragmentListCount = coveredFragmentList.size()-1;
			for( InteractionFragment iFragment : coveredFragmentList ) {
				if (coveredFragmentList.indexOf(iFragment) == coveredFragmentListCount ) {
					// lfContext.isLastFragmentTransformation
					lfContext.isLastFragmentTransformation = true;

//					lfContext.currentState = lfContext.finalState;
				}
				transformFragment(iFragment, lfContext);
			}

//			Transition tr_final = lfContext.createTransition(
//					"tr_final", lfContext.currentState, lfContext.finalState);
		}
	}

	/**
	 * performTransform a CombinedFragment element
	 * @param element
	 * @param writer
	 */
	public void transformCombinedFragment(CombinedFragment element,
			StatemachineContext lfContext) {

		switch (element.getInteractionOperator()) {
		case LOOP_LITERAL:
			transformCombinedFragmentLoop(element, lfContext);
			break;

		case ALT_LITERAL:
			transformCombinedFragmentAlt(element, lfContext);
			break;

		case OPT_LITERAL:
			transformCombinedFragmentOpt(element, lfContext);
			break;

		case SEQ_LITERAL:
			transformCombinedFragmentSequence(element, lfContext);
			break;

		case STRICT_LITERAL:
			transformCombinedFragmentStrict(element, lfContext);
			break;

		case PAR_LITERAL:
			transformCombinedFragmentParallel(element, lfContext);
			break;

		default:
			break;
		}
	}


	////////////////////////////////////// Transform Loop Fragment //////////////////////////////
	////////////////////////////////////////////////////////////////////////////////////////////

	public void transformCombinedFragmentLoop(CombinedFragment element,
			StatemachineContext lfContext) {

		lfContext.currentState.setName("LoopFragment#" + element.getName());
		Constraint loopGuard = element.getOperands().get(0).getGuard();
		State loopState = lfContext.createTargetState("loop_" + element.getName());

		if( element.getCovereds().size() < 2 || lfContext.transfoCtx == CONTEXT.LIFELINE ) {

			Transition entryLoop = lfContext.createTransition(
					"tr_loop_entry", lfContext.currentState, loopState);
			UmlFactory.setGuard(entryLoop, loopGuard);
		}
		else {

		Transition entryLoop = lfContext.createTransition(
				"tr_loop_first", lfContext.currentState, loopState);
		UmlFactory.setGuard(entryLoop, loopGuard);

		entryLoop= lfContext.createTransition(
				"tr_loop_not_first", lfContext.currentState, loopState);
		UmlFactory.setGuard(entryLoop, loopGuard);
		}

		lfContext.currentState = loopState;

		// loop boucle with min/max index constraint
		Transition trLoop = lfContext.createFinalTransition(
				"tr_loop", loopState, loopState);
		Property loopIndex = UmlFactory.createVariable(lfContext.statemachine,
				//"loopIndex_"
				"count_"+ element.getName(), UmlFactory.integerType());

		// Add effect behavior
		//increment loopIndex
		UmlFactory.addOpaqueBehaviorEffect(trLoop, loopIndex.getName()+" +=1 ;");


		if( loopGuard instanceof InteractionConstraint ) {

			UmlFactory.setGuard(trLoop, (InteractionConstraint) loopGuard, loopIndex);
		}
		else {
			UmlFactory.setGuard(trLoop, loopGuard);
		}



		StatemachineContext loopContext = new StatemachineContext(lfContext, element);

		for( InteractionOperand iFragment : element.getOperands()) {
			transformInteractionOperand(iFragment, loopContext);
		}

		// quit loop transition
		State quitloopState = lfContext.createTargetState("quit_loop_" + element.getName());
		Transition quitLoop = lfContext.createFinalElseTransition(
				"final#tr_quit_loop", loopState, quitloopState);

		lfContext.currentState = quitloopState;


	}



////////////////////////////////////// Transform Alt Fragment //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

public void transformCombinedFragmentAlt(CombinedFragment element,
		StatemachineContext lfContext) {

	State exitAltState = lfContext.createTargetState("exit_alt#" + element.getName());

	State sourceAltStates = lfContext.currentState;

	for( InteractionOperand iFragment : element.getOperands()) {

		State regionAltState = lfContext.createTargetState("region_alt#" + iFragment.getName());

		Constraint regionGuard = iFragment.getGuard();

		if( element.getCovereds().size() < 2 || lfContext.transfoCtx == CONTEXT.LIFELINE ) {

			Transition entryAltFirst = lfContext.createTransition(
					"tr_alt_entry#" + iFragment.getName(), sourceAltStates, regionAltState);
			UmlFactory.setGuard(entryAltFirst, regionGuard);
		}
		else {
		Transition entryAltFirst = lfContext.createTransition(
				"tr_alt_first#" + iFragment.getName(), sourceAltStates, regionAltState);
		UmlFactory.setGuard(entryAltFirst, regionGuard);

		Transition entryAltNotFirst = lfContext.createTransition(
				"tr_alt_not_first#" + iFragment.getName(), sourceAltStates, regionAltState);
		UmlFactory.setGuard(entryAltNotFirst, regionGuard);
		}

		lfContext.currentState = regionAltState;
		StatemachineContext altContext = new StatemachineContext(lfContext, element);

		transformInteractionOperand(iFragment, altContext);

		Transition exitRegionAlt = lfContext.createFinalTransition(
				"tr_alt_quit#" + iFragment.getName(), regionAltState, exitAltState);
	}

	lfContext.currentState = exitAltState;


}


//////////////////////////////////////Transform Sequence Fragment //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// TODO
public void transformCombinedFragmentSequence(
		CombinedFragment element, StatemachineContext lfContext) {

	lfContext.currentState.setName("SeqFragment#" + element.getName());
	State exitSeqState = lfContext.createTargetState("exit_seq#" + element.getName());

	State regionSeqState = lfContext.createTargetState("target_seq#" + element.getName());
	for( InteractionOperand iFragment : element.getOperands()) {

		Constraint regionGuard = iFragment.getGuard();

		Transition entrySeq = lfContext.createTransition(
				"tr_seq_region#" + iFragment.getName(), lfContext.currentState, regionSeqState);
		//	UmlFactory.setGuard(entryStrict, regionGuard);

		StatemachineContext seqContext = new StatemachineContext(lfContext, iFragment);

		transformInteractionOperand(iFragment, seqContext);

	}

	Transition exitSeq = lfContext.createFinalTransition(
			"tr_seq_quit#" + element.getName(), lfContext.currentState, exitSeqState);
	lfContext.currentState = exitSeqState;
}


//////////////////////////////////////Transform Strict Fragment //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

public void transformCombinedFragmentStrict(
		CombinedFragment element, StatemachineContext lfContext) {

	lfContext.currentState.setName("StrictFragment#" + element.getName());

	State elseStrictState = null;
	Transition elseStrictTransition = null;
	State operandStrictState = null;

	for( InteractionOperand iFragment : element.getOperands()) {

		if( elseStrictState != null ) {
			elseStrictState.setName("strict#" + iFragment.getName());
			operandStrictState = elseStrictState;
			elseStrictState = null;
		}
		else {
			operandStrictState = lfContext.createNewState("strict#" + iFragment.getName());
		}
		Transition operandStrictTransition = lfContext.createTransition(
				"tr_strict_region#" + iFragment.getName(), lfContext.currentState, operandStrictState);

		Constraint regionGuard = iFragment.getGuard();
		if( regionGuard != null ) {
			UmlFactory.setGuard(operandStrictTransition, regionGuard);

			// previous else transition
			if( elseStrictTransition != null ) {
				UmlFactory.setGuard(elseStrictTransition, regionGuard);

			}

			elseStrictState = lfContext.createNewState("else_strict#" + iFragment.getName());

			elseStrictTransition = lfContext.createTransition(
					"tr_else_strict_region#" + iFragment.getName(), lfContext.currentState, elseStrictState);
		}

		lfContext.currentState = operandStrictState;

		StatemachineContext strictContext = new StatemachineContext(lfContext, iFragment);

		transformInteractionOperand(iFragment, strictContext);
	}

	if( elseStrictState != null ) {
		elseStrictState.setName("exit_strict#" + element.getName());
	}
	else {
		elseStrictState = lfContext.createTargetState("exit_strict#" + element.getName());
	}
	Transition exitStrict = lfContext.createTransition(
			"tr_strict_quit#" + element.getName(), lfContext.currentState, elseStrictState);
	lfContext.currentState = elseStrictState;
}


//////////////////////////////////////Transform Parallel Fragment //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//TODO

public void transformCombinedFragmentParallel(
		CombinedFragment element, StatemachineContext lfContext) {

	lfContext.currentState.setName("ParFragment#" + element.getName());
	State exitParState = lfContext.createTargetState("exit_par#" + element.getName());

	State regionStrictState = lfContext.createTargetState("target_par#" + element.getName());
	for( InteractionOperand iFragment : element.getOperands()) {

		Constraint regionGuard = iFragment.getGuard();
		//	Transition entryStrict = lfContext.createTransition(
		//			"tr_strict_region#" + iFragment.getName(), lfContext.currentState, regionStrictState);
		//	UmlFactory.setGuard(entryStrict, regionGuard);

		StatemachineContext parContext = new StatemachineContext(lfContext, iFragment);

		transformInteractionOperand(iFragment, parContext);

	}

	Transition exitPar = lfContext.createTransition(
			"tr_par_quit#" + element.getName(), lfContext.currentState, exitParState);
	lfContext.currentState = exitParState;


}



//////////////////////////////////////Transform Opt Fragment //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////

public void transformCombinedFragmentOpt(CombinedFragment element,
		StatemachineContext lfContext) {

	State optState = lfContext.createTargetState("opt#" + element.getName());

	Transition entryOpt = lfContext.createTransition(
			"tr_opt_first", lfContext.currentState, optState);
	////TODO Add effect behavior

	entryOpt= lfContext.createTransition(
			"tr_opt_not_first", lfContext.currentState, optState);
	////TODO Add effect behavior

	lfContext.currentState = optState;
	//
	//
	StatemachineContext optContext = new StatemachineContext(lfContext, element);
	for( InteractionOperand iFragment : element.getOperands()) {
		transformInteractionOperand(iFragment, optContext);
	}
}




	/**
	 * performTransform a ExecutionOccurrence element to a writer
	 * @param element
	 */
	public void transformExecutionOccurrenceSpecification(
			ExecutionOccurrenceSpecification element, StatemachineContext lfContext) {

		State execOccState = lfContext.createTargetState("execOcc#" + element.getName());

		Transition execOccTrqns = lfContext.createTransition(
				"tr_execOcc", lfContext.currentState, execOccState);


		lfContext.currentState = execOccState;
	}


	/**
	 * performTransform a Lifeline element to a writer
	 * @param element
	 * @param writer
	 */
	public void transformLifeline(Lifeline element, PrettyPrintWriter writer)
	{
		final StatemachineContext lfContext =
				new StatemachineContext(element.getInteraction(), CONTEXT.LIFELINE);

		transformInteraction(element.getInteraction(),
				Arrays.asList( element ), lfContext, writer);
	}

	public void transformWriteLifeline(Lifeline element,
			StatemachineContext lfContext, PrettyPrintWriter writer) {

		Interaction interaction = element.getInteraction();

		if( interaction != null ) {
			lfContext = new StatemachineContext(lfContext, element);

			ArrayList<InteractionFragment> coveredFragmentList =
					coveredFragments(element, interaction.getFragments());

			lfContext.isLastFragmentTransformation = false;
			int coveredFragmentListCount = coveredFragmentList.size()-1;
			for (InteractionFragment itFragment : coveredFragmentList) {
				if(coveredFragmentList.indexOf(itFragment) == coveredFragmentListCount){
					//Transition tr_final = lfContext.createTransition(
					//"tr_final", lfContext.currentState, lfContext.finalState);
					lfContext.isLastFragmentTransformation = true;

//					lfContext.currentState = lfContext.finalState;
				}

				transformFragment(itFragment, lfContext);
			}

			lfContext.toWriter(fSupervisor, writer);
		}
	}





	/**
	 * performTransform a BehaviorExecutionSpecification element to a writer
	 * @param element
	 * @param writer
	 */
	public void transformBehaviorExecutionSpecification(
			BehaviorExecutionSpecification element,
			StatemachineContext lfContext) {
		if(element.getStart() instanceof ExecutionOccurrenceSpecification){
			BehaviorExecutionSpecification act = element;

			State targetState = needIntermediateState(element, lfContext)
					? lfContext.createIntermediateState("targetBhExec#" + element.getName())
					: lfContext.createTargetState("targetBhExec#" + element.getName());

			lfContext.currentState.setName("BhExec#" + element.getName());
			Transition BH_tr= lfContext.createTransition(
					act.getName(), lfContext.currentState, targetState);

			transformElementConstraints(element.getStart(), BH_tr, lfContext);

			UmlFactory.addOpaqueBehaviorEffect(BH_tr, act.getBehavior());

			lfContext.currentState = targetState;
			//add constraint of finishOccurrence to the transition
			if(element.getFinish() instanceof ExecutionOccurrenceSpecification ){

				List<Constraint> constraints = lfContext.getElementConstraints(element.getFinish());
				if( constraints != null ){
					lfContext.intermediateTransition = null;

					for (Constraint constraint : constraints) {
						UmlFactory.addEffectGuard(lfContext, element, BH_tr, constraint);
					}

					if(lfContext.intermediateTransition != null){
						lfContext.currentState = (State) lfContext.intermediateTransition.getTarget();
						lfContext.intermediateTransition = null;
					}

					if(element.getBehavior() instanceof FunctionBehavior){
						UmlFactory.addOpaqueBehaviorEffect(BH_tr, "AllCallsStack <=< currentCall;");
					}
				}
				else {
					if(element.getBehavior() instanceof FunctionBehavior){
						UmlFactory.addOpaqueBehaviorEffect(BH_tr, "AllCallsStack <=< currentCall;");
					}
				}
			}
			//lfContext.currentState = targetState;

		}
	}

	private boolean needIntermediateState(
			BehaviorExecutionSpecification element,
			StatemachineContext lfContext) {
		if( lfContext.isLastFragmentTransformation
			&& (element.getFinish() instanceof ExecutionOccurrenceSpecification) ){

			List<Constraint> constraints = lfContext.getElementConstraints(element.getFinish());
			if( constraints != null ){
				for (Constraint constraint : constraints)
				{
					ValueSpecification valueSpec = constraint.getSpecification();
					if( valueSpec instanceof OpaqueExpression ) {
						OpaqueExpression opaqExpr = (OpaqueExpression)valueSpec;
						for (String language : opaqExpr.getLanguages()) {
							if(language.contains("xLIA")){
								{
									return true;
								}
							}
						}
					}
				}
			}
		}
		return false;
	}

	/**
	 * performTransform a MessageOccurrenceSpecification element to a writer
	 * @param element
	 * @param writer
	 */
	public void transformMessageOccurrenceSpecification(
			MessageOccurrenceSpecification element,
			StatemachineContext lfContext) {


		lfContext.currentState.setName("MsgOcc#" + element.getName());
		State targetState = lfContext.createTargetState("targetMsgOcc#" + element.getName());
		Transition MsgOcc_tr= lfContext.createTransition(
				"tr_" + element.getName(), lfContext.currentState, targetState);

//		Message message = element.getMessage();
//		if( element.isReceive() ){
//
//			StringBuilder MsgReceiveAction = new StringBuilder("input ");
//			lfContext.inputMessage.add(message);
//
//			MsgReceiveAction.append( message.getName() );//.getSignature().getLabel() )
////			if (! (message.getArguments().isEmpty()) ){
//				boolean isnotFirst = false;
//
//				MsgReceiveAction.append("( { ");
//
//				if( message.getSignature() instanceof Signal ) {
//					Signal signal = (Signal) message.getSignature();
//
//					final String paramPrefix = message.getName() + "#in.";
//
//					for (Property property : signal.getAllAttributes()) {
//
//						if( isnotFirst ) {
//							MsgReceiveAction.append(" , ");
//						}
//						else {
//							isnotFirst = true;
//						}
//						MsgReceiveAction.append( paramPrefix)
//							.append(property.getName());
//					}
//
//				}



		Message message = element.getMessage();
		if( element.isReceive() ){

		    StringBuilder MsgReceiveAction = new StringBuilder("input ");
		    lfContext.inputMessage.add(message);

		    MsgReceiveAction.append( message.getName() );


		//    if (! (message.getArguments().isEmpty()) ){
		    	// check if there is a behaviorExecution that specifies the variables on which we receive the message
				EList<InteractionFragment> fragments = lfContext.coveredLifeline.getCoveredBys();
				Boolean isStartExecBehavExecution = false;
				BehaviorExecutionSpecification behavExecSpecOfComAct = null;
				for (Iterator<InteractionFragment> iterator = fragments.iterator(); iterator.hasNext();) {
					InteractionFragment interactionFragment = iterator.next();
					if (interactionFragment instanceof BehaviorExecutionSpecification){

						behavExecSpecOfComAct = (BehaviorExecutionSpecification) interactionFragment;
						if (behavExecSpecOfComAct.getStart() == element){
							isStartExecBehavExecution = true;
							break;
						}
					}
				}

				MsgReceiveAction.append("( ")
				.append(message.getName()).append( "#params );\n" );//append("#").append(message.getSignature().getName()).append(");\n");

				if (isStartExecBehavExecution){
					Behavior behavior = behavExecSpecOfComAct.getBehavior();
					if (behavior instanceof OpaqueBehavior){
						OpaqueBehavior opaqueBehavior = (OpaqueBehavior) behavior;
						if (opaqueBehavior.getBodies().size() > 0){
							String strinBehavior = opaqueBehavior.getBodies().get(0).trim();
							if( strinBehavior.startsWith("in ") ) {
								strinBehavior = strinBehavior.substring(3, strinBehavior.length()-1);
								String[] inVars = strinBehavior.split(" *, *");

								Signal signal = (Signal) message.getSignature();
								for (int i = 0; i < inVars.length; i++) {
									MsgReceiveAction.append(inVars[i])
									.append(" = ")
									.append(message.getName()).append( "#params.")//append("#").append(message.getSignature().getName()).append(".")
									.append(signal.getAllAttributes().get(i).getName())
									.append(";\n");
								}
							}
							else {
								//TO DO error message
							}
						}
					}
				}

		        //ancien
		        NamedElement signature = message.getSignature();
		        if( signature instanceof Signal ) {
		            lfContext.addLocalVariable(message.getName() + "#params"//"#" + message.getSignature().getName()
		            , (Signal) signature);
		        }

				UmlFactory.addOpaqueBehaviorEffect(MsgOcc_tr, MsgReceiveAction.toString());
	//	    }
		}
		else if( element.isSend() ) {

			//translate constraints
			transformElementConstraints(element, MsgOcc_tr, lfContext);

			//translate output action
			StringBuilder MsgReceiveAction = new StringBuilder("output ");
			lfContext.outputMessage.add(message);

			MsgReceiveAction.append( message.getName() )
			.append("( { ")
			.append("\"")
			.append(message.getSignature().getName())
			.append("\"");

			if (! (message.getArguments().isEmpty()) ){
				MsgReceiveAction.append(", ");

				boolean isnotFirst = false;

				for (ValueSpecification itArg : message.getArguments()) {
					if( isnotFirst ) {
						MsgReceiveAction.append(" , ");
					}
					else {
						isnotFirst = true;
					}
					MsgReceiveAction.append(itArg.stringValue());
				}
				MsgReceiveAction.append(" } )");
			}

			MsgReceiveAction.append(" --> ");


			if (message.getReceiveEvent() instanceof MessageOccurrenceSpecification){

				if( lfContext.transfoCtx == CONTEXT.INTERACTION )
				{
					MessageOccurrenceSpecification target = (MessageOccurrenceSpecification) message.getReceiveEvent();

					MsgReceiveAction.append(target.getCovered().getRepresents().getType().getName())
						.append('#').append(target.getCovered().getName());
				}
				else {
					MsgReceiveAction.append("$env");
				}
			}

			if (message.getReceiveEvent() instanceof Gate){

				//Gate target = (Gate) message.getReceiveEvent();

				MsgReceiveAction.append("$env");
			}
			MsgReceiveAction.append(";");

			UmlFactory.addOpaqueBehaviorEffect(MsgOcc_tr, MsgReceiveAction.toString());
	   }
		lfContext.currentState = targetState;
	}



	/**
	 * performTransform a Message element to a writer
	 * @param element
	 * @param writer
	 */
	public void transformMessage(Message element,
			StatemachineContext lfContext,  PrettyPrintWriter writer) {
		writer.appendTab("Message ")
			.appendEol(" {");


		writer.appendTab("} // end Message ")
			.appendEol2(element.getName());
	}


//	/**
//	 * performTransform a Region List element to a writer
//	 * @param listOfRegion
//	 * @param writer
//	 */
//	private void transformGate(Gate element,
//			StatemachineContext lfContext, PrettyPrintWriter writer) {
//
//		writer.appendTab("Gate ")
//		.append(element.getName())
//		.appendEol(" {");
//
//		writer.appendTab("} // end Gate ")
//		.appendEol2(element.getName());
//	}


//	private void transformPartDecomposition(PartDecomposition element,
//			StatemachineContext lfContext, PrettyPrintWriter writer) {
//		writer.appendTab("PartDecomposition ")
//			.append(element.getName())
//			.appendEol(" {");
//
//	writer.appendTab("} // end PartDecomposition ")
//		.appendEol2(element.getName());
//	}

}