#include <jetscript/Parselets.h>
#include <jetscript/Expressions.h>
#include <jetscript/Parser.h>
#include <jetscript/UniquePtr.h>
#include <string>

using namespace Jet;

Expression* NameParselet::parse(Parser* parser, Token token)
{
	if (parser->MatchAndConsume(TokenType::LeftBracket))
	{
		//array index
		UniquePtr<Expression*> index = parser->parseExpression();
		parser->Consume(TokenType::RightBracket);

		return new IndexExpression(new NameExpression(token.text), index.Release(), token);
	}
	else
		return new NameExpression(token.text);
}

Expression* AssignParselet::parse(Parser* parser, Expression* left, Token token)
{
	Expression* right = parser->parseExpression(Precedence::ASSIGNMENT-1/*assignment prcedence -1 */);

	if (dynamic_cast<IStorableExpression*>(left) == 0)
	{
		delete right;
		throw CompilerException(parser->filename, token.line, "AssignParselet: Left hand side must be a storable location!");
	}
	return new AssignExpression(left, right);
}

Expression* OperatorAssignParselet::parse(Parser* parser, Expression* left, Token token)
{
	if (dynamic_cast<IStorableExpression*>(left) == 0)
		throw CompilerException(parser->filename, token.line, "OperatorAssignParselet: Left hand side must be a storable location!");

	Expression* right = parser->parseExpression(Precedence::ASSIGNMENT-1/*assignment prcedence -1 */);

	return new OperatorAssignExpression(token, left, right);
}

Expression* SwapParselet::parse(Parser* parser, Expression* left, Token token)
{
	if (dynamic_cast<IStorableExpression*>(left) == 0)
		throw CompilerException(parser->filename, token.line, "SwapParselet: Left hand side must be a storable location!");

	UniquePtr<Expression*> right = parser->parseExpression(Precedence::ASSIGNMENT-1/*assignment prcedence -1 */);

	if (dynamic_cast<IStorableExpression*>((Expression*)right) == 0)
		throw CompilerException(parser->filename, token.line, "SwapParselet: Right hand side must be a storable location!");

	return new SwapExpression(left, right.Release());
}

Expression* PrefixOperatorParselet::parse(Parser* parser, Token token)
{
	Expression* right = parser->parseExpression(precedence);
	if (right == 0)
		throw CompilerException(parser->filename, token.line, "PrefixOperatorParselet: Right hand side missing!");

	return new PrefixExpression(token, right);
}

Expression* BinaryOperatorParselet::parse(Parser* parser, Expression* left, Token token)
{
	Expression* right = parser->parseExpression(precedence - (isRight ? 1 : 0));
	if (right == 0)
		throw CompilerException(parser->filename, token.line, "BinaryOperatorParselet: Right hand side missing!");

	return new OperatorExpression(left, token, right);
}

Expression* GroupParselet::parse(Parser* parser, Token token)
{
	UniquePtr<Expression*> exp = parser->parseExpression();
	parser->Consume(TokenType::RightParen);
	return exp.Release();
}

Expression* WhileParselet::parse(Parser* parser, Token token)
{
	parser->Consume(TokenType::LeftParen);

	UniquePtr<Expression*> condition = parser->parseExpression();

	parser->Consume(TokenType::RightParen);

	auto block = new ScopeExpression(parser->parseBlock());
	return new WhileExpression(token, condition.Release(), block);
}

Expression* ForParselet::parse(Parser* parser, Token token)
{
	parser->Consume(TokenType::LeftParen);
	if (parser->LookAhead().type == TokenType::Local)
	{
		if (parser->LookAhead(1).type == TokenType::Name)
		{
			Token n = parser->LookAhead(2);
			if (n.type == TokenType::Name && n.text == "in")
			{
				//ok its a foreach loop
				parser->Consume();
				auto name = parser->Consume();
				parser->Consume();
				UniquePtr<Expression*> container = parser->parseExpression();
				parser->Consume(TokenType::RightParen);

				auto block = new ScopeExpression(parser->parseBlock());
				return new ForEachExpression(name, container.Release(), block);
			}
		}
	}

	UniquePtr<Expression*> initial = parser->ParseStatement(true);
	UniquePtr<Expression*> condition = parser->ParseStatement(true);
	UniquePtr<Expression*> increment = parser->parseExpression();

	parser->Consume(TokenType::RightParen);

	auto block = new ScopeExpression(parser->parseBlock());
	return new ForExpression(token, initial.Release(), condition.Release(), increment.Release(), block);
}

Expression* IfParselet::parse(Parser* parser, Token token)
{
	std::vector<Branch*> branches;
	//take parens
	parser->Consume(TokenType::LeftParen);
	UniquePtr<Expression*> ifcondition = parser->parseExpression();
	parser->Consume(TokenType::RightParen);

	BlockExpression* ifblock = parser->parseBlock(true);

	branches.push_back(new Branch(ifblock, ifcondition.Release()));

	Branch* Else = 0;
	while(true)
	{
		//look for elses
		if (parser->MatchAndConsume(TokenType::ElseIf))
		{
			//keep going
			parser->Consume(TokenType::LeftParen);
			UniquePtr<Expression*> condition = parser->parseExpression();
			parser->Consume(TokenType::RightParen);

			BlockExpression* block = parser->parseBlock(true);

			branches.push_back(new Branch(block, condition.Release()));
		}
		else if (parser->MatchAndConsume(TokenType::Else))
		{
			//its an else
			BlockExpression* block = parser->parseBlock(true);

			Else = new Branch(block, 0);
			break;
		}
		else
			break;//nothing else
	}

	return new IfExpression(token, std::move(branches), Else);
}

Expression* FunctionParselet::parse(Parser* parser, Token token)
{
	auto name = new NameExpression(parser->Consume(TokenType::Name).getText());
	auto arguments = new std::vector<Expression*>;

	NameExpression* varargs = 0;
	parser->Consume(TokenType::LeftParen);

	if (!parser->MatchAndConsume(TokenType::RightParen))
	{
		do
		{
			Token name = parser->Consume();
			if (name.type == TokenType::Name)
			{
				arguments->push_back(new NameExpression(name.text));
			}
			else if (name.type == TokenType::Ellipses)
			{
				varargs = new NameExpression(parser->Consume(TokenType::Name).getText());

				break;//this is end of parsing arguments
			}
			else
			{
				std::string str = "Consume: TokenType not as expected! Expected Name or Ellises Got: " + name.text;
				throw CompilerException(parser->filename, name.line, str);
			}
		}
		while(parser->MatchAndConsume(TokenType::Comma));

		parser->Consume(TokenType::RightParen);
	}

	auto block = new ScopeExpression(parser->parseBlock());
	return new FunctionExpression(token, name, arguments, block, varargs);
}

Expression* LambdaParselet::parse(Parser* parser, Token token)
{
	parser->Consume(TokenType::LeftParen);

	NameExpression* varargs = 0;
	auto arguments = new std::vector<Expression*>;
	if (parser->LookAhead().type != TokenType::RightParen)
	{
		do
		{
			Token name = parser->Consume();
			if (name.type == TokenType::Name)
			{
				arguments->push_back(new NameExpression(name.getText()));
			}
			else if (name.type == TokenType::Ellipses)
			{
				varargs = new NameExpression(parser->Consume(TokenType::Name).getText());

				break;//this is end of parsing arguments
			}
			else
			{
				std::string str = "Consume: TokenType not as expected! Expected Name or Ellises Got: " + name.text;
				throw CompilerException(parser->filename, name.line, str);
			}
		}
		while(parser->MatchAndConsume(TokenType::Comma));
	}

	parser->Consume(TokenType::RightParen);

	auto block = new ScopeExpression(parser->parseBlock());
	return new FunctionExpression(token, 0, arguments, block, varargs);
}

Expression* CallParselet::parse(Parser* parser, Expression* left, Token token)
{
	UniquePtr<std::vector<Expression*>*> arguments = new std::vector<Expression*>;

	if (!parser->MatchAndConsume(TokenType::RightParen))
	{
		do
		{
			arguments->push_back(parser->parseExpression(Precedence::ASSIGNMENT));
		}
		while( parser->MatchAndConsume(TokenType::Comma));

		parser->Consume(TokenType::RightParen);
	}
	return new CallExpression(token, left, arguments.Release());
}

Expression* ReturnParselet::parse(Parser* parser, Token token)
{
	Expression* right = 0;
	if (parser->Match(TokenType::Semicolon) == false)
		right = parser->parseExpression(Precedence::ASSIGNMENT);

	return new ReturnExpression(token, right);
}

Expression* LocalParselet::parse(Parser* parser, Token token)
{
	UniquePtr<std::vector<Token>*> names = new std::vector<Token>;

	do
	{
		Token name = parser->Consume(TokenType::Name);
		names->push_back(name);
	}
	while (parser->MatchAndConsume(TokenType::Comma));

	parser->Consume(TokenType::Assign);//its possible this wont be here and it may just be a mentioning, but no assignment

	//handle multiple comma expressions
	UniquePtr<std::vector<Expression*>*> rights = new std::vector<Expression*>;
	do
	{
		Expression* right = parser->parseExpression(Precedence::ASSIGNMENT-1/*assignment prcedence -1 */);

		rights->push_back(right);
	}
	while (parser->MatchAndConsume(TokenType::Comma));

	parser->Consume(TokenType::Semicolon);

	return new LocalExpression(names.Release(), rights.Release());
}

Expression* ConstParselet::parse(Parser* parser, Token token)
{
	throw CompilerException("", 0, "Const keyword not implemented!");

	std::vector<Token>* names = new std::vector<Token>;
	do
	{
		Token name = parser->Consume(TokenType::Name);
		names->push_back(name);
	}
	while (parser->MatchAndConsume(TokenType::Comma));

	parser->Consume(TokenType::Assign);//its possible this wont be here and it may just be a mentioning, but no assignment

	//do somethign with multiple comma expressions
	std::vector<Expression*>* rights = new std::vector<Expression*>;
	do
	{
		Expression* right = parser->parseExpression(Precedence::ASSIGNMENT-1/*assignment prcedence -1 */);

		rights->push_back(right);
	}
	while (parser->MatchAndConsume(TokenType::Comma));

	parser->Consume(TokenType::Semicolon);
	//do stuff with this and store and what not
	//need to add this variable to this's block expression

	return new LocalExpression(names, rights);
}

Expression* ArrayParselet::parse(Parser* parser, Token token)
{
	std::vector<Expression*> inits;// = new std::vector<Expression*>;
	while(parser->LookAhead().getType() != TokenType::RightBracket)
	{
		Expression* e = parser->parseExpression(2);

		inits.push_back(e);

		if (!parser->MatchAndConsume(TokenType::Comma))//check if more
			break;//we are done
	}
	parser->Consume(TokenType::RightBracket);
	return new ArrayExpression(std::move(inits));
}

Expression* IndexParselet::parse(Parser* parser, Expression* left, Token token)
{
	UniquePtr<Expression*> index = parser->parseExpression();
	parser->Consume(TokenType::RightBracket);

	return new IndexExpression(left, index.Release(), token);
}

Expression* MemberParselet::parse(Parser* parser, Expression* left, Token token)
{
	//this is for const members
	Expression* member = parser->parseExpression(Precedence::CALL);
	UniquePtr<NameExpression*> name = dynamic_cast<NameExpression*>(member);
	if (name == 0)
	{
		delete member; delete left;
		throw CompilerException(parser->filename, token.line, "Cannot access member name that is not a string");
	}

	auto ret = new IndexExpression(left, new StringExpression(name->GetName()), token);

	return ret;
}

Expression* ObjectParselet::parse(Parser* parser, Token token)
{
	if (parser->MatchAndConsume(TokenType::RightBrace))
	{
		//we are done, return null object
		return new ObjectExpression();
	}

	//parse initial values
	std::vector<std::pair<std::string, Expression*>>* inits = new std::vector<std::pair<std::string, Expression*>>;
	while(parser->LookAhead().type == TokenType::Name || parser->LookAhead().type == TokenType::String || parser->LookAhead().type == TokenType::Number)
	{
		Token name = parser->Consume();

		parser->Consume(TokenType::Assign);

		//parse the data;
		Expression* e = parser->parseExpression(Precedence::LOGICAL);

		inits->push_back(std::pair<std::string, Expression*>(name.text, e));
		if (!parser->MatchAndConsume(TokenType::Comma))//is there more to parse?
			break;//we are done
	}
	parser->Consume(TokenType::RightBrace);//end part
	return new ObjectExpression(inits);
};

Expression* YieldParselet::parse(Parser* parser, Token token)
{
	Expression* right = 0;
	if (parser->Match(TokenType::Semicolon) == false)
		right = parser->parseExpression(Precedence::ASSIGNMENT);

	return new YieldExpression(token, right);
}

Expression* InlineYieldParselet::parse(Parser* parser, Token token)
{
	Expression* right = 0;
	if (parser->Match(TokenType::Semicolon) == false && parser->LookAhead().type != TokenType::RightParen)
		right = parser->parseExpression(Precedence::ASSIGNMENT);

	return new YieldExpression(token, right);
}

Expression* ResumeParselet::parse(Parser* parser, Token token)
{
	Expression* right = parser->parseExpression(Precedence::ASSIGNMENT);

	return new ResumeExpression(token, right);
}

Expression* ResumePrefixParselet::parse(Parser* parser, Token token)
{
	Expression* right = parser->parseExpression(Precedence::ASSIGNMENT);

	return new ResumeExpression(token, right);
}