package jcircus.newutil;

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

import javax.swing.JOptionPane;

import jcircus.anns.MuCallAnn;
import jcircus.complementaryenvs.CallsAndParamsEnv;
import jcircus.parallelism.Consumer;
import jcircus.parallelism.CopyProcessAnn;
import net.sourceforge.czt.circus.ast.Action1;
import net.sourceforge.czt.circus.ast.Action2;
import net.sourceforge.czt.circus.ast.ActionPara;
import net.sourceforge.czt.circus.ast.AssignmentCommand;
import net.sourceforge.czt.circus.ast.AssignmentPairs;
import net.sourceforge.czt.circus.ast.BasicAction;
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.ChaosAction;
import net.sourceforge.czt.circus.ast.CircusAction;
import net.sourceforge.czt.circus.ast.CircusActionList;
import net.sourceforge.czt.circus.ast.CircusCommand;
import net.sourceforge.czt.circus.ast.CircusProcess;
import net.sourceforge.czt.circus.ast.Communication;
import net.sourceforge.czt.circus.ast.ExtChoiceAction;
import net.sourceforge.czt.circus.ast.GuardedAction;
import net.sourceforge.czt.circus.ast.HideAction;
import net.sourceforge.czt.circus.ast.IfGuardedCommand;
import net.sourceforge.czt.circus.ast.IntChoiceAction;
import net.sourceforge.czt.circus.ast.InterleaveAction;
import net.sourceforge.czt.circus.ast.MuAction;
import net.sourceforge.czt.circus.ast.ParAction;
import net.sourceforge.czt.circus.ast.ParallelAction;
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.Process1;
import net.sourceforge.czt.circus.ast.Process2;
import net.sourceforge.czt.circus.ast.ProcessPara;
import net.sourceforge.czt.circus.ast.RenameAction;
import net.sourceforge.czt.circus.ast.SeqAction;
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.Decl;
import net.sourceforge.czt.z.ast.Expr;
import net.sourceforge.czt.z.ast.NarrSect;
import net.sourceforge.czt.z.ast.Para;
import net.sourceforge.czt.z.ast.Pred;
import net.sourceforge.czt.z.ast.Spec;
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.ZParaList;
import net.sourceforge.czt.z.ast.ZSect;

public class CallUtil {
	static FactoryUtil pf = new FactoryUtil ();
	
	public static Vector <String> muCalls (CircusAction action, CircusProcess process, Spec spec) {
		if (action instanceof Action2) {
			Vector <String> mucalls = muCalls (((Action2)action).getLeftAction(), process, spec);
			mucalls.addAll(muCalls (((Action2)action).getRightAction(), process, spec));
			return mucalls;
		}
		else if (action instanceof Action1 && !(action instanceof MuAction)) {
			return muCalls (((Action1)action).getCircusAction(), process, spec);
		}
		else if (action instanceof MuAction) {
			String muname = ((MuAction)action).getZName().toString();
			Vector <String> mucalls = new Vector <String> ();
			mucalls.addElement(muname);
			mucalls.addAll(muCalls(((MuAction)action).getCircusAction(), process, spec));
			return mucalls;
		}
		else if (action instanceof CallAction) {
			/*if (action.getAnn(MuCallAnn.class) == null) {}*/
			return new Vector <String> ();
			//return muCalls (getContentOfCallAction ((CallAction)action, process, spec), process, spec);
		}
		else if (action instanceof AssignmentCommand) {
			return new Vector <String> ();
		}
		else if (action instanceof IfGuardedCommand) {
			CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList();
			int size = cal.size();
			Vector <String> igccalls = new Vector <String> ();
			for (int i = 0; i < size; i++) {
				GuardedAction ga = (GuardedAction) cal.get(i);
				igccalls.addAll(muCalls (ga, process, spec));
			}
			return igccalls;
		}
		else if (action instanceof VarDeclCommand) {
			return muCalls (((VarDeclCommand)action).getCircusAction(), process, spec);
		}
		else if (action instanceof BasicAction) {
			return new Vector <String> ();
		}
		else {
			ExceptionUtil.throwImplementationException("CallUtil.muCalls", action.getClass());
			return new Vector <String> ();
		}
	}
	public CircusAction transformCallActionsIntoRealActions (CircusAction action, CircusProcess process, Spec spec) {
		if (action instanceof CallAction) {
			return getContentOfCallAction (((CallAction)action), process, spec);
		}
		else if (action instanceof Action2) {
			((Action2)action).setLeftAction(transformCallActionsIntoRealActions (((Action2)action).getLeftAction(), process, spec));
			((Action2)action).setRightAction(transformCallActionsIntoRealActions (((Action2)action).getRightAction(), process, spec));
			return action;
		}
		else return action;
	}

	private static void transformToMuAction (CircusAction action) {
		
	}

