#include "parser.h"
#include "exception.h"



Parser::Parser() {
	lexer = Lexer{};
}

std::unique_ptr<Node> Parser::parse(const std::string &code) {
	lexer.parse(code);
	lexer.debugTokens();	

	if (lexer.tokenType() == TokenType::keyword_create && lexer.nextTokenType() == TokenType::keyword_table) {
		return parse_create_table();
	} if (lexer.tokenType() == TokenType::keyword_select) {
		return parse_select();
	}

	return std::make_unique<Node>(NodeType::error);
}

std::unique_ptr<Node> Parser::parse_create_table() {
	std::vector<ColDefNode> cols_def {};

	lexer.skipToken(TokenType::keyword_create);
	lexer.skipToken(TokenType::keyword_table);

	if (lexer.tokenType() != TokenType::identifier)	{ /* TODO handle error */ }
	std::string table_name = lexer.currentToken().token_string;
	lexer.nextToken();
	
	lexer.skipToken(TokenType::open_paren);
	do {
		std::string	column_name;
		ColumnType	column_type;
		int		column_len {1};
		bool		column_nullable {true};

		// column name
		if (lexer.tokenType() != TokenType::identifier)	{ /* TODO handle error */ }
		column_name = lexer.currentToken().token_string;
		lexer.nextToken();

		// column type and optionaly len
		if (lexer.tokenType() == TokenType::keyword_int) {
			column_type = ColumnType::integer_type;
			lexer.nextToken();
		} else if (lexer.tokenType() == TokenType::keyword_float) {
			column_type = ColumnType::float_type;
			lexer.nextToken();
		} else if (lexer.tokenType() == TokenType::keyword_varchar) {
			column_type = ColumnType::varchar_type;
			lexer.nextToken();
			lexer.skipToken(TokenType::open_paren);
			if (lexer.tokenType() == TokenType::int_number) {
				column_len = std::stoi(lexer.currentToken().token_string);
				lexer.nextToken();
			} else { /* TODO handle error */ }
			lexer.skipToken(TokenType::close_paren);
		} else { /* TODO handle error */ }

		if (lexer.tokenType() == TokenType::keyword_not) {
			lexer.nextToken();
			lexer.skipToken(TokenType::keyword_null);
			column_nullable = false;
		} else if (lexer.tokenType() == TokenType::keyword_null) {
			lexer.nextToken();
		}

		cols_def.push_back(ColDefNode(column_name, column_type, column_len, column_nullable));

		if (lexer.tokenType() == TokenType::comma) lexer.nextToken();
		
		// TODO in future constraints

	} while (lexer.tokenType() != TokenType::close_paren);


	return std::make_unique<CreateTableNode>(table_name, cols_def);
}

std::unique_ptr<Node> Parser::parse_select() {
	std::vector<Node> exec_code {};

	return std::make_unique<Node>(NodeType::not_implemented_yet);
}