#pragma once
#include <memory>
#include "Lexer.h"
#include "AST/NumberNode.h"

class Parser
{
    template<typename T>
    struct ErrorOr
    {
        std::string error()
        {
            return m_error;
        }
        std::shared_ptr<T> get()
        {
            return m_ptr;
        }
        Token errtok()
        {
            return *(error_tok.get());
        }

        ErrorOr(T* ptr) : m_ptr(ptr), m_is_error(false) {}
        ErrorOr(const std::string& error, const Token& error_tok) : m_error(error), m_is_error(true), error_tok(error_tok) {}

        bool is_error() { return m_is_error; }

    private:
        bool m_is_error;
        std::string m_error;
        std::shared_ptr<Token> error_tok;
        std::shared_ptr<T> m_ptr;
    };
private:
    Parser(const TokenStream& tokens);
    TokenStream tokens;

    ErrorOr<ExprNode> walk_expr();
    ErrorOr<NumberNode> walk_number();

    int m_index;
    int saved_m_index;

    void save_current_position();
    void restore_current_position();
public:
    ~Parser();

    static std::shared_ptr<Parser> new_parser(const TokenStream& tokens);
    std::shared_ptr<ASTNode> parse();
};