	private static Vector <String> callsWithoutDuplicates (Vector <String> callsvec) {
		Vector <String> callsvec2 = new Vector <String> ();
		for (int i = 0; i < callsvec.size(); i++) {
			if (!callsvec2.contains(callsvec.elementAt(i)))
				callsvec2.add(callsvec.elementAt(i));
		}
		return callsvec2;
	}
	public static Vector <String> recursiveCalls (CircusProcess process, Spec spec) {
		Vector <String> callsvecRec = new Vector <String> ();
		Vector <String> actionParaNames = new Vector <String> ();
		BasicProcess bp;
		if (process instanceof ParamProcess) {
			bp = ((ParamProcess)process).getCircusBasicProcess();
		}
		else {
			bp = (BasicProcess)process;
		}
		ZParaList paras = bp.getZParaList();
		Vector <String> alreadySeen;
		for (int i = 0; i < paras.size(); i++) {
			if (paras.get(i) instanceof ActionPara) {
				ActionPara actionPara = ((ActionPara)paras.get(i));
				alreadySeen = new Vector <String> ();
				CircusAction action = ((ActionPara)paras.get(i)).getCircusAction();
				
				String paraName = actionPara.getName().toString();
				HashMap <String, Integer> allCalls = calls (action, process, spec);
				boolean hasRecursiveCall = allCalls.keySet().contains(paraName);//hasRecursiveCall (action, process, paraName, alreadySeen);
				if (hasRecursiveCall) {
					callsvecRec.add(((ActionPara)paras.get(i)).getName().toString());
				}
				System.out.print("");
			}
		}
		return callsvecRec;
	}

	public static Vector <String> recursiveCalls (CircusAction action, CircusProcess process, Spec spec) {
		Vector <String> all = recursiveCalls (process, spec);
		HashMap <String, Integer> fromAction = calls (action, process, spec);
		Vector <String> ret = new Vector <String> ();
		for (int i = 0; i < all.size(); i++) {
			if (fromAction.keySet().contains(all.elementAt(i))) {
				if (fromAction.get(all.elementAt(i)) > 1) {
					ret.addElement(all.elementAt(i));
				}
			}
		}
		return ret;
	}

