#include "tparser.h"

#include "tgrammar.h"

#include "ttokenizer.h"

#include "tutil.h"

#include <iostream></iostream>

namespace TSyntax

{

//-------------------------------------------------------------------

// RunningPattern

//-------------------------------------------------------------------

class RunningPattern

{

public:

	std::vector<token> m_tokens;</token>

	const Pattern *m_pattern;

	RunningPattern(const Pattern *pattern) : m_pattern(pattern) {}

	int getPriority() const { return m_pattern->getPriority(); }

	bool isFinished(const Token &token) const { return m_pattern->isFinished(m_tokens, token); }

	bool isComplete(const Token &token) const { return m_pattern->isComplete(m_tokens, token); }

	bool expressionExpected() const { return m_pattern->expressionExpected(m_tokens); }

	bool matchToken(const Token &token) const { return m_pattern->matchToken(m_tokens, token); }

	void advance()

	{

		assert(!isFinished(Token()));

		m_tokens.push_back(Token());

	}

	void advance(const Token &token)

	{

		assert(!isFinished(token));

		m_tokens.push_back(token);

	}

	TokenType getTokenType(const Token &token) const { return m_pattern->getTokenType(m_tokens, token); }

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack)</calculatornode>

	{

		m_pattern->createNode(calc, stack, m_tokens);

	}

};

//-------------------------------------------------------------------

// Parser::Imp

//-------------------------------------------------------------------

class Parser::Imp

{

public:

	const Grammar *m_grammar;

	Tokenizer m_tokenizer;

	std::string m_errorString;

	bool m_isValid;

	Calculator *m_calculator;

	std::vector<runningpattern> m_patternStack;</runningpattern>

	std::vector<calculatornode *=""> m_nodeStack;</calculatornode>

	std::vector<syntaxtoken> m_syntaxTokens;</syntaxtoken>

	Grammar::Position m_position;

	// Pattern *m_lastPattern;

	Imp(const Grammar *grammar)

		: m_grammar(grammar), m_errorString(""), m_isValid(false), m_calculator(0), m_position(Grammar::ExpressionStart)

	{

	}

	~Imp()

	{

		clearPointerContainer(m_nodeStack);

		delete m_calculator;

	}

	void pushSyntaxToken(TokenType type);

	bool parseExpression(bool checkOnly);

	void flushPatterns(int minPriority, int minIndex, bool checkOnly);

	bool checkSyntax(std::vector<syntaxtoken> &tokens);</syntaxtoken>

};

//-------------------------------------------------------------------

// Parser

//-------------------------------------------------------------------

Parser::Parser(const Grammar *grammar)

	: m_imp(new Imp(grammar))

{

}

//-------------------------------------------------------------------

Parser::~Parser()

{

}

//-------------------------------------------------------------------

void Parser::Imp::flushPatterns(int minPriority, int minIndex, bool checkOnly)

{

	while ((int)m_patternStack.size() > minIndex && m_patternStack.back().getPriority() >= minPriority) {

		if (!checkOnly)

			m_patternStack.back().createNode(m_calculator, m_nodeStack);

		m_patternStack.pop_back();

	}

}

//-------------------------------------------------------------------

void Parser::Imp::pushSyntaxToken(TokenType type)

{

	SyntaxToken syntaxToken;

	Token token = m_tokenizer.getToken();

	syntaxToken.m_pos = token.getPos();

	syntaxToken.m_length = token.getPos1() - token.getPos() + 1;

	syntaxToken.m_type = type;

	m_syntaxTokens.push_back(syntaxToken);

}

//-------------------------------------------------------------------

bool Parser::Imp::parseExpression(bool checkOnly)

