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();
	}
}