	public static HashMap <String, Integer> calls (CircusAction action, CircusProcess process, Spec spec) {
		Vector <String> mucalls = muCalls (action, process, spec);
		return calls (action, process, new HashMap <String, Integer> (), mucalls/*new Vector <String> ()*/, spec);
	}
	public static HashMap <String, Integer> calls (CircusAction action, CircusProcess process, HashMap <String, Integer> callsvec, Vector <String> mucalls, Spec spec) {
		if (action instanceof PrefixingAction) {
			HashMap <String, Integer> callsvec2 = new HashMap <String, Integer> ();
			callsvec2.putAll(callsvec);
			callsvec2.putAll(calls (((PrefixingAction)action).getCircusAction(), process, callsvec, mucalls, spec));
			return callsvec2;
		}
		else if (action instanceof Action2) {
			Action2 action2 = (Action2) pf.createCircusAction(action);
			HashMap <String, Integer> callsvec2 = new HashMap <String, Integer> ();
			callsvec2.putAll(callsvec);
			callsvec2.putAll(calls (action2.getLeftAction(), process, callsvec, mucalls, spec));
			callsvec2.putAll(calls (action2.getRightAction(), process, callsvec, mucalls, spec));
			return callsvec2;
		}
		else if (action instanceof CallAction) {
			String name = ((CallAction)action).getName().toString();
			//HashMap <String, Integer> callsvec2 = new HashMap <String, Integer> ();
			//callsvec2.putAll(callsvec);
			if (!callsvec.keySet().contains(name)) {
				callsvec.put(name, 1);
				if (!mucalls.contains(name))
					callsvec.putAll(calls (getContentOfCallAction ((CallAction)action, process, spec), process, callsvec, mucalls, spec));
				return callsvec;
			}
			else if (callsvec.keySet().contains(name)) {
				callsvec.put(name, callsvec.get(name) + 1);
				return callsvec;
			}
			else
				return callsvec;
		}
		else if (action instanceof CircusCommand) {
			if (action instanceof AssignmentCommand) {
				return new HashMap <String, Integer> ();
			}
			else if (action instanceof IfGuardedCommand) {
				CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList();
				int size = cal.size();
				HashMap <String, Integer> igccalls = new HashMap <String, Integer> ();
				for (int i = 0; i < size; i++) {
					GuardedAction ga = (GuardedAction) cal.get(i);
					igccalls.putAll(calls (ga, process, callsvec, mucalls, spec));
				}
				return igccalls;
			}
			else if (action instanceof VarDeclCommand) {
				return calls (((VarDeclCommand)action).getCircusAction(), process, callsvec, mucalls, spec);
			}
			else {
				ExceptionUtil.throwImplementationException("CallUtil.calls", action.getClass());
				return callsvec;
			}
		}
		else if (action instanceof ParamAction) {
			return calls (((ParamAction)action).getCircusAction(), process, callsvec, mucalls, spec);
		}
		else if (action instanceof GuardedAction) {
			return calls (((GuardedAction)action).getCircusAction(), process, callsvec, mucalls, spec);
		}
		else if (action instanceof MuAction) {
			mucalls.addElement(((MuAction)action).getZName().toString());
			return calls (((MuAction)action).getCircusAction(), process, callsvec, mucalls, spec);
		}
		else if (action instanceof BasicAction) {
			return new HashMap <String, Integer> ();
		}
		else {
			ExceptionUtil.throwImplementationException("CallUtil.calls", action.getClass());
			return callsvec;
		}
	}
	public static CircusAction seqVersionOfAction (CircusAction action) {
		Factory f = new Factory ();
		if (action instanceof PrefixingAction) {
			SeqAction seq = f.createSeqAction();
			Communication c = ((PrefixingAction)action).getCommunication();
			CircusAction ca = ((PrefixingAction)action).getCircusAction();
			seq.setLeftAction (f.createPrefixingAction (f.createSkipAction(), c));
			seq.setRightAction(seqVersionOfAction (((PrefixingAction) action).getCircusAction()));
			seq.getAnns().addAll(action.getAnns());
			return seq;
		}
		else if (action instanceof ExtChoiceAction) {
			ExtChoiceAction eca = f.createExtChoiceAction();
			Action2 action2 = (Action2)action;
			CircusAction left = action2.getLeftAction();
			CircusAction right = action2.getRightAction();
			if (left instanceof PrefixingAction || right instanceof PrefixingAction) {
				if (left instanceof PrefixingAction && !(right instanceof PrefixingAction)) {
					CircusAction pfLeft = ((PrefixingAction)left).getCircusAction ();
					pfLeft = seqVersionOfAction (pfLeft);
					((PrefixingAction)left).setCircusAction(pfLeft);
					eca.setLeftAction (left);
					eca.setRightAction (seqVersionOfAction (right));
					//eca.getAnns().addAll(action.getAnns());
					//return eca;
				}
				else if (!(left instanceof PrefixingAction) && right instanceof PrefixingAction) {
					CircusAction pfRight = ((PrefixingAction)right).getCircusAction ();
					pfRight = seqVersionOfAction (pfRight);
					((PrefixingAction)right).setCircusAction(pfRight);
					eca.setRightAction (right);
					eca.setLeftAction (seqVersionOfAction (left));
					//eca.setRightAction (right);
					//eca.getAnns().addAll(action.getAnns());
					//return eca;
				}
				else /*if (left instanceof PrefixingAction && right instanceof PrefixingAction)*/ {
					CircusAction pfLeft = ((PrefixingAction)left).getCircusAction ();
					CircusAction pfRight = ((PrefixingAction)right).getCircusAction ();				
					pfLeft = seqVersionOfAction (pfLeft);
					pfRight = seqVersionOfAction (pfRight);
					((PrefixingAction)left).setCircusAction(pfLeft);
					((PrefixingAction)right).setCircusAction(pfRight);
					eca.setLeftAction (left);
					eca.setRightAction (right);
					eca.getAnns().addAll(action.getAnns());
					return eca;
				}
				/*eca.setLeftAction (left);
				eca.setRightAction (right);*/
				eca.getAnns().addAll(action.getAnns());
				return eca;
			}
			else {
				eca.setLeftAction(seqVersionOfAction (left));
				eca.setRightAction(seqVersionOfAction (right));
				eca.getAnns().addAll(action.getAnns());
				return eca;
			}
		}
		else if (action instanceof IntChoiceAction) {
			IntChoiceAction eca = f.createIntChoiceAction();
			Action2 action2 = (Action2)action;
			eca.setLeftAction(seqVersionOfAction (action2.getLeftAction()));
			eca.setRightAction(seqVersionOfAction (action2.getRightAction()));
			eca.getAnns().addAll(action.getAnns());
			return eca;
		}
		else if (action instanceof ParallelAction) {
			ParallelAction eca = f.createParallelAction();
			Action2 action2 = (Action2)action;
			eca.setLeftAction(seqVersionOfAction (action2.getLeftAction()));
			eca.setRightAction(seqVersionOfAction (action2.getRightAction()));
			eca.setLeftNameSet(((ParallelAction)action).getLeftNameSet());
			eca.setRightNameSet(((ParallelAction)action).getRightNameSet());
			eca.setChannelSet(((ParallelAction)action).getChannelSet());
			eca.getAnns().addAll(action.getAnns());
			return eca;
		}
		else if (action instanceof InterleaveAction) {
			InterleaveAction eca = f.createInterleaveAction();
			Action2 action2 = (Action2)action;
			eca.setLeftAction(seqVersionOfAction (action2.getLeftAction()));
			eca.setRightAction(seqVersionOfAction (action2.getRightAction()));
			eca.getAnns().addAll(action.getAnns());
			return eca;
		}
		else if (action instanceof SeqAction) {
			SeqAction eca = f.createSeqAction();
			Action2 action2 = (Action2)action;
			eca.setLeftAction(seqVersionOfAction (action2.getLeftAction()));
			eca.setRightAction(seqVersionOfAction (action2.getRightAction()));
			eca.getAnns().addAll(action.getAnns());
			return eca;
		}
		else if (action instanceof MuAction) {
			MuAction mu = f.createMuAction();
			mu.setName(((MuAction)action).getName());
			mu.setCircusAction(seqVersionOfAction (((MuAction)action).getCircusAction()));
			mu.getAnns().addAll(action.getAnns());
			return mu;
		}
		else if (action instanceof CallAction) {
			CallAction ca = f.createCallAction(f.createZName (((CallAction)action).getZName().toString()), f.createZExprList());
			ca.getAnns().addAll(action.getAnns());
			return ca;
		}
		else if (action instanceof RenameAction) {
			//CallAction ca = f.createRenameAction(f.createZName (((RenameAction)action).getZName().toString()), f.createZExprList());
			RenameAction ra = f.createRenameAction();
			ra.setAssignmentPairs(((RenameAction)action).getAssignmentPairs());
			ra.setCircusAction(seqVersionOfAction (((RenameAction)action).getCircusAction()));
			ra.getAnns().addAll(action.getAnns());
			return ra;
		}
		else if (action instanceof GuardedAction) {
			GuardedAction ga = f.createGuardedAction ();
			ga.setPred(((GuardedAction)action).getPred());
			ga.setCircusAction(seqVersionOfAction (((GuardedAction)action).getCircusAction()));
			return ga;
		}
		/*else if (action instanceof HideAction) { //TODO
			return 
		}*/
		else {
			return action;
			/*SkipAction skp = f.createSkipAction();
			return skp;*/
		}
	}
	public static CircusAction getContentOfCallAction (CallAction ca, CircusProcess process, Spec spec) {
		//Só vai retornar o conteúdo do primeiro nível.
			//Ex: Se A ^= B, e B = a -> SKIP, o conteúdo de A será B. E o conteúdo de B será a -> SKIP
			//Favor não mexer nesta condição,
				//pois pode dar Stack Overflow caso façamos o conteúdo do conteúdo 
					//da ação ser retornado no caso de o conteúdo ser uma ação de chamada
		Factory f = new Factory ();
		String actionName = ca.getName().toString();
		CircusAction returnedAction = null;
		if (process instanceof BasicProcess) {
			List <? extends Para> actionParas = (List <? extends Para>) ((BasicProcess)process).getZParaList();
			int size = actionParas.size();
			for (int i = 0; i < size; i++) {
				Para para = actionParas.get(i);
				if (para instanceof ActionPara) {
					if (((ActionPara)para).getZName().toString().equals(actionName)) {
						CircusAction currentaction = ((ActionPara)para).getCircusAction();
						/*if (ca.getZExprList() != null) {
							if (ca.getZExprList().size() > 0) {
								ZExprList exprs = ca.getZExprList();
								ZDeclList params = pf.createZDeclList(((ParamAction)currentaction).getZDeclList());
								params = DeclUtil.renameDecls2pNameIndex(params, actionName);
								returnedAction = ExprUtil.actionWithUpdatedExpression(params, exprs, currentaction);
							}
						}*/
						//else {
							returnedAction = pf.createCircusAction(currentaction);
						//}
					}
				}
			}
		}
		else if (process instanceof ParamProcess) {
			List <? extends Para> actionParas = (List <? extends Para>) ((ParamProcess)process).getCircusBasicProcess().getZParaList(); //falta testar esta linha
			int size = actionParas.size();
			for (int i = 0; i < size; i++) {
				Para para = actionParas.get(i);
				if (para instanceof ActionPara) {
					if (((ActionPara)para).getZName().toString().equals(actionName)) {
						returnedAction = pf.createCircusAction(((ActionPara)para).getCircusAction());
						returnedAction.getAnns().addAll(((ActionPara)para).getCircusAction().getAnns());
					}
				}
			}
		}
		else if (process instanceof Process2) {
			CircusAction content1 = pf.createCircusAction (getContentOfCallAction (ca, ((Process2)process).getLeftProcess(), spec));
			CircusAction content2 = pf.createCircusAction (getContentOfCallAction (ca, ((Process2)process).getRightProcess(), spec));
			if (content1 != null) {
				returnedAction = content1;
			}
			else if (content2 != null) {
				returnedAction = content2;
			}
		}
		else if (process instanceof CallProcess) {
			CircusProcess contentOfProcess = ProcessUtil.getContentOfCallProcess (process, spec);
			returnedAction = pf.createCircusAction(getContentOfCallAction (ca, contentOfProcess, spec));
		}
		if (returnedAction == null) {
			if (/*actionName.equals("X") ||*/ca.getAnn(MuCallAnn.class) != null) {
				System.out.println ("*******************\nAction " + actionName + " was not found on process, in the first search. " +
						"If it starts with \"X\", then no problem, it is a recursive action.\n*******************\n");
			}
			else {
				ExceptionUtil.throwException("CallUtil.getContentOfCallAction :: CallAction is null... Cannot return anything for the content of " + ca.getZName().toString());
			}
		}
		return returnedAction;
	}
	public static CircusAction expandAction (Vector <String> actionNames, CircusAction action, CircusProcess process, Spec spec) {
		Vector <String> mucalls = muCalls (action, process, spec);
		HashMap <String, Integer> calls = calls (action, process, spec);
		CircusAction step1 = expandAction (mucalls, actionNames, action, process, new Consumer (toVectorString (calls.keySet().toArray())/*new Vector <String> ()*/), spec, new CallsAndParamsEnv ());
		//CircusAction step2 = expandActionStep2 (mucalls, actionNames, step1, process, new Consumer (toVectorString (calls.keySet().toArray())/*new Vector <String> ()*/), spec);
		//CircusAction returnaction = 
		return step1;
	}
	public static CircusAction transformParamAction (ParamAction action, CallAction callaction, Spec spec, Consumer c, String actionname) {
		ZExprList exprlist = callaction.getZExprList();
		return transformParamAction (action, exprlist, spec, c, actionname);
	}
	public static CircusAction transformParamAction (ParamAction action, ZExprList exprlist, Spec spec, Consumer c, String actionname) {
		Factory f = new Factory ();
		FactoryUtil fu = new FactoryUtil ();
		ZDeclList declList = fu.createZDeclList(action.getZDeclList());
		AssignmentCommand assig = f.createAssignmentCommand ();
		AssignmentPairs pairs = f.createAssignmentPairs();
		ZNameList namelist = f.createZNameList();
		int size = declList.size();
		for (int i = 0; i < size; i++) {
			Decl decl = declList.get(i);
			if (decl instanceof VarDecl) {
				VarDecl vardecl = (VarDecl)decl;
				ZNameList declsvardecl = vardecl.getZNameList();
				for (int j = 0; j < declsvardecl.size(); j++) {
					ZName name = (ZName) declsvardecl.get(j);
					namelist.add(name);
				}
			}
		}
		pairs.setLHS(namelist);
		pairs.setRHS(exprlist);
		assig.setAssignmentPairs(pairs);
		SeqAction almostfinalaction = f.createSeqAction();
		almostfinalaction.setLeftAction(assig);
		CircusAction accccc = action.getCircusAction();
		almostfinalaction.setRightAction(fu.createCircusAction (action.getCircusAction()));
		VarDeclCommand finalaction = f.createVarDeclCommand();
		finalaction.setDeclList(declList);
		finalaction.setCircusAction(almostfinalaction);
		System.out.println (PrinterUtil.printAction(finalaction, spec));
		if (c.callStatus(actionname) != Consumer.NORMALCALL
				&&
			c.callStatus(actionname) != Consumer.RECSTART
			) {
			return almostfinalaction;
		}
		return finalaction;
	}
	