{

	if (!m_grammar)

		return false;

	int stackMinIndex = m_patternStack.size();

	int count = 0;

	Grammar::Position position = Grammar::ExpressionStart;

	m_position = position;

	// warning: parseExpression() is called recursively. m_position is used after parseExpression()

	// for diagnostic and suggestions. position is used in the actual parsing

	bool expressionExpected = true;

	while (!m_tokenizer.eos()) {

		// token, position -> pattern

		const Pattern *pattern = m_grammar->getPattern(position, m_tokenizer.getToken());

		if (!pattern) {

			// no pattern found for the next token

			if (position == Grammar::ExpressionEnd) {

				// already found an expression

				flushPatterns(-1, stackMinIndex, checkOnly);

				return true;

			} else {

				// syntax error : expression not found

				if (checkOnly)

					pushSyntaxToken(UnexpectedToken);

				m_errorString = "Unexpected token";

				return false;

			}

		}

		// pattern found: start scanning it

		RunningPattern runningPattern(pattern);

		if (position == Grammar::ExpressionEnd) // patterns of the form "<expr> ...."</expr>

			runningPattern.advance();

		// eat the first token

		if (checkOnly)

			pushSyntaxToken(runningPattern.getTokenType(m_tokenizer.getToken()));

		runningPattern.advance(m_tokenizer.getToken());

		m_tokenizer.nextToken();

		expressionExpected = false;

		while (!runningPattern.isFinished(m_tokenizer.getToken())) {

			if (runningPattern.expressionExpected()) {

				// expression expected

				runningPattern.advance();

				if (runningPattern.isFinished(m_tokenizer.getToken())) {

					// pattern ended with an expression

					expressionExpected = true;

					break;

				}

				// parse a sub expression

				if (!parseExpression(checkOnly)) {

					return false;

				}

			} else {

				// "terminal" expected

				if (m_tokenizer.eos()) {

					// EOS

					if (runningPattern.isComplete(Token()))

						break;

					if (checkOnly)

						pushSyntaxToken(Eos);

					m_errorString = "Uncompleted syntax";

					return false;

				}

				if (!runningPattern.matchToken(m_tokenizer.getToken())) {

					// token mismatch

					if (runningPattern.isComplete(m_tokenizer.getToken()))

						break;

					if (checkOnly)

						pushSyntaxToken(Mismatch);

					m_errorString = "Syntax error";

					return false;

				}

				// token matched

				if (checkOnly)

					pushSyntaxToken(runningPattern.getTokenType(m_tokenizer.getToken()));

				runningPattern.advance(m_tokenizer.getToken());

				m_tokenizer.nextToken();

			}

		}

		// pattern ended

		if (expressionExpected) {

			// pattern terminated with an expression

			if (position == Grammar::ExpressionEnd) {

				// "E op . E"

				flushPatterns(runningPattern.getPriority(), stackMinIndex, checkOnly);

				m_patternStack.push_back(runningPattern);

			} else {

				// "op . E"

				m_patternStack.push_back(runningPattern);

			}

			m_position = position = Grammar::ExpressionStart;

		} else {

			// pattern terminates with a keyword

			if (position == Grammar::ExpressionEnd) {

				// "E op ."

				flushPatterns(runningPattern.getPriority(), stackMinIndex, checkOnly);

			} else {

				// "leaf .", "f(E) .", "(E) ."

			}

			if (!checkOnly)

				runningPattern.createNode(m_calculator, m_nodeStack);

			count++;

			m_position = position = Grammar::ExpressionEnd;

		}

	}

	if (count == 0 || expressionExpected) {

		m_errorString = "Expression expected";

		return false;

	}

	flushPatterns(-1, stackMinIndex, checkOnly);

	return true;

}

//-------------------------------------------------------------------

Calculator *Parser::parse(std::string text)

{

	m_imp->m_tokenizer.setBuffer(text);

	clearPointerContainer(m_imp->m_nodeStack);

	m_imp->m_errorString = "";

	m_imp->m_isValid = false;

	m_imp->m_calculator = new Calculator();

	bool ret = m_imp->parseExpression(false);

	if (ret && !m_imp->m_nodeStack.empty()) {

		m_imp->m_calculator->setRootNode(m_imp->m_nodeStack.back());

		m_imp->m_nodeStack.pop_back();

		m_imp->m_isValid = true;

	} else {

		delete m_imp->m_calculator;

		m_imp->m_calculator = 0;

	}

	clearPointerContainer(m_imp->m_nodeStack);

	Calculator *calculator = m_imp->m_calculator;

	m_imp->m_calculator = 0;

	return calculator;

}

//-------------------------------------------------------------------

Parser::SyntaxStatus Parser::checkSyntax(std::vector<syntaxtoken> &tokens, std::string text)</syntaxtoken>

{

	m_imp->m_tokenizer.setBuffer(text);

	if (m_imp->m_tokenizer.eos())

		return Incomplete;

	bool ret = m_imp->parseExpression(true);

	tokens = m_imp->m_syntaxTokens;

	if (ret && m_imp->m_tokenizer.eos())

		return Correct;

	if (tokens.empty())

		return Incomplete;

	SyntaxToken &lastToken = tokens.back();

	if (lastToken.m_type == Eos)

		return Incomplete;

	int k = lastToken.m_pos + lastToken.m_length;

	if (k >= (int)text.length()) {

		if (lastToken.m_type < Unknown) {

			lastToken.m_type = Unknown;

		}

		return ExtraIgnored;

	}

	SyntaxToken extraIgnored;

	extraIgnored.m_type = Unknown;

	extraIgnored.m_pos = k;

	extraIgnored.m_length = text.length() - k;

	tokens.push_back(extraIgnored);

	return Error;

}

//-------------------------------------------------------------------

void Parser::getSuggestions(Grammar::Suggestions &suggestions, std::string text)

{

	std::vector<syntaxtoken> tokens;</syntaxtoken>

	Parser::SyntaxStatus status = checkSyntax(tokens, text);

	suggestions.clear();

	if (status == Correct || status == Incomplete || status == ExtraIgnored)

		m_imp->m_grammar->getSuggestions(suggestions, m_imp->m_position);

}

//-------------------------------------------------------------------

std::string Parser::getCurrentPatternString(std::string text)

{

	return "ohime";

}

//-------------------------------------------------------------------

bool Parser::isValid() const

{

	return m_imp->m_isValid;

}

//-------------------------------------------------------------------

std::string Parser::getText() const

{

	return m_imp->m_tokenizer.getBuffer();

}

//-------------------------------------------------------------------

std::string Parser::getError() const

{

	return m_imp->m_errorString;

}

//-------------------------------------------------------------------

std::pair<int, int=""> Parser::getErrorPos() const</int,>

{

	if (m_imp->m_errorString == "")

		return std::make_pair(0, -1);

	Token token = m_imp->m_tokenizer.getToken();

	return std::make_pair(token.getPos(), token.getPos1());

}

//-------------------------------------------------------------------

} // namespace TSyntax