#pragma once

#include <cstdint>
#include <memory>
#include <elna/source/lexer.hpp>

namespace elna::source
{
    enum class binary_operator
    {
        sum,
        subtraction,
        multiplication,
        division
    };

    class definition;
    class bang_statement;
    class block;
    class binary_expression;
    class variable_expression;
    class integer_literal;

    struct parser_visitor
    {
        virtual void visit(definition *) = 0;
        virtual void visit(bang_statement *) = 0;
        virtual void visit(block *) = 0;
        virtual void visit(binary_expression *) = 0;
        virtual void visit(variable_expression *) = 0;
        virtual void visit(integer_literal *) = 0;
    };

    /**
     * AST node.
     */
    class node
    {
    public:
        virtual void accept(parser_visitor *) = 0;
    };

    class statement : public node
    {
    };

    class expression : public node
    {
    };

    /**
     * Constant definition.
     */
    class definition : public node
    {
        std::string m_identifier;
        std::unique_ptr<integer_literal> m_body;

    public:
        definition(std::string&& identifier, std::unique_ptr<integer_literal>&& body);
        virtual void accept(parser_visitor *visitor) override;

        std::string& identifier() noexcept;
        integer_literal& body();
    };

    class bang_statement : public statement
    {
        std::unique_ptr<expression> m_body;

    public:
        bang_statement(std::unique_ptr<expression>&& body);
        virtual void accept(parser_visitor *visitor) override;

        expression& body();
    };

    /**
     * Block.
     */
    class block : public node
    {
        std::unique_ptr<statement> m_body;
        std::vector<std::unique_ptr<definition>> m_definitions;

    public:
        block(std::vector<std::unique_ptr<definition>>&& definitions, std::unique_ptr<statement>&& body);
        virtual void accept(parser_visitor *visitor) override;

        statement& body();
        std::vector<std::unique_ptr<definition>>& definitions() noexcept;
    };

    class integer_literal : public expression
    {
        std::int32_t m_number;

    public:
        integer_literal(const std::int32_t value);
        virtual void accept(parser_visitor *visitor) override;

        std::int32_t number() const noexcept;
    };

    class variable_expression : public expression
    {
        std::string m_name;

    public:
        variable_expression(const std::string& name);
        virtual void accept(parser_visitor *visitor) override;

        const std::string& name() const noexcept;
    };

    class binary_expression : public expression
    {
        std::unique_ptr<expression> m_lhs;
        std::unique_ptr<expression> m_rhs;
        binary_operator m_operator;

    public:
        binary_expression(std::unique_ptr<expression>&& lhs,
                std::unique_ptr<expression>&& rhs, const unsigned char operation);

        virtual void accept(parser_visitor *visitor) override;
        expression& lhs();
        expression& rhs();
        binary_operator operation() const noexcept;
    };

    struct parser
    {
        parser(const std::vector<token>& tokens);

        std::unique_ptr<block> parse();

    private:
        std::unique_ptr<expression> parse_factor();
        std::unique_ptr<expression> parse_term();
        std::unique_ptr<expression> parse_expression();
        std::unique_ptr<definition> parse_definition();
        std::unique_ptr<statement> parse_bang_statement();
        std::vector<std::unique_ptr<definition>> parse_definitions();
        std::unique_ptr<block> parse_block();

        std::vector<token>::const_iterator tokens;
        std::vector<token>::const_iterator end;
    };
}