	public static void addMuCallAnns (CircusAction action, CircusProcess process, Spec spec) {
		Vector <String> mucalls = muCalls (action, process, spec);
		addMuCallAnns (action, process, spec, mucalls);
	}
	public static void addMuCallAnns (CircusAction action, CircusProcess process, Spec spec, Vector <String> mucalls) {
		if (action instanceof Action2) {
			CircusAction left = ((Action2)action).getLeftAction();
			CircusAction right = ((Action2)action).getRightAction();
			addMuCallAnns (left, process, spec, mucalls);
			addMuCallAnns (right, process, spec, mucalls);
		}
		else if (action instanceof Action1) {
			CircusAction act1 = ((Action1)action).getCircusAction();
			addMuCallAnns (act1, process, spec, mucalls);
		}
		else if (action instanceof CallAction) {
			String actionname = ((CallAction)action).getZName().toString();
			if (mucalls.contains(actionname)) {
				action.getAnns().add(new MuCallAnn ());
			}
		}
		else if (action instanceof CircusCommand) {
			if (action instanceof AssignmentCommand) {
				//Não faz nada
			}
			else if (action instanceof IfGuardedCommand) {
				CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList();
				int size = cal.size();
				for (int i = 0; i < size; i++) {
					GuardedAction ga = (GuardedAction) cal.get(i);
					addMuCallAnns (ga, process, spec, mucalls);
				}
			}
			else if (action instanceof VarDeclCommand) {
				addMuCallAnns (((VarDeclCommand)action).getCircusAction(), process, spec, mucalls);
			}
			else {
				ExceptionUtil.throwImplementationException("CallUtil.addMuCallAnns", action.getClass());
			}
		}
		else if (action instanceof BasicAction) {
			//Não faz nada
		}
		else {
			ExceptionUtil.throwImplementationException("CallUtil.addMuCallAnns", action.getClass());
		}
	}

	private static AssignmentCommand recStartAssignmentCommand (ZDeclList decllist, ZExprList exprs, String actionname) {
		Factory f = new Factory ();
		FactoryUtil fu = new FactoryUtil ();
		Vector <String> vecnames = DeclUtil.declListAsVector(decllist);
		ZNameList names = f.createZNameList();
		int size = exprs.size();
		for (int i = 0; i < size; i++) {
			String paramname = "p" + actionname + i;
			//String paramname = vecnames.elementAt(i);
			names.add(f.createZName(paramname));
		}
		AssignmentPairs asspairs = f.createAssignmentPairs(names, fu.createZExprList(exprs));
		AssignmentCommand asscomm = f.createAssignmentCommand();
		asscomm.setAssignmentPairs(asspairs);
		return asscomm;
	}
	private static AssignmentCommand recCallAssignmentCommand (ParamAction action, ZExprList exprs, String actionname) {
		Vector <String> targetvars = ParamUtil.getParamVars (action);
		Factory f = new Factory ();
		FactoryUtil fu = new FactoryUtil ();
		ZNameList names = f.createZNameList ();
		ZExprList newexprs = fu.createZExprList (exprs);
		int size = exprs.size();
		Vector <String> vecnames = DeclUtil.declListAsVector(action.getZDeclList());
		for (int i = 0; i < size; i++) {
			String paramname = "p" + actionname + i;
			//String paramname = vecnames.elementAt(i);
			names.add(f.createZName(paramname));
			Expr currentexpr = newexprs.get(i);
			ExprUtil.replaceVarName (targetvars.get(i), paramname, currentexpr);
		}
		AssignmentPairs asspairs = f.createAssignmentPairs(names, newexprs);
		AssignmentCommand asscomm = f.createAssignmentCommand();
		asscomm.setAssignmentPairs(asspairs);
		return asscomm;
	}
	/*public static CallsAndParamsEnv originalCallsAndParamsEnv (CircusAction action, CallsAndParamsEnv cape) {
		if (action instanceof CallAction) {
			CallAction callaction = (CallAction)action;
			
			//if (callaction.getZExprList().size() > 0) {
				//CallsAndParamsEnv newcape = new CallsAndParamsEnv (cape);
			//}
		}
	}*/
	public static CircusAction expandAction (Vector <String> mus, Vector <String> actionNames, CircusAction action, CircusProcess process, Consumer c, Spec spec, CallsAndParamsEnv cape) {
		Factory f = new Factory ();
		FactoryUtil fu = new FactoryUtil ();
		if (action instanceof ParamAction) {
			ParamAction pact = f.createParamAction();
			pact.setCircusAction(fu.createCircusAction (expandAction (mus, actionNames, ((ParamAction)action).getCircusAction(), process, c, spec, cape)));
			pact.setDeclList(fu.createZDeclList(((ParamAction)action).getZDeclList()));
			return pact;
		}
		else if (action instanceof CallAction) {
			String callName = ((CallAction)action).getName().toString();
			if (mus.contains(callName)) {
				action.getAnns().add(new MuCallAnn ());
			}
			if (action.getAnn(MuCallAnn.class) != null) {
				return fu.createCircusAction (action);
			}
			CircusAction content = getContentOfCallAction ((CallAction)action, process, spec);
			CircusAction updatedContent = pf.createCircusAction (content);
			Vector <String> paramvars = new Vector <String> ();
			if (content instanceof ParamAction) {
				paramvars = ParamUtil.getParamVars((ParamAction)content);
				updatedContent = ((ParamAction)updatedContent).getCircusAction ();
				ZDeclList decls2beupdated = pf.createZDeclList(((ParamAction)content).getZDeclList());
				ZExprList newactexprs = ExprUtil.pActname2ExprList (decls2beupdated.size(), ((CallAction)action).getName().toString());
				updatedContent = ExprUtil.actionWithUpdatedExpression (decls2beupdated, newactexprs, updatedContent, process, spec, mus, actionNames, c);
				System.out.println ("content :: " + PrinterUtil.printAction(content, spec));
				System.out.println ("updatedContent :: " + PrinterUtil.printAction(updatedContent, spec));
				System.out.print ("");
			}
			if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.RECSTART) {
				c.incrementStatus(((CallAction)action).getName().toString());
				MuAction mu = f.createMuAction();
				mu.setName(f.createZName("X" + ((CallAction)action).getName().toString()));
				CircusAction act = fu.createCircusAction (expandAction (new Vector <String> (mus), actionNames, updatedContent, process, c, spec, cape));
				mu.getAnns().addAll(act.getAnns());
				mu.setCircusAction (act);
				if (((CallAction)action).getZExprList() != null) {
					if (((CallAction)action).getZExprList().size() > 0) {
						AssignmentCommand asscomm = recStartAssignmentCommand (((ParamAction)content).getZDeclList(), ((CallAction)action).getZExprList(), ((CallAction)action).getZName().toString());
						SeqAction seq = f.createSeqAction();
						seq.setLeftAction(asscomm);
						seq.setRightAction (mu);
						ZDeclList newdecllist = fu.createZDeclList (DeclUtil.correspondentRenamedDeclList(((ParamAction)content).getZDeclList(), ((CallAction)action).getName().toString()));
						VarDeclCommand vdc = f.createVarDeclCommand();
						vdc.setDeclList(newdecllist);
						vdc.setCircusAction(seq);
						c.decrementStatus(((CallAction)action).getName().toString());
						return vdc;
					}
				}
				c.decrementStatus(((CallAction)action).getName().toString());
				return mu;
			}
			else if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.RECCALL) {
				c.incrementStatus(((CallAction)action).getName().toString());
				CallAction act2 = f.createCallAction ();
				act2.setName(f.createZName("X" + ((CallAction)action).getName().toString()));
				act2.setExprList (fu.createZExprList (((CallAction)action).getZExprList()));
				act2.getAnns().add(new MuCallAnn ());
				if (((CallAction)action).getZExprList() != null) {
					if (((CallAction)action).getZExprList().size() > 0 && content instanceof ParamAction) {
						ZExprList exprs = ExprUtil.fromVectorToRefExpr(paramvars);
						//updatedContent = ExprUtil.actionWithUpdatedExpression(decls2beupdated, updatedContent);
						AssignmentCommand asscomm = recCallAssignmentCommand ((ParamAction)content, ((CallAction)action).getZExprList(), ((CallAction)action).getName().toString());
						SeqAction seq = f.createSeqAction();
						seq.setLeftAction(asscomm);
						seq.setRightAction (act2);
						VarDeclCommand vdc = f.createVarDeclCommand ();
						vdc.setDeclList(fu.createZDeclList(((ParamAction)content).getZDeclList()));
						vdc.setCircusAction(seq);
						c.decrementStatus(((CallAction)action).getName().toString());
						return vdc;
					}
				}
				c.decrementStatus(((CallAction)action).getName().toString());
				return act2;
			}
			else if (c.callStatus (((CallAction)action).getName().toString()) == Consumer.NORMALCALL) {
				CircusAction normalcallreturn = fu.createCircusAction (
						expandAction (
								new Vector <String> (mus), 
								actionNames,
								content,
								process, c, spec, cape)
				);
				return normalcallreturn;
			}
			else {
				return action;
			}
			/*
			if (content instanceof ParamAction) {
				paramvars = ParamUtil.getParamVars((ParamAction)content);
				updatedContent = ((ParamAction)updatedContent).getCircusAction ();
				ZDeclList decls2beupdated = pf.createZDeclList(((ParamAction)content).getZDeclList());
				ZExprList newactexprs = ExprUtil.pActname2ExprList (decls2beupdated.size(), ((CallAction)action).getName().toString());
				updatedContent = ExprUtil.actionWithUpdatedExpression (decls2beupdated, newactexprs, updatedContent, process, spec, mus, actionNames, c);
				System.out.println ("content :: " + PrinterUtil.printAction(content, spec));
				System.out.println ("updatedContent :: " + PrinterUtil.printAction(updatedContent, spec));
				System.out.print ("");
			}
			*/
		}
		else if (action instanceof PrefixingAction) {
			PrefixingAction pa = f.createPrefixingAction();
			pa.setCommunication(fu.createCommunication(((PrefixingAction)action).getCommunication()));
			pa.setCircusAction(expandAction (new Vector <String> (mus), actionNames, ((Action1)action).getCircusAction(), process, c, spec, cape));
			return pa;
		}
		else if (action instanceof MuAction) {
			Vector <String> newmus = new Vector <String> (mus);
			newmus.addElement (((MuAction)action).getName().toString());
			MuAction mu = f.createMuAction ();
			mu.setName(((MuAction)action).getName());
			mu.setCircusAction(expandAction (newmus, actionNames, ((MuAction)action).getCircusAction(), process, c, spec, cape));
			return mu;
		}
		/*
		 TODO os outros elses de Action1: HideAction, e etc
		 * */
		else if (action instanceof GuardedAction) {
			GuardedAction ga = f.createGuardedAction ();
			ga.setPred(((GuardedAction)action).getPred());
			ga.setCircusAction(expandAction (new Vector <String> (mus), actionNames, ((GuardedAction)action).getCircusAction(), process, c, spec, cape));
			return ga;
		}
		else if (action instanceof CircusCommand) {
			if (action instanceof AssignmentCommand) {
				AssignmentPairs apa = ((AssignmentCommand)action).getAssignmentPairs();
				AssignmentPairs ap = f.createAssignmentPairs(apa.getLHS(), apa.getRHS());
				return f.createAssignmentCommand(ap);
			}
			else if (action instanceof VarDeclCommand) {
				CircusAction caction = expandAction (new Vector <String> (mus), actionNames, ((VarDeclCommand)action).getCircusAction(), process, c, spec, cape);
				VarDeclCommand vdc = f.createVarDeclCommand ();
				vdc.setCircusAction(caction);
				vdc.setDeclList(((VarDeclCommand)action).getDeclList());
				vdc.getAnns().addAll(action.getAnns());
				return vdc;
			}
			else if (action instanceof IfGuardedCommand) {
				CircusActionList cal = ((IfGuardedCommand) action).getGuardedActionList();
				IfGuardedCommand newgc = f.createIfGuardedCommand();
				CircusActionList gal = f.createCircusActionList();
				int size = cal.size();
				for (int i = 0; i < size; i++) {
					GuardedAction ga = (GuardedAction) cal.get(i);
					GuardedAction newga = f.createGuardedAction();
					newga.setPred(ga.getPred());
					newga.setCircusAction(expandAction (new Vector <String> (mus), actionNames, fu.createCircusAction(ga.getCircusAction()), process, c, spec, cape));
					gal.add(newga);
				}
				newgc.setActionList(gal);
				return newgc;
			}
			else {
				ExceptionUtil.throwImplementationException("CallUtil.expandAction", action.getClass());
				return action;
			}
		}
		else if (action instanceof Action2) {
			Action2 action2 = ((Action2)action);
			/*Consumer cleft = new Consumer (c);
			Consumer cright = new Consumer (c);
			if (
				!(action instanceof SeqAction)	
					//action instanceof ParAction
			) {
				action2.setLeftAction(expandAction (new Vector <String> (mus), actionNames, ((Action2)action).getLeftAction(), process, cleft, spec));
				action2.setRightAction(expandAction (new Vector <String> (mus), actionNames, ((Action2)action).getRightAction(), process, cright, spec));
				System.out.print ("");
			}
			else {*/
				action2.setLeftAction(expandAction (new Vector <String> (mus), actionNames, ((Action2)action).getLeftAction(), process, c, spec, cape));
				action2.setRightAction(expandAction (new Vector <String> (mus), actionNames, ((Action2)action).getRightAction(), process, c, spec, cape));
			//}
			if (action instanceof ParallelAction) {
				((ParallelAction)action2).setChannelSet(((ParallelAction)action).getChannelSet());
				((ParallelAction)action2).setLeftNameSet(((ParallelAction)action).getLeftNameSet());
				((ParallelAction)action2).setRightNameSet(((ParallelAction)action).getRightNameSet());
			}
			else if (action instanceof InterleaveAction) {
				((InterleaveAction)action2).setLeftNameSet(((InterleaveAction)action).getLeftNameSet());
				((InterleaveAction)action2).setRightNameSet(((InterleaveAction)action).getRightNameSet());				
			}
			return action2;
		}
		else if (action instanceof SkipAction) {
			return f.createSkipAction();
		}
		else if (action instanceof StopAction) {
			return f.createStopAction();
		}
		else if (action instanceof ChaosAction) {
			return f.createChaosAction();
		}
		else {
			//return f.createSkipAction();
			return action;
		}
	}

	private static Vector <String> toVectorString (Object [] o) {
		Vector <String> vec = new Vector <String> ();
		for (int i = 0; i < o.length; i++) {
			vec.addElement((String)o[i]);
		}
		return vec;
	}
	public static ActionPara similarExpandedAndRecursiveActionPara (ActionPara para, CircusProcess process, Spec spec) {
		Factory f = new Factory ();
		FactoryUtil fu = new FactoryUtil();
		CircusAction action = para.getCircusAction();
		action.getAnns().addAll(para.getCircusAction().getAnns());
		Vector <String> calls = toVectorString (calls (action, process, spec).keySet().toArray());
		Consumer c = new Consumer (calls);
		Vector <String> actionNames = new Vector <String> ();
		String actionName = para.getZName().toString();
		actionNames.addElement(actionName);
		if (calls.contains(para.getName().toString()) && !(action instanceof ParamAction) && !(para.getName().toString().contains("$$mainAction"))) {
			c.setStatus(Consumer.RECSTART, para.getName().toString());
			MuAction mu = f.createMuAction();
			mu.setName(f.createZName ("X" + para.getName().toString()));
			Vector <String> mucalls = muCalls (action, process, spec);
			CircusAction action3 = fu.createCircusAction (expandAction (mucalls, actionNames, action, process, c, spec, new CallsAndParamsEnv ()));
			action3.getAnns().addAll(para.getCircusAction().getAnns());
			mu.setCircusAction(action3);
			para.setCircusAction(mu);
			return para;
		}
		else {
			return para;
		}
	}
	
//NOVOS MÉTODOS
	public static void expandCallsOnMainActions (Spec spec, boolean expanded) {
    	ZSect zSect;
    	if (spec.getSect().get(0) instanceof NarrSect)
    		zSect = (ZSect) spec.getSect().get(1);
    	else
    		zSect = (ZSect) spec.getSect().get(0);
        ZParaList paras = (ZParaList) zSect.getParaList();
		for (int i = 0; i < paras.size(); i++) {
			if (paras.get(i) instanceof ProcessPara) {
            	ProcessPara para = (ProcessPara) paras.get(i); //Aqui vai invocar os visitadores dos paragrafos que nao forem narrativos (com texto), ou de tags de Latex
            	String paraName = para.getZName().toString();
            	CircusProcess process = ((ProcessPara)para).getCircusProcess();
            	System.out.println (PrinterUtil.specAsString (spec));
            	expandCallsOnMainActions (process, paraName, spec);
			}
		}
		//expanded = true;
	}
	public static void transformActionParasToRecursive (ZParaList paralist, CircusProcess process, Spec spec) {
		int size = paralist.size();
		FactoryUtil fu = new FactoryUtil ();
		for (int i = 0; i < size; i++) {
			Para para = paralist.get(i);
			if (para instanceof ActionPara) {
				String name = ((ActionPara)para).getZName().toString();
				paralist.set(i, similarExpandedAndRecursiveActionPara ((ActionPara)para, process, spec));
				System.out.print ("");
			}
		}
		System.out.print ("");
	}
	private static void expandCallsOnMainActions (CircusProcess process, String paraName, Spec spec) {
		FactoryUtil fu = new FactoryUtil ();
		if (process instanceof BasicProcess) {
			ZParaList paras = ((BasicProcess)process).getZParaList();
			CircusAction mainactantes = ((BasicProcess)process).getMainAction();
			//transformActionParasToRecursive (paras, process, spec);
			CircusAction mainAction = fu.createCircusAction (((BasicProcess)process).getMainAction());
			Vector <String> actionNames = new Vector <String> ();
			actionNames.add(paraName);
			mainAction = expandAction (actionNames, mainAction, process, spec);
			ActionUtil.setOrAddValidMainActionPara (mainAction, (BasicProcess)process);
			System.out.println (PrinterUtil.specAsString(spec));
			System.out.print("");
		}
		else if (process instanceof Process2) {
			CircusProcess left = ((Process2)process).getLeftProcess();
			CircusProcess right = ((Process2)process).getRightProcess();
			expandCallsOnMainActions (left, paraName, spec);
			expandCallsOnMainActions (right, paraName, spec);
		}
		else if (process instanceof Process1) {
			CircusProcess process1 = ((Process1)process).getCircusProcess();
			expandCallsOnMainActions (process1, paraName, spec);
		}
		else {
			//ExceptionUtil.throwImplementationException ("CallUtil.expandCallsOnMainActions", process.getClass ());
		}
	}
}