package circusRefine.gui;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import net.sourceforge.czt.circus.util.Factory;
  import net.sourceforge.czt.typecheck.z.ErrorAnn;
  import net.sourceforge.czt.z.ast.Expr;
  import net.sourceforge.czt.z.ast.RefExpr;
  import net.sourceforge.czt.z.ast.Spec;
  import jcircus.JCircusController;
  import jcircus.exceptions.FailParsingException;
  import jcircus.exceptions.FailTranslationException;
  import jcircus.exceptions.FailTypeCheckingException;
  import jcircus.exceptions.JCircusException;
  import jcircus.exceptions.TranslationCancelledException;
  import jcircus.gui.JCircusFrame;
  import jcircus.translator.ProcInfoUpdater;
  import jcircus.translator.Translator2Java;
  import jcircus.util.Constants;
  import jcircus.util.Error;
  import jcircus.util.MathToolkitConstants;
  import jcircus.util.ProcInfo;
  
  public class JCircusControllerCodigo extends JCircusController {
  	Spec spec = null;
  	JCircusFrame jcf;
  	
  	public JCircusControllerCodigo () {
  		this.jcf = new JCircusFrame (JCircusControllerCodigo.this);
  	}
      protected void translate2Java (String projectDir, String projectName, Spec spec, String compl, boolean useBarriers, boolean parallelism, boolean bench) 
      		throws FailTranslationException, TranslationCancelledException, JCircusException {
      	List <ProcInfo> procInfoList = new ArrayList <ProcInfo> ();
      	ProcInfoUpdater.initProcInfoAndCreateMainEnv (jcf.getProcCreateMainEnv(), procInfoList, spec, parallelism, true);
      	_translator = new Translator2Java(projectDir, projectName, spec, compl, useBarriers, parallelism, bench, jcf, false);
      	_translator.translate(true);
  
      	// Prompt for the processes for each we want a main and 
      	// prompt for the parameters, in case of parameterised processes
      	procInfoList = _translator.getProcInfoList();
  
      	//_jCircusFrame.promptForMainProcesses(procInfoList);
      	jcf.promptForMainProcesses(procInfoList);
  
      	for (int i = 0; i < procInfoList.size(); i++) {
      		ProcInfo procInfo = procInfoList.get(i);
      		if (procInfo.getCreateMain() == true &&
      				procInfo.getParameters() != null &&
      				!procInfo.getParameters().isEmpty()) {
      			jcf.promptForParameters(procInfo);
      		}
      	}
      	// Create the source code files
      	_translator.createSources(); 
      	System.out.println ("Time Millis FINAL ::: " + System.currentTimeMillis());
      }
  
      protected void reportMessage (String message) {
      	//_jCircusFrame.reportMessage(message);
      }
  
  /**
  *
  */
      protected void reportParsingErrors(List<String> errors) {
      	String message = parsingErrorMessage(errors);
      	reportMessage(message);
      }
  
  /**
  *
  */
  	protected void reportTypeCheckingErrors(List<ErrorAnn> errors) {
  		String message = typeCheckingErrorMessage(errors);
  		reportMessage(message);
  	}
  	
  	/**
  	*
  	*/
  	protected void reportTranslationErrors(List<Error> errors) {
  		String message = translationErrorMessage(errors);
  		reportMessage(message);
  	}
  
  	public String codeForParameter(String expression, Expr typeExpr)
  	    throws FailParsingException, FailTypeCheckingException {
  		String code = "";
  		// For the moment, typeExpr will be always a reference. This will be
  		// changed in the future. Probably this method will receive the actual
  		// Type, instead of the type expression.
  		assert(typeExpr instanceof RefExpr);
  	
          String typeExprSt = ((RefExpr) typeExpr).getName().toString();//.getRefName().toString();
          if (typeExprSt.equals(MathToolkitConstants.NAT) ||
  	        typeExprSt.equals(MathToolkitConstants.NUM) ||
  	        typeExprSt.equals(MathToolkitConstants.ARITHMOS)) {
  	    // Number
          	try {
          		// Simulate parsing/typeChecking here
          		int number = Integer.parseInt(expression);
          		code = "new " + Constants.CLS_CIRCNUM + "(" + number + ")";
          	} 
          	catch (NumberFormatException nfe) {
  	      // Error
          		List<String> errors = new Factory().list("Expression is not a number.");
          		throw new FailParsingException(errors);
          	}
          	} else {
          		if (_translator.getEnvironment().isElementFreeType(typeExprSt, expression)) {
  	        
          			// Simulate parsing/typeChecking here
          			code = "new " + typeExprSt + "(" + typeExprSt + "." + expression + ")";
          	} else {
  	        	// Error
  	        	List<String> errors = new Factory().list("Expression is not an element of free type.");
  	        	throw new FailParsingException(errors);
  	    	}
  		}
  		return code;
  	} 
  	
  	/**
  	* Cancel the translation.
  	*/
  	public void cancelTranslation () throws TranslationCancelledException {
  		throw new TranslationCancelledException();
  	}
  }