package jcircus.benchmarking;

import java.util.ArrayList;
import java.util.List;

import javax.swing.JOptionPane;

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.JCircusControllerFrame;
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.gui.ParametersDialog;
import jcircus.parallelism.ProcHiddenFromGUIEnv;
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 JCircusControllerBench extends JCircusController {
	Spec spec = null;
	JCircusFrame _jCircusFrame;
	private boolean createMain = false;

	public void setCreateMain (String c) {
		if (c.equals("true"))
			createMain = true;
		else {
			createMain = false;
		}
	}
	public JCircusControllerBench () {
        _jCircusFrame = new JCircusFrame(JCircusControllerBench.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> ();
    	ProcHiddenFromGUIEnv prochid = new ProcHiddenFromGUIEnv ();
    	/*ProcInfoUpdater.initProcInfoAndCreateMainEnv (_jCircusFrame.getProcCreateMainEnv(), procInfoList, spec, parallelism, createMain);
    	if (!createMain) {
    		_jCircusFrame.promptForMainProcessesPCME (procInfoList);
    	}*/
    	_translator = new Translator2Java(projectDir, projectName, spec, compl, useBarriers, parallelism, bench, _jCircusFrame/*.getProcCreateMainEnv()*/, createMain);

    	_translator.translate(true);
    	procInfoList = _translator.getProcInfoList();
    	/*if (!createMain)
    		_jCircusFrame.promptForMainProcesses(procInfoList);*/

    	for (int i = 0; i < procInfoList.size(); i++) {
    		ProcInfo procInfo = procInfoList.get(i);
    		if (createMain) {
    			procInfo.setCreateMain(true);
    		}
    		if (procInfo.getCreateMain() == true &&
    				procInfo.getParameters() != null &&
    				!procInfo.getParameters().isEmpty()
    			) {
    			if (!createMain)
    				_jCircusFrame.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();
	}
}