#include "parsing.h"


namespace parsing {
    namespace {
        Result<std::unique_ptr<AST::Type>, std::string> parse_type(token::TokenStream& stream) {
            token::TokenStream inner{ stream };
            try {
                auto token = inner.expect(token::Type::Ident);

                stream.m_position = inner.m_position;

                auto ty = new AST::FundamentalType{ AST::FundamentalTypeKind::Int };
                return new std::unique_ptr<AST::Type>{ ty };
            }
            catch (std::runtime_error error) {
                return new std::string{ error.what() };
            }
        }

        Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream) {
            token::TokenStream inner{ stream };
            try {
                auto token = inner.next();
                if (token.type == token::Type::LiteralInt) {
                    stream.m_position = inner.m_position;

                    auto expr = new AST::IntLiteralExpression{ 5 };
                    return new std::unique_ptr<AST::Expression>{ expr };
                }
                else {
                    throw std::runtime_error("Expected expression");
                }
            }
            catch (std::runtime_error error) {
                return new std::string{ error.what() };
            }
        }

        Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream) {
            token::TokenStream inner{ stream };
            try {
                if (inner.peek().type == token::Type::ReturnKeyword) {
                    inner.next();
                    auto expression = parse_expression(inner).unwrap();
                    inner.expect(token::Type::Symbol, ";");

                    stream.m_position = inner.m_position;

                    auto ret = new AST::ReturnStatement{ std::move(expression) };
                    return new std::unique_ptr<AST::Statement>{ ret };
                }
                else {
                    throw std::runtime_error("Expected return-keyword");
                }

            }
            catch (std::runtime_error error) {
                return new std::string{ error.what() };
            }
        }
    }

    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream) {
        token::TokenStream inner{ stream };
        try {
            auto type = parse_type(inner).unwrap();
            auto name_token = inner.expect(token::Type::Ident);
            inner.expect(token::Type::Symbol, "(");
            inner.expect(token::Type::Symbol, ")");
            inner.expect(token::Type::Symbol, "{");

            std::vector<std::unique_ptr<AST::Statement>> statements{};

            auto statement = parse_statement(inner);
            while (statement.ok()) {
                statements.push_back(statement.unwrap());
                statement = parse_statement(inner);
            }


            inner.expect(token::Type::Symbol, "}");

            stream.m_position = inner.m_position;

            auto fun = new AST::Function{ std::move(type), {}, "main", std::move(statements) };
            return new std::unique_ptr<AST::TopLevelStatement>{ fun };
        }
        catch (std::runtime_error error) {
            return new std::string(error.what());
        }
    }
}