package jcircus;
  
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  import javax.swing.JOptionPane;
  
  import jcircus.exceptions.FailParsingException;
  import jcircus.exceptions.FailTranslationException;
  import jcircus.exceptions.FailTypeCheckingException;
  import jcircus.exceptions.JCircusException;
  import jcircus.exceptions.TranslationCancelledException;
  import jcircus.parallelism.ParallelismUpdater;
  import jcircus.translator.Translator2Java;
  import jcircus.util.Constants;
  import jcircus.util.Error;
  import jcircus.util.MathToolkitConstants;
  import net.sourceforge.czt.base.ast.Term;
  import net.sourceforge.czt.base.util.UnmarshalException;
  import net.sourceforge.czt.circus.util.Factory;
  import net.sourceforge.czt.parser.circus.CircusParseError;
  import net.sourceforge.czt.parser.circus.ParseUtils;
  import net.sourceforge.czt.parser.util.ErrorType;
  import net.sourceforge.czt.parser.util.ParseException;
  import net.sourceforge.czt.session.FileSource;
  import net.sourceforge.czt.session.Markup;
  import net.sourceforge.czt.session.SectionInfo;
  import net.sourceforge.czt.session.SectionManager;
  import net.sourceforge.czt.typecheck.circus.TypeChecker;
  import net.sourceforge.czt.typecheck.circus.WarningManager;
  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 net.sourceforge.czt.circustools.ast.*;
  //import circparser.CircusParser;
  
  /**
   * JCircus.java
   *
   * Main class of JCircus, with access to all the modules of the tool.
   *
   * @author Angela Freitas
   *
   */
  public abstract class JCircusController {
  
      static private final String NEWLINE = "
  ";
  
      
  /*Os métodos abaixo foram trazidos de JCircusControllerFrame para JCircusController
   * para habilitar a possibilidade de chamar o painel de escolha de geração de 
   * classe Main para os processos
   * */
      public void cancelTranslation () throws TranslationCancelledException {
      	//Copiado de JCircusControllerFrame para JCircusController
          throw new TranslationCancelledException();
      }
      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();
          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 {
              // Free type
              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;
      } 
  /*Os métodos acima foram trazidos de JCircusControllerFrame para JCircusController
  * para habilitar a possibilidade de chamar o painel de escolha de geração de 
  * classe Main para os processos
  * */
  
      /* Translator */
      protected Translator2Java _translator;
      Spec spec = null;
      /**
       * Performs parser, type checking and translates the given input file.
       */
      public void translate (String path, String projectDir, String projectName
      		, String compl, boolean useBarriers, boolean parallelism, boolean bench)
              throws Exception {
          try {
              spec = parse(path);
              typeCheck(spec);
              translate2Java(projectDir, projectName, spec, compl, useBarriers, parallelism, bench);
              reportTranslationOK(projectDir, projectName);
          } catch (FailParsingException e) {
              reportParsingErrors(e.getErrors());
          } catch (FailTypeCheckingException e) {
              reportTypeCheckingErrors(e.getErrors());
          } catch (FailTranslationException e) {
              reportTranslationErrors(e.getErrors());
  
          } catch (TranslationCancelledException e) {
              reportMessage("Translation cancelled by the user." + NEWLINE);
          }
      }
  
      /**
       * Performs parsing, and if there is no error, returns the syntax tree.
       * 
       * If the parsing fails, throws FailParsingException.
       */
      private Spec parse(String path) throws FailParsingException {
      	ParseException parseException = null;
      	Spec spec = null;
      	FileSource source = new FileSource (path);
  		try {
  			spec = (Spec) ParseUtils.parse(new FileSource (path), new SectionManager ("circus"));
  		} catch (ParseException e) {
  			JOptionPane.showMessageDialog (null, e.getMessage());
  			e.printStackTrace();
  		} catch (IOException e) {
  			System.out.println ("IOException");
  			e.printStackTrace();
  		} catch (UnmarshalException e) {
  			e.printStackTrace();
  			System.out.println ("UnmarshalException");
  		}//CircusParser.parse(path);
          // TODO: Change this. The errors should be a simple list, as it is in the type
          // checker, and not a mapping.
      	//System.out.println ("Passou por acu�... Depois dos catch!");
      	//TODO: Mudar isso aqui!!!!!!!!!!!!!!!!!!!!!!!!
          /*Map<String, List<String>> errors = null;//CircusParser.getErrors();
          if (errors.isEmpty()) {
          	System.out.println ("errors � empty!");
              reportParsingOK();
  
          } else {
              // Parsing errors
          	System.out.println ("errors N�O � empty!");
              List<String> parseErrors = null;
              int i = 0;
              for (List<String> list : errors.values()) {
                  parseErrors = list;
                  i++;
                  assert (i <= 1); // The mapping must have only one value
              }
              throw new FailParsingException (parseErrors);
          }*/
          return spec;
      }
      
      /**
       * Performs type checking on a syntax tree.
       *
       * If the type checking fails, throwns FailTypeChecking Exception.
       */
      /*Metodo abaixo implementado por Samuel, para ignorar os warnings no lançamento da exceção*/
      private static boolean hasErrors (TypeChecker tcheck) {
      	int counterErrors = 0;
      	List </*net.sourceforge.czt.typecheck.circus.*/ErrorAnn> errorsOrWarnings = (List </*net.sourceforge.czt.typecheck.circus.*/ErrorAnn>) tcheck.errors();
      	for (int i = 0; i < errorsOrWarnings.size(); i++) {
      		if (errorsOrWarnings.get(i).getErrorType() == ErrorType.ERROR) {
      			counterErrors ++;
      		}
      	}
      	if (counterErrors > 0) {
      		return true;
      	}
      	else return false;
      }
      /*Método acima implementado por Samuel, para ignorar os warnings no lan�amento da exce��o*/
  
      public static void typeCheck (Spec spec) throws FailTypeCheckingException {
          @SuppressWarnings ({"unchecked", "fallthrough", "doWarn", "WarningManager"})
          SectionManager manager = new SectionManager("circus");
  
          net.sourceforge.czt.typecheck.circus.impl.Factory factory = new net.sourceforge.czt.typecheck.circus.impl.Factory();
          TypeChecker typeChecker = new TypeChecker (factory, manager);
          WarningManager wm = typeChecker.getWarningManager();
          typeChecker.visitTerm(spec);
          List<ErrorAnn> typeErrors = (List<ErrorAnn>) typeChecker.errors();
  
          if (!hasErrors(typeChecker)) {
              reportTypeCheckingOK();
          } else {
              throw new FailTypeCheckingException(typeErrors);
          }    
      }
  
      /**
       *
       */
      protected abstract void translate2Java (String projectDir, String projectName, Spec /*Term*/ spec, String compl, boolean useBarriers, boolean parallelism, boolean bench)
              throws FailTranslationException, TranslationCancelledException, JCircusException;
  
      /**
       *
       */
      protected abstract void reportMessage (String message);
  
      /**
       *
       */
      private void reportParsingOK() {
          String message = "No parsing errors!" + NEWLINE;
          reportMessage(message);
      }
      
      /**
       *
       */
      private static void reportTypeCheckingOK() {
          String message = "No type checking errors!" + NEWLINE;
          //JOptionPane.showMessageDialog (null, "From TypeChecker: " + message);
          //reportMessage(message);
      }
          
      /**
       *
       */
      public void reportTranslationOK(String projectDir, String projectName) {
          String message = "Translation was successful! Files for project '" + projectName + 
                  "' were created at " + getOutputDir(projectDir, projectName) + ".";
          reportMessage(message);
      }
  
      /**
       *
       */
      protected String parsingErrorMessage(List<String> errors) {
  
          StringBuilder message = new StringBuilder();
          
          message.append(errors.size() + " parsing error(s)!" + NEWLINE);
          for(String e : errors) {
              message.append(e.toString() + NEWLINE);
          }
          return message.toString();
      }
      
      /**
       *
       */
      protected String typeCheckingErrorMessage(List<ErrorAnn> errors) {
  
          StringBuilder message = new StringBuilder();
  
          message.append(errors.size() + " type error(s)!" + NEWLINE);
  
          for(ErrorAnn e : errors) {
              message.append(e.toString() + NEWLINE);
          }                
          return message.toString();
      }
      
      /**
       *
       */
      protected String translationErrorMessage(List<Error> errors) {
          
          StringBuilder message = new StringBuilder();
  
          message.append("Input file does not meet the requirements for translation." + NEWLINE);
          message.append(errors.size() + " error(s)!" + NEWLINE);
  
          for(Error e : errors) {
              message.append(e.toString() + NEWLINE);
          }   
          return message.toString();
      }
      
      /**
       *
       */
      protected abstract void reportParsingErrors(List<String> errors) 
              throws FailParsingException;
      
      /**
       *
       */
      protected abstract void reportTypeCheckingErrors(List<ErrorAnn> errors) 
              throws FailTypeCheckingException;
      
      /**
       *
       */
      protected abstract void reportTranslationErrors(List<Error> errors) 
              throws FailTranslationException;
      
      /**
       *
       */
      public String getOutputDir(String outputPath, String projectName) {
          return outputPath + "/"/*"\\"*/ + projectName + "/"/*"\\"*/ + Constants.DIR_SOURCE;
      }
      
  }