/**
  *
  *                      OOAS Compiler
  *
  *       Copyright 2015, AIT Austrian Institute of Technology.
  * This code is based on the C# Version of the OOAS Compiler, which is
  * copyright 2015 by the Institute of Software Technology, Graz University
  * of Technology with portions copyright by the AIT Austrian Institute of
  * Technology. All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * If you modify the file please update the list of contributors below to in-
  * clude your name. Please also stick to the coding convention of using TABs
  * to do the basic (block-level) indentation and spaces for anything after
  * that. (Enable the display of special chars and it should be pretty obvious
  * what this means.) Also, remove all trailing whitespace.
  *
  * Contributors:
  *               Willibald Krenn (AIT)
  *               Stephan Zimmerer (AIT)
  *               Markus Demetz (AIT)
  *               Christoph Czurda (AIT)
  *
  */


package org.momut.ooas;

import java.io.File;
import java.io.FileFilter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.momut.ooas.CompilerConfiguration.LabelCompression;
import org.momut.ooas.ast.IAstVisitor;
import org.momut.ooas.codegen.prolog.OoaPrologVisitor;
import org.momut.ooas.codegen.prologsymbolic.OoaPrologSymbolicVisitor;
import org.momut.ooas.parser.ParserError;
import org.momut.ooas.parser.ParserMessage;
import org.momut.ooas.parser.ParserState;
import org.momut.ooas.parser.ParserWarning;
import org.momut.ooas.parser.ooaCustomParser;
import org.momut.ooas.visitors.OoaActionClassifierVisitor;
import org.momut.ooas.visitors.OoaMethodPureClassifierVisitor;
import org.momut.ooas.visitors.OoaObjectInstantiationVisitor;
import org.momut.ooas.visitors.OoaReplaceOpaqueVisitor;
import org.momut.ooas.visitors.OoaResolveExpressionsVisitor;
import org.momut.ooas.visitors.OoaSymbolSortVisitor;
import org.momut.ooas.visitors.OoaTypeCheckVisitor;
import org.momut.ooas.visitors.OoaTypeRenameVisitor;
import org.momut.ooas.visitors.OoaTypesVisitor;
import org.momut.ooas.visitors.optimisation.OoaRemoveTrivialPrioritizedCompositionVisitor;

public final class CmdlineCompiler
{
	public interface CreateVisitor {
		public IAstVisitor cerate(ParserState aState);
	}

	public static class Options
	{
		public boolean quiet = false;
		public String fileToParse = "";
		public String outputToFile = "";
		public String namedTypePrefix = "";
		public String namespace = "";
		public ArrayList<CreateVisitor> pipeLine = new ArrayList<CreateVisitor>();
	}

	static void displayTitle()
	{
		System.out.println();
		System.out.println("          >> OO-Action System Parser <<");
		System.out.println();
		System.out.println();
	}


	/* fire up the parser */
	static int runAntlrParser(Options options)
	{
		ParserState pState;
		try {
			pState = new ParserState(options.fileToParse, options.namedTypePrefix);
			final int result = ooaCustomParser.FirstPass(pState);
			if (result > 0)
			{
				System.out.println(String.format("The parser returned %s errors:", result));
				for (final ParserError error: pState.listOfParserErrors)
					System.out.println(String.format("ERROR (%s): %s,%s; %s",
							error.file(), error.line(), error.column(), error.message()));
			}
			else
			{
				System.out.println("   Passed: OoaParser");
				if (options.pipeLine.size() > 0)
				{

					IAstVisitor visitor = null;
					for (final CreateVisitor item: options.pipeLine)
					{
						visitor = item.cerate(pState);
						pState.ooaSystem.Accept(visitor);
						if (pState.listOfParserErrors.size() > 0)
						{
							System.out.println(String.format("The parser (%s) returned %s errors:",
									visitor.returnVisitorName(), pState.listOfParserErrors.size()));

							for (final ParserError error: pState.listOfParserErrors)
								System.out.println(String.format("ERROR (%s): %s,%s; %s",
										error.file(), error.line(), error.column(), error.message()));
							return pState.listOfParserErrors.size();
						}
						else
						{
							System.out.print("   Passed: ");
							System.out.println(visitor.returnVisitorName());
						}
					}
					System.out.println();
					System.out.println(String.format("File %s successfully parsed.", pState.filename));
					System.out.println();

					if (pState.listOfParserMessages.size() > 0 && !(options.quiet))
					{
						System.out.println(String.format("Parser returned %s messages:", pState.listOfParserMessages.size()));
						for (final ParserMessage message: pState.listOfParserMessages)
							System.out.println(String.format("Message (%s): %s,%s; %s",
									message.file(), message.line(), message.column(), message.message()));
						System.out.println();
						System.out.println();
					}

					if (pState.listOfParserWarnings.size() > 0 && !(options.quiet))
					{
						System.out.println(String.format("Parser returned %s warnings:", pState.listOfParserWarnings.size()));
						for (final ParserWarning warning: pState.listOfParserWarnings)
							System.out.println(String.format("Warning (%s): %s,%s; %s",
									warning.file(), warning.line(), warning.column(), warning.message()));
						System.out.println("");
						System.out.println("");
					}

					if (!options.outputToFile.equals(""))
					{
						System.out.println(String.format("Writing output to %s.", options.outputToFile));
						final FileWriter fw = new FileWriter(options.outputToFile, false);
						fw.write(visitor.toString()); // fixme: this should be ascii..
						fw.close();
					}
					else
						System.out.println(visitor.toString());
				}
				else
				{
					System.out.println();
					System.out.println(String.format("File %s successfully parsed.", pState.filename));
					System.out.println("");
				}
			}

			return result;
		} catch (final IOException e) {
			e.printStackTrace();
			return -1;
		}
	}


	private static void fillPipeLine(Options options) {
		int index = 0;

		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaSymbolSortVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaReplaceOpaqueVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaTypesVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaResolveExpressionsVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaMethodPureClassifierVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaTypeCheckVisitor(aState);
			}});

		if (!options.namedTypePrefix.equals(""))
		{
			options.pipeLine.add(index++, new CreateVisitor(){
				@Override
				public IAstVisitor cerate(ParserState aState) {
					return new OoaTypeRenameVisitor(aState);
				}});
		}

		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaRemoveTrivialPrioritizedCompositionVisitor(aState);
			}});
		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaActionClassifierVisitor(aState);
			}});

		options.pipeLine.add(index++, new CreateVisitor(){
			@Override
			public IAstVisitor cerate(ParserState aState) {
				return new OoaObjectInstantiationVisitor(aState, LabelCompression.NoCompression);
			}});
	}


	/* entry point */
	public static void main(String[] args)
	{
		displayTitle();

		if (args.length != 4) {
			System.out.println("3 Arguments expected: backend orig/mut inputfile outputfile");
			System.out.println();
			System.out.println("   backend    ... 'psym' or 'p'");
			System.out.println("   orig/mut   ... 'orig' or 'mut'");
			System.out.println("   input  file or directory ... full path to input .ooas file or");
			System.out.println("                                directory containing .ooas files");
			System.out.println("   output file or directory ... full path to output file; will erase or");
			System.out.println("                                directory (only if also input is a directory)");
			System.out.println();
			System.exit(-1);
		}

		final Options options  = new Options();
		final boolean symbolic = args[0].toLowerCase().trim().equals("psym");
		final boolean mutant   = args[1].toLowerCase().trim().equals("mut");
		options.fileToParse    = args[2];
		options.outputToFile   = args[3];
		fillPipeLine(options); // add all basic operations
		final String namespace = mutant? "asm" : "as";
		options.namespace      = namespace;

		// add the prolog codegen target...
		if (symbolic) {
			options.pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor cerate(ParserState aState) {
					return new OoaPrologSymbolicVisitor(aState, 35, namespace);
				}});
		} else {
			options.pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor cerate(ParserState aState) {
					return new OoaPrologVisitor(aState, 35, namespace); // "as" ... original, "asm" ... mutant
				}});
		}
		System.out.println(String.format("Running OOAS Compiler... [backend=%s, namespace=%s]", symbolic?"psym":"p", namespace));
		if (new File(options.fileToParse).isDirectory()) {
			directoryMode(options);
		} else {
			fileMode(options);
		}
	}

	/**
	 * Iterates over all files in a directory if options.fileToParse is a directory
	 * and runs the antlr parser for each file. the output is stored in the same
	 * directory if the options.outputToFile is blank or not a directory.
	 * @param options
	 */
	public static void directoryMode(final Options options) {
		final File input  = new File(options.fileToParse);
		final File output = new File(options.outputToFile);
		final List<File> errors = new ArrayList<File>();

		File[] filesToParse = null;
		final FileFilter filter = new FileFilter() {
			@Override
			public final boolean accept(final File myFile) {
				return myFile.getName().endsWith(".ooas");
			}
		};

		System.out.println(String.format("Processing Directory [Input, Output]: %s, %s",
				input.getAbsolutePath(), output.getAbsoluteFile()));

		filesToParse = input.listFiles(filter);

		int result              = 0;
		File fileToParse        = null;
		String inputFileName    = "";
		String outputFileName   = "";
		final String outputFileSuffix = "." + options.namespace + ".pl";

		if (filesToParse != null) {
			for (int i = 0; i < filesToParse.length; ++i) {
				fileToParse    = filesToParse[i];
				inputFileName  = fileToParse.getAbsolutePath();
				outputFileName = fileToParse.getName().substring(0, fileToParse.getName().indexOf(".ooas")).concat(outputFileSuffix);

				if (output != null) {
					if (!output.isDirectory())
						output.mkdir();
					outputFileName = output.getAbsolutePath() + File.separatorChar + outputFileName;
				}
				else {
					// use same directory as input file for output
					outputFileName = fileToParse.getParent() + File.separatorChar + outputFileName;
				}

				options.fileToParse  = inputFileName;
				options.outputToFile = outputFileName;

				System.out.println(String.format("Parsing %s", options.fileToParse));
				result = runAntlrParser(options);
				if (result != 0)
					errors.add(fileToParse);
			}
		}

		if (errors.size() > 0) {
			System.out.println("Following files were not processed correctly:");
			final Iterator<File> i = errors.iterator();
			File file = null;
			while (i.hasNext()) {
				file = i.next();
				System.out.println(file.getName());
			}
			System.exit(-1);
		}
		System.exit(0);
	}

	/**
	 * Runs the antlr parser with the given options
	 * @param options
	 */
	public static void fileMode(final Options options) {
		System.out.println(String.format("Parsing %s.", options.fileToParse));
		final int result = runAntlrParser(options);
		System.exit(result);
	}
}