package jcircus.newutil;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Vector;








import net.sourceforge.czt.base.ast.Term;
import net.sourceforge.czt.circus.ast.AlphabetisedParallelProcess;
import net.sourceforge.czt.circus.ast.AssignmentCommand;
import net.sourceforge.czt.circus.ast.AssignmentPairs;
import net.sourceforge.czt.circus.ast.BasicChannelSetExpr;
import net.sourceforge.czt.circus.ast.BasicProcess;
import net.sourceforge.czt.circus.ast.CallAction;
import net.sourceforge.czt.circus.ast.CallProcess;
import net.sourceforge.czt.circus.ast.ChannelSet;
import net.sourceforge.czt.circus.ast.CircusAction;
import net.sourceforge.czt.circus.ast.CircusActionList;
import net.sourceforge.czt.circus.ast.CircusChannelSet;
import net.sourceforge.czt.circus.ast.CircusCommand;
import net.sourceforge.czt.circus.ast.CircusCommunicationList;
import net.sourceforge.czt.circus.ast.CircusFieldList;
import net.sourceforge.czt.circus.ast.CircusNameSet;
import net.sourceforge.czt.circus.ast.CircusProcess;
import net.sourceforge.czt.circus.ast.CommPattern;
import net.sourceforge.czt.circus.ast.CommUsage;
import net.sourceforge.czt.circus.ast.Communication;
import net.sourceforge.czt.circus.ast.CommunicationList;
import net.sourceforge.czt.circus.ast.DotField;
import net.sourceforge.czt.circus.ast.ExtChoiceAction;
import net.sourceforge.czt.circus.ast.ExtChoiceProcess;
import net.sourceforge.czt.circus.ast.Field;
import net.sourceforge.czt.circus.ast.GuardedAction;
import net.sourceforge.czt.circus.ast.HideAction;
import net.sourceforge.czt.circus.ast.HideProcess;
import net.sourceforge.czt.circus.ast.IfGuardedCommand;
import net.sourceforge.czt.circus.ast.InputField;
import net.sourceforge.czt.circus.ast.IntChoiceAction;
import net.sourceforge.czt.circus.ast.IntChoiceProcess;
import net.sourceforge.czt.circus.ast.InterleaveAction;
import net.sourceforge.czt.circus.ast.InterleaveProcess;
import net.sourceforge.czt.circus.ast.MuAction;
import net.sourceforge.czt.circus.ast.NameSet;
import net.sourceforge.czt.circus.ast.ParallelAction;
import net.sourceforge.czt.circus.ast.ParallelProcess;
import net.sourceforge.czt.circus.ast.ParamAction;
import net.sourceforge.czt.circus.ast.ParamProcess;
import net.sourceforge.czt.circus.ast.PrefixingAction;
import net.sourceforge.czt.circus.ast.SeqAction;
import net.sourceforge.czt.circus.ast.SeqProcess;
import net.sourceforge.czt.circus.ast.SkipAction;
import net.sourceforge.czt.circus.ast.StopAction;
import net.sourceforge.czt.circus.ast.VarDeclCommand;
import net.sourceforge.czt.circus.util.Factory;
import net.sourceforge.czt.z.ast.AndPred;
import net.sourceforge.czt.z.ast.ApplExpr;
import net.sourceforge.czt.z.ast.AxPara;
import net.sourceforge.czt.z.ast.ConstDecl;
import net.sourceforge.czt.z.ast.Decl;
import net.sourceforge.czt.z.ast.Expr;
import net.sourceforge.czt.z.ast.FalsePred;
import net.sourceforge.czt.z.ast.MemPred;
import net.sourceforge.czt.z.ast.Name;
import net.sourceforge.czt.z.ast.NegPred;
import net.sourceforge.czt.z.ast.NumExpr;
import net.sourceforge.czt.z.ast.OrPred;
import net.sourceforge.czt.z.ast.Pred;
import net.sourceforge.czt.z.ast.RefExpr;
import net.sourceforge.czt.z.ast.SchExpr;
import net.sourceforge.czt.z.ast.SetExpr;
import net.sourceforge.czt.z.ast.Spec;
import net.sourceforge.czt.z.ast.TruePred;
import net.sourceforge.czt.z.ast.TupleExpr;
import net.sourceforge.czt.z.ast.VarDecl;
import net.sourceforge.czt.z.ast.ZDeclList;
import net.sourceforge.czt.z.ast.ZExprList;
import net.sourceforge.czt.z.ast.ZName;
import net.sourceforge.czt.z.ast.ZNameList;
import net.sourceforge.czt.z.ast.ZSchText;

/**@author: Samuel Barrocas**/
//Classe implementada para ajudar a criar cópias de ações e processos. Como a árvore sintática abstrata
	//de Circus possui muitos atributos (e muitos deles estão contidos em classes que são atributos de outras classes, e etc),
	//pode haver uma situação em que instanciamos uma classe sem a instanciação de seus atributos,
	//o que pode levar a uma igualdade indesejada entre os dois objetos (literalmente). 
	//É bom observar que, em Java, dois objetos iguais na verdade são o mesmo objeto. 
	//Qualquer modificação em um dos objetos leva à mesma modificação a qualquer outro objeto igual a ele, 
	//e isso, muitas vezes, não é a intenção do programador.

public class FactoryUtil {
	Factory f = new Factory ();
	public static ZNameList createZNameList (ZNameList namelist) {
		Factory f = new Factory ();
		ZNameList newlist = f.createZNameList ();
		int size = namelist.size();
		for (int i = 0; i < size; i++) {
			newlist.add(f.createZName ((ZName)namelist.get(i)));
		}
		return newlist;
	}
	public static ZDeclList createZDeclList (ZDeclList decllist) {
		int size = decllist.size();
		Factory f = new Factory ();
		ZDeclList decls = f.createZDeclList();
		for (int i = 0; i < size; i++) {
			decls.add(createDecl (decllist.get(i)));
		}
		return decls;
	}
	public static Decl createDecl (Decl decl) {
		Factory f = new Factory ();
		if (decl instanceof VarDecl) {
			VarDecl vardecl = ((VarDecl)decl);
			VarDecl returnvardecl = f.createVarDecl();
			returnvardecl.setNameList(createZNameList (vardecl.getZNameList()));
			returnvardecl.setExpr(createExpr (vardecl.getExpr()));
			return returnvardecl;
		}
		else if (decl instanceof ConstDecl) {
			ConstDecl constdecl = ((ConstDecl)decl);
			ConstDecl returnconstdecl = f.createConstDecl();
			returnconstdecl.setName(f.createZName(constdecl.getZName().toString()));
			returnconstdecl.setExpr(createExpr (constdecl.getExpr()));
			return returnconstdecl;
		}
		else {
			ExceptionUtil.throwImplementationException ("FactoryUtil.createDecl", decl.getClass());
			return f.createVarDecl();
		}
	}
	public static Pred createPred (Pred pred) {
		Factory f = new Factory ();
		if (pred instanceof MemPred) {
			MemPred mempred = (MemPred)pred;
			MemPred predf = f.createMemPred();
			predf.setLeftExpr(createExpr (mempred.getLeftExpr()));
			predf.setRightExpr(createExpr (mempred.getRightExpr()));
			predf.setMixfix(mempred.getMixfix());
			return predf;
		}
		else if (pred instanceof AndPred) {
			AndPred andpred = (AndPred)pred;
			AndPred predf = f.createAndPred();
			predf.setLeftPred(createPred (andpred.getLeftPred()));
			predf.setRightPred(createPred (andpred.getRightPred()));
			return predf;
		}
		else if (pred instanceof OrPred) {
			OrPred orpred = (OrPred)pred;
			OrPred predf = f.createOrPred();
			predf.setLeftPred(createPred (orpred.getLeftPred()));
			predf.setRightPred(createPred (orpred.getRightPred()));
			return predf;
		}
		else if (pred instanceof TruePred) {
			return f.createTruePred();
		}
		else if (pred instanceof FalsePred) {
			return f.createFalsePred();
		}
		else if (pred instanceof NegPred) {
			NegPred neg = f.createNegPred();
			neg.setPred(createPred (((NegPred) pred).getPred()));
			return neg;
		}
		else {
			ExceptionUtil.throwImplementationException("FactoryUtil.createPred", pred.getClass());
			return f.createTruePred();
		}
	}
	public static ZSchText createZSchText (ZSchText schtext) {
		Factory f = new Factory ();
		Pred schpred = schtext.getPred() == null? f.createTruePred() : createPred (schtext.getPred());
		ZSchText textfinal = 
				f.createZSchText(
						FactoryUtil.createZDeclList (schtext.getZDeclList()), 
						schpred
				);
		return textfinal;
	}
	public static AxPara createAxPara (AxPara axpara) {
		Factory f = new Factory ();
		AxPara newaxpara = f.createAxPara(
				f.createZNameList(axpara.getZNameList()),
				FactoryUtil.createZSchText(axpara.getZSchText()),
				/*f.createZSchText(
						//FactoryUtil.createZDeclList (axpara.getZSchText().getZDeclList()),
						//axpara.getZSchText().getPred()
				),*/
				axpara.getBox()
		);
		return newaxpara;
	}
	public static ZExprList createZExprList (ZExprList exprlist) {
		Factory f = new Factory ();
		int size = exprlist.size();
		ZExprList newlist = f.createZExprList();
		for (int i = 0; i < size; i++) {
			newlist.add(FactoryUtil.createExpr (exprlist.get(i)));
		}
		return newlist;
	}
	public static CircusCommunicationList createCircusCommunicationList (CircusCommunicationList cl) {
		int size = cl.size();
		Factory f = new Factory ();
		CircusCommunicationList ccl = f.createCircusCommunicationList ();
		for (int i = 0; i < size; i++) {
			ccl.add(createCommunication (cl.get(i)));
		}
		return ccl;
	}
	public static Expr createExpr (Expr expr) {
		Factory f = new Factory ();
		if (expr instanceof RefExpr) {
			RefExpr exprref = (RefExpr) expr;
			RefExpr ref = f.createRefExpr();
			ref.setExplicit(exprref.getExplicit());
			ref.setExprList(createZExprList (exprref.getZExprList()));
			ref.setMixfix(exprref.getMixfix());
			ref.setName(f.createZName(exprref.getZName()));
			ref.getAnns().addAll(exprref.getAnns());
			return ref;
			//return exprref;
		}
		else if (expr instanceof ApplExpr) {
			ApplExpr exprappl = (ApplExpr)expr;
			ApplExpr appl = f.createApplExpr();
			appl.setLeftExpr(exprappl.getLeftExpr());
			appl.setRightExpr(exprappl.getRightExpr());
			appl.setMixfix(exprappl.getMixfix());
			appl.getAnns().addAll(exprappl.getAnns());
			return appl;
		}
		else if (expr instanceof TupleExpr) {
			TupleExpr exprtuple = (TupleExpr) expr;
			TupleExpr tuple = f.createTupleExpr();
			tuple.setExprList(createZExprList(exprtuple.getZExprList()));
			tuple.getAnns().addAll (exprtuple.getAnns());
			return tuple;
		}
		else if (expr instanceof NumExpr) {
			return f.createNumExpr(((NumExpr)expr).getValue());
		}
		else if (expr instanceof SetExpr) {
			SetExpr setexpr = (SetExpr)expr;
			SetExpr setexprfinal = f.createSetExpr();
			setexprfinal.setExprList(createZExprList (setexpr.getZExprList()));
			return setexprfinal;
		}
		else if (expr instanceof BasicChannelSetExpr) {
			BasicChannelSetExpr bcse = f.createBasicChannelSetExpr();
			bcse.setCommunicationList(createCircusCommunicationList (((BasicChannelSetExpr)expr).getCircusCommunicationList()));
			return bcse;
		}
		else if (expr instanceof SchExpr) {
			SchExpr se = f.createSchExpr();
			se.setSchText(createZSchText (((SchExpr)expr).getZSchText()));
			return se;
		}
		/*else if {outras express�es}*/
		else {
			ExceptionUtil.throwImplementationException ("FactoryUtil.createExpr", expr.getClass());
			return f.createRefExpr();
		}
	}
	private static void addAllNew (Term term) {
		
	}
	public static Field createField (Field field) {
		Factory f = new Factory ();
		if (field instanceof InputField) {
			InputField nfield = f.createInputField();
			nfield.setVariableName(f.createZName (((InputField)field).getVariableName().toString()));
			nfield.setRestriction(createPred (((InputField)field).getRestriction()));
			nfield.getAnns().addAll(field.getAnns());
			return nfield;
		}
		else if (field instanceof DotField) {
			DotField nfield = f.createDotField();
			nfield.setExpr(
				createExpr (((DotField)field).getExpr())
			);
			nfield.getAnns().addAll(field.getAnns());
			return nfield;
		}
		else {
			ExceptionUtil.throwImplementationException("FactoryUtil.createField", field.getClass());
			return f.createDotField();
		}
	}
	public static CircusFieldList createCFL (CircusFieldList cfl) {
		Factory f = new Factory ();
		CircusFieldList cfl2 = f.createCircusFieldList();
		for (int i = 0; i < cfl.size(); i++) {
			cfl2.add(FactoryUtil.createField(cfl.get(i)));
		}
		cfl2.getAnns().addAll(cfl.getAnns());
		return cfl2;
	}
	public static Communication createCommunication (Communication c) {
		Factory f = new Factory ();
		Communication c2 = f.createCommunication(
				f.createRefExpr(f.createZName(c.getChannelExpr().getName().toString())),
				FactoryUtil.createCFL(c.getCircusFieldList()),
				c.getCommUsage(),
				c.getCommPattern(),
				c.getMultiSych(),
				c.getIndexed()
		);
		c2.getAnns().addAll(c.getAnns());
		return c2;
	}
	public ChannelSet createChannelSet (CircusChannelSet channelSet) { 
		CircusChannelSet circusChannelSet = f.createCircusChannelSet();
		circusChannelSet.setExpr(createExpr (channelSet.getExpr()));
		return circusChannelSet;
	}
	public CircusAction createExpandedCircusAction (CircusAction action, CircusProcess process, Spec spec) {
		if (!(action instanceof CallAction))
			return action;//createCircusAction (action);
		else {
			return createCircusAction (CallUtil.getContentOfCallAction((CallAction)action, process, spec));
		}
	}
	public CircusNameSet createNameSet (CircusNameSet nameset) {
		Factory f = new Factory ();
		CircusNameSet newnameset = f.createCircusNameSet();
		Expr expr = nameset.getExpr();
		if (expr != null)
			newnameset.setExpr(createExpr (expr));
		return newnameset;
	}
	/*private void addAnnsProperly (Term term1, Term term2) { //Adiciona as anotações de term1 a term2 evitando o problema de igualdade de objetos
		List <Object> term1anns = term1.getAnns();
		List <Object> newterm1anns = new ArrayList <Object> ();
		for (int i = 0; i < term1anns.size(); i++) {
			newterm1anns.add(new Object (term1anns.get(i)));
		}
	}*/
	public CircusAction createCircusAction (CircusAction action) {
		//TODO TESTADO PARCIALMENTE. DEDICAR UMA ATENCAO ESPECIAL AOS BLOCOS DE ACOES HIDE, GUARDED, PARALLEL E INTERLEAVE,
			//QUE TEM PERIGO DE ELAS CAÍREM NA ARMADILHA DA IGUALDADE ENTRE OS OBJETOS
		if (action instanceof ParamAction) {
			Factory f = new Factory ();
			ParamAction param = f.createParamAction();
			param.setDeclList(f.createZDeclList (((ParamAction)action).getZDeclList()));
			param.setCircusAction(createCircusAction (((ParamAction)action).getCircusAction()));
			param.getAnns().addAll(action.getAnns());
			return param;
		}
		else if (action instanceof PrefixingAction) {
			PrefixingAction action2 = (PrefixingAction) action;
			PrefixingAction action3;
			action3 = f.createPrefixingAction();
			action3.setCommunication(FactoryUtil.createCommunication (action2.getCommunication()));
			action3.setCircusAction(createCircusAction(action2.getCircusAction()));
			action3.getAnns().addAll(action2.getAnns());
			return action3;
		}
		else if (action instanceof ExtChoiceAction) {
			ExtChoiceAction action2 = (ExtChoiceAction) action;
			ExtChoiceAction eca = f.createExtChoiceAction();
			eca.setLeftAction(createCircusAction (action2.getLeftAction()));
			eca.setRightAction(createCircusAction (action2.getRightAction()));
			eca.getAnns().addAll(action2.getLeftAction().getAnns());
			eca.getAnns().addAll(action2.getRightAction().getAnns());
			return eca;
		}
		else if (action instanceof IntChoiceAction) {
			IntChoiceAction action2 = (IntChoiceAction) action;
			IntChoiceAction ica = f.createIntChoiceAction();
			ica.setLeftAction(createCircusAction (action2.getLeftAction()));
			ica.setRightAction(createCircusAction (action2.getRightAction()));
			ica.getAnns().addAll(action2.getLeftAction().getAnns());
			ica.getAnns().addAll(action2.getRightAction().getAnns());
			return ica;
		}
		else if (action instanceof ParallelAction) {
			ParallelAction action2 = (ParallelAction) action;
			ParallelAction pa = f.createParallelAction();
			pa.setLeftAction(createCircusAction (action2.getLeftAction()));
			pa.setRightAction(createCircusAction (action2.getRightAction()));
			pa.setLeftNameSet(createNameSet ((CircusNameSet)action2.getLeftNameSet()));
			pa.setRightNameSet(createNameSet ((CircusNameSet)action2.getRightNameSet()));
			pa.setChannelSet(createChannelSet ((CircusChannelSet) action2.getChannelSet()));
			pa.getAnns().addAll(action2.getLeftAction().getAnns());
			pa.getAnns().addAll(action2.getRightAction().getAnns());
			return pa;
		}
		else if (action instanceof InterleaveAction) {
			InterleaveAction action2 = (InterleaveAction) action;
			InterleaveAction pa = f.createInterleaveAction();
			pa.setLeftAction(createCircusAction (action2.getLeftAction()));
			pa.setRightAction(createCircusAction (action2.getRightAction()));
			pa.setLeftNameSet(action2.getLeftNameSet());
			pa.setRightNameSet(action2.getRightNameSet());
			pa.getAnns().addAll(action2.getLeftAction().getAnns());
			pa.getAnns().addAll(action2.getRightAction().getAnns());
			return pa;
		}
		else if (action instanceof SeqAction) {
			SeqAction action2 = (SeqAction) action;
			SeqAction pa = f.createSeqAction();
			pa.setLeftAction(createCircusAction (action2.getLeftAction()));
			pa.setRightAction(createCircusAction (action2.getRightAction()));
			pa.getAnns().addAll(action2.getLeftAction().getAnns());
			pa.getAnns().addAll(action2.getRightAction().getAnns());
			return pa;
		}
		else if (action instanceof CallAction) {
			CallAction action2 = f.createCallAction ();
			action2.setName(((CallAction)action).getName());
			action2.setExprList(createZExprList(((CallAction)action).getZExprList()));
			action2.getAnns().addAll(action.getAnns());
			return action2;
		}
		else if (action instanceof GuardedAction) {
			GuardedAction action2 = (GuardedAction)action;
			GuardedAction action3 = f.createGuardedAction();
			action3.setCircusAction(createCircusAction (action2.getCircusAction()));
			action3.setPred(createPred (action2.getPred()));
			action3.getAnns().addAll(action2.getAnns());
			return action3;
		}
		else if (action instanceof HideAction) {
			HideAction action2 = (HideAction)action;
			HideAction action3 = f.createHideAction();
			action3.setCircusAction(createCircusAction (action2));
			action3.setChannelSet(createChannelSet ((CircusChannelSet)action2.getChannelSet()));
			action3.getAnns().addAll(action2.getAnns());
			return action3;
		}
		else if (action instanceof MuAction) {
			MuAction action2 = (MuAction)action;
			MuAction action3 = f.createMuAction();
			action3.setCircusAction(createCircusAction (action2.getCircusAction()));
			action3.setName(action2.getName());//.setChannelSet(createChannelSet ((CircusChannelSet)action2.getChannelSet()));
			action3.getAnns().addAll(action2.getAnns());
			return action3;
		}
		/*
		else (do for other circus unary actions)
		 * */
		else if (action instanceof SkipAction) {
			return f.createSkipAction();
		}
		else if (action instanceof StopAction) {
			return f.createStopAction();
		}
		else if (action instanceof AssignmentCommand){
			AssignmentCommand ac = f.createAssignmentCommand();
			AssignmentPairs ap = f.createAssignmentPairs(
					FactoryUtil.createZNameList((ZNameList)((AssignmentCommand)action).getAssignmentPairs().getLHS()),
					FactoryUtil.createZExprList((ZExprList)((AssignmentCommand)action).getAssignmentPairs().getRHS())
			);
			ac.setAssignmentPairs(ap);
			ac.getAnns().addAll(action.getAnns());
			return ac;
		}
		else if (action instanceof IfGuardedCommand){
			IfGuardedCommand ifgc = f.createIfGuardedCommand();
			CircusActionList cal = ((IfGuardedCommand)action).getGuardedActionList();
			CircusActionList cal2 = f.createCircusActionList();
			int size = cal.size();
			for (int i = 0; i < size; i++) {
				GuardedAction ga = (GuardedAction) cal.get(i);
				cal2.add(createCircusAction (ga));
			}
			ifgc.setActionList(cal2);
			ifgc.getAnns().addAll(action.getAnns());
			//ifgc.setAssignmentPairs(((AssignmentCommand)action).getAssignmentPairs());
			return ifgc;
		}
		else if (action instanceof VarDeclCommand) {
			VarDeclCommand commandedAction = (VarDeclCommand)action;
			VarDeclCommand vdc = f.createVarDeclCommand();
			vdc.setCircusAction(createCircusAction (commandedAction.getCircusAction()));
			vdc.setDeclList(createZDeclList (commandedAction.getZDeclList()));
			return vdc;
		}
		/*else if (){
			//TODO do for other circus commands
		}*/
		else {
			ExceptionUtil.throwException (this.getClass() + ".createCircusAction :: Not possible to invoke this method for " + action.getClass());
			return f.createStopAction();
		}
	}
	public CircusProcess createCircusProcess (CircusProcess process) {
		//TODO NAO TESTADO! DEDICAR UMA ATENCAO ESPECIAL AOS BLOCOS DE ACOES HIDE, GUARDED, PARALLEL E INTERLEAVE,
			//QUE TEM PERIGO DE ELAS CAIREM NA ARMADILHA DA IGUALDADE ENTRE OS OBJETOS
		if (process instanceof ParamProcess) {
			Factory f = new Factory ();
			ParamProcess param = f.createParamProcess();
			param.setDeclList(((ParamProcess)process).getDeclList());
			param.setCircusProcess(createCircusProcess (((ParamProcess)process).getCircusBasicProcess()));
			return param;
		}
		else if (process instanceof BasicProcess) {
			Factory f = new Factory ();
			BasicProcess basic = f.createBasicProcess();
			basic.setParaList(((BasicProcess)process).getParaList());
			return basic;
		}
		else if (process instanceof ExtChoiceProcess) {
			ExtChoiceProcess process2 = (ExtChoiceProcess) process;
			ExtChoiceProcess ecp = f.createExtChoiceProcess();
			ecp.setLeftProcess(createCircusProcess (process2.getLeftProcess()));
			ecp.setRightProcess(createCircusProcess (process2.getRightProcess()));
			ecp.getAnns().addAll(process2.getLeftProcess().getAnns());
			ecp.getAnns().addAll(process2.getRightProcess().getAnns());
			return ecp;
		}
		else if (process instanceof IntChoiceProcess) {
			IntChoiceProcess process2 = (IntChoiceProcess) process;
			IntChoiceProcess ecp = f.createIntChoiceProcess();
			ecp.setLeftProcess(createCircusProcess (process2.getLeftProcess()));
			ecp.setRightProcess(createCircusProcess (process2.getRightProcess()));
			ecp.getAnns().addAll(process2.getLeftProcess().getAnns());
			ecp.getAnns().addAll(process2.getRightProcess().getAnns());
			return ecp;
		}
		else if (process instanceof ParallelProcess) {
			ParallelProcess process2 = (ParallelProcess) process;
			ParallelProcess pp = f.createParallelProcess();
			pp.setLeftProcess(createCircusProcess (process2.getLeftProcess()));
			pp.setRightProcess(createCircusProcess (process2.getRightProcess()));
			pp.setChannelSet(createChannelSet ((CircusChannelSet) process2.getChannelSet()));
			pp.getAnns().addAll(process2.getLeftProcess().getAnns());
			pp.getAnns().addAll(process2.getRightProcess().getAnns());
			return pp;
		}
		else if (process instanceof AlphabetisedParallelProcess) {
			AlphabetisedParallelProcess cp2 = (AlphabetisedParallelProcess)process;
			AlphabetisedParallelProcess parallelProcess = f.createAlphabetisedParallelProcess();
			parallelProcess.setLeftAlpha (cp2.getLeftAlpha());
			parallelProcess.setRightAlpha (cp2.getRightAlpha());
			parallelProcess.setLeftProcess(createCircusProcess (cp2.getLeftProcess()));
			parallelProcess.setRightProcess(createCircusProcess (cp2.getRightProcess()));
			return parallelProcess;
		}
		else if (process instanceof InterleaveProcess) {
			InterleaveProcess process2 = (InterleaveProcess) process;
			InterleaveProcess pp = f.createInterleaveProcess();
			pp.setLeftProcess(createCircusProcess (process2.getLeftProcess()));
			pp.setRightProcess(createCircusProcess (process2.getRightProcess()));
			pp.getAnns().addAll(process2.getLeftProcess().getAnns());
			pp.getAnns().addAll(process2.getRightProcess().getAnns());
			return pp;
		}
		else if (process instanceof SeqProcess) {
			SeqProcess process2 = (SeqProcess) process;
			SeqProcess pa = f.createSeqProcess();
			pa.setLeftProcess(createCircusProcess (process2.getLeftProcess()));
			pa.setRightProcess(createCircusProcess (process2.getRightProcess()));
			pa.getAnns().addAll(process2.getLeftProcess().getAnns());
			pa.getAnns().addAll(process2.getRightProcess().getAnns());
			return pa;
		}
		else if (process instanceof CallProcess) { //TODO MANTER O OLHO AQUI!!!! getCallExpr pode nao ser suficiente para evitar o problema da igualdade indesejada entre objetos
			CallProcess process2 = f.createCallProcess ();
			process2.setCallExpr((RefExpr)createExpr (((CallProcess)process).getCallExpr()));
			process2.setActuals(((CallProcess) process).getActuals());
			process2.setUsage(((CallProcess) process).getUsage());
			//process2.setCallExpr(arg0)setExprList(((CallProcess)process).getCallExpr().getExprList());
			return process2;
		}
		else if (process instanceof HideProcess) {
			HideProcess process2 = (HideProcess) process;
			HideProcess process3 = f.createHideProcess();
			process3.setCircusProcess(createCircusProcess (process2));
			process3.setChannelSet(createChannelSet ((CircusChannelSet)process2.getChannelSet()));
			return process3;
		}
		else { //TODO TALVEZ AQUI PRECISE DE MAIS AJUSTES...
			ExceptionUtil.throwImplementationException("FactoryUtil.createCircusProcess :: ", process);
			return f.createBasicProcess();
		}
	}
}