/**
  *
  *                      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.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.momut.ooas.CompilerConfiguration.Backend;
import org.momut.ooas.ast.IAstVisitor;
import org.momut.ooas.codegen.ast.OoaAstEmitter;
import org.momut.ooas.codegen.cadp.OoaCADPVisitor;
import org.momut.ooas.codegen.prolog.OoaPrologVisitor;
import org.momut.ooas.codegen.prologsymbolic.OoaPrologSymbolicVisitor;
import org.momut.ooas.parser.CompilerMessage;
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.utils.exceptions.OoasCompilerRuntimeException;
import org.momut.ooas.visitors.OoaActionClassifierVisitor;
import org.momut.ooas.visitors.OoaCheckObjectRefsConstant;
import org.momut.ooas.visitors.OoaMethodPureClassifierVisitor;
import org.momut.ooas.visitors.OoaObjectInstantiationVisitor;
import org.momut.ooas.visitors.OoaPrintVisitor;
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.analysis.OoaCheckASTVisitor;
import org.momut.ooas.visitors.analysis.OoaPrintActionSequencesVisitor;
import org.momut.ooas.visitors.analysis.OoaPrintActionsVisitor;
import org.momut.ooas.visitors.analysis.OoaPrintMetricsVisitor;
import org.momut.ooas.visitors.optimisation.OoaRemoveTrivialBlocksVisitor;

public final class Compiler {
	public interface IProgressCallBack {
		public void startingCompilePhase(String compilePhaseName);
		public void doneCompilePhase();
	}
	public interface ILogCallBack {
		public void logError(boolean toConsole, String message);
	}
	private static final class NullProgressCallBack implements IProgressCallBack {
		@Override
		public void startingCompilePhase(String compilePhaseName) {}
		@Override
		public void doneCompilePhase() {}
	}
	private interface CreateVisitor {
		public IAstVisitor create(ParserState aState);
	}

	public final CompilerConfiguration config;
	private final ArrayList<CreateVisitor> pipeLine = new ArrayList<CreateVisitor>();
	private ArrayList<ParserError> listOfParserErrors = new ArrayList<>();
	private ArrayList<ParserWarning> listOfParserWarnings = new ArrayList<>();
	private ArrayList<ParserMessage> listOfParserMessages = new ArrayList<>();

	private void updateParserMsgs(ParserState pState) {
		final Comparator<CompilerMessage> comparator = new Comparator<CompilerMessage>(){
			@Override
			public int compare(CompilerMessage arg0, CompilerMessage arg1) {
				if (arg0.line() != arg1.line())
					return arg0.line() - arg1.line();
				else
					return arg0.column() - arg1.column();
			}};

		listOfParserErrors = pState.listOfParserErrors;
		listOfParserMessages = pState.listOfParserMessages;
		listOfParserWarnings = pState.listOfParserWarnings;

		// sort the logs
		Collections.sort(listOfParserErrors, comparator);
		Collections.sort(listOfParserMessages, comparator);
		Collections.sort(listOfParserWarnings, comparator);
	}

	public List<ParserError> getErrors() {
		return Collections.unmodifiableList(listOfParserErrors);
	}
	public List<ParserWarning> getWarnings() {
		return Collections.unmodifiableList(listOfParserWarnings);
	}
	public List<ParserMessage> getMessages() {
		return Collections.unmodifiableList(listOfParserMessages);
	}

	@Override
	public String toString() {
		final StringBuilder result = new StringBuilder();
		for (final ParserError err: getErrors())
			result.append(String.format("ERROR: %s (%s,%s): %s\n",
				err.file(), err.line(), err.column(), err.message()));
		for (final ParserWarning err: getWarnings())
			result.append(String.format("Warning: %s (%s,%s): %s\n",
				err.file(), err.line(), err.column(), err.message()));
		for (final ParserMessage msg: getMessages())
			result.append(String.format("Info: %s (%s,%s): %s\n",
				msg.file(), msg.line(), msg.column(), msg.message()));
		return result.toString();
	}

	private void fillPipeLine() {
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaCheckASTVisitor(aState, "Stage 0");
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaSymbolSortVisitor(aState);
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaReplaceOpaqueVisitor(aState);
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaTypesVisitor(aState);
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaResolveExpressionsVisitor(aState);
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaMethodPureClassifierVisitor(aState);
			}});
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaTypeCheckVisitor(aState);
			}});

		if (!config.getNamedTypePrefix().equals(""))
		{
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaTypeRenameVisitor(aState);
				}});
		}

		// do some trivial "optimizations" (remove prioritized and nondet choice blocks
		// with only one element, join sequential blocks that are direct children of
		// sequential blocks to one sequential block
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaRemoveTrivialBlocksVisitor(aState);
			}});
		// check the AST
		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaCheckASTVisitor(aState,"After Optimisation");
			}});


		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaActionClassifierVisitor(aState);
			}});

		pipeLine.add(new CreateVisitor(){
			@Override
			public IAstVisitor create(ParserState aState) {
				return new OoaPrintMetricsVisitor(aState);
			}
		});

		switch (config.getBackend()) {
		case Printer:
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintVisitor(aState);
				}});
			break;
		case CADP :
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionsVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionSequencesVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaCADPVisitor(aState);
				}});
			break;
		case Prolog:
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionsVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionSequencesVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrologVisitor(aState, config.getMaxSearchDepth(), config.getNameSpace());
				}});
			break;
		case PrologSymbolic:
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaCheckObjectRefsConstant(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionSequencesVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionsVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrologSymbolicVisitor(aState, config.getMaxSearchDepth(), config.getNameSpace());
				}});
			break;
		case CopyAST:
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaObjectInstantiationVisitor(aState, config.getLabelCompression());
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaPrintActionsVisitor(aState);
				}});
			pipeLine.add(new CreateVisitor(){
				@Override
				public IAstVisitor create(ParserState aState) {
					return new OoaAstEmitter<>(aState, config.getAstTarget());
				}});
			break;
		default:
			throw new OoasCompilerRuntimeException("Unknown backend.");
		}
	}


	public int compile(ILogCallBack logCallback) {
		return compile(new NullProgressCallBack(), logCallback);
	}

	/* fire up the parser */
	public int compile(IProgressCallBack callback, ILogCallBack logCallback)
	{
		if (config.isWriteable()) {
			config.setWriteOnly();
			fillPipeLine();
		}

		ParserState pState;
		try {
			callback.startingCompilePhase("OoaParser");
			pState = config.useStreams()
					?  new ParserState(config.getUnitName(), config.getInputStream(), config.getNamedTypePrefix())
					:  new ParserState(config.getFileToParse(), config.getNamedTypePrefix());
			final int result = ooaCustomParser.FirstPass(pState);
			if (result == 0) {
				callback.doneCompilePhase();
				if (pipeLine.size() > 0) {
					IAstVisitor visitor = null;
					for (final CreateVisitor item: pipeLine) {
						visitor = item.create(pState);
						callback.startingCompilePhase(visitor.returnVisitorName());
						pState.ooaSystem.Accept(visitor);
						visitor.done();
						if (pState.listOfParserErrors.size() > 0) {
							updateParserMsgs(pState);
							return pState.listOfParserErrors.size();
						} else
							callback.doneCompilePhase();
					}
					// after we've done all visitors, write the output file.
					if (!config.useStreams() && !config.getFileToOutput().equals(""))
					{
						final FileWriter fw = new FileWriter(config.getFileToOutput(), false);
						fw.write(visitor.toString()); // fixme: this should be ascii..
						fw.close();
					} else if (config.useStreams()) {
						final OutputStream out = config.getOutputStream();
						final BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
						writer.write(visitor.toString());
						writer.close();
					}
				}
			}
			updateParserMsgs(pState);
			return result;
		} catch (final IOException e) {
			logCallback.logError(true, e.toString());
			return -1;
		}
	}


	public Compiler(CompilerConfiguration config) {
		this.config = config;
	}

	public Compiler(String unitName, String fileToParse, String fileToWrite, Backend be) {
		this(new CompilerConfiguration(unitName, fileToParse, fileToWrite, be));
	}

	public Compiler(String fileToParse, String fileToWrite, Backend be) {
		this(new File(fileToParse).getName(), fileToParse, fileToWrite, be);
	}

	public Compiler(String unitName, InputStream input, OutputStream output, Backend be) {
		this(new CompilerConfiguration(unitName, input, output, be));
	}
}