#pragma once

#include <ostream>
#include <vector>
#include <optional>

#include "../lexer/lexer.hpp"

namespace Solstice {

    enum class NodeType {
        Root, Literal, Identifier,
        FunctionBind, Bind, Set, 
        Lambda, FunctionCall,
        Add, Subtract, Multiply, Divide,
        Equal, NotEqual, GreaterThan, LesserThan
    };

    enum class Precedence {
        NewLine,
        Identifier,
        If, 
        While, 
        Compare, 
        Set,
        FunctionCall,
        Add,
        Multiply,
        Other,
        Root
    };
    
    extern std::unordered_map<TokenType, NodeType> tokToNodeType;

    class Node {
        public:
        NodeType type = NodeType::Root;
        std::vector<Node> children;
        std::variant<Literal, std::string> data;

        Node() = delete;
        Node(NodeType type) : type(type) {}
        Node(NodeType type, const std::vector<Node>& children) : type(type), children(children) {}
        Node(const Literal& literal) : type(NodeType::Literal), data(literal) {}
        Node(const std::string& id) : type(NodeType::Identifier), data(id) {}

        std::optional<Literal> getLiteral() const;
        std::optional<std::string> getIdentifier() const;
    };

    std::ostream& operator<<(std::ostream& stream, const Node& node);

    class Parser {

        std::vector<Token> input;
        Node output{NodeType::Root};

        size_t current = 0;

        std::optional<Token> peek(int64_t ahead = 0);
        std::optional<Token> consume();

        std::optional<Node> getPreviousNode(Node& parent);

        Node parseKwType();

        Node parseHashCimport();
        Node parseHashEffect();

        Node parseAssignBind();
        Node parseAssignSet();
        Node parseAssignType();

        Node parseActionFunction();

        Node parseExpr(TokenType type);

        Node parseOpenCurly();
        Node parseOpenParen();
        Node parseOpenSpiky();
        Node parseCloseCurly();
        Node parseCloseParen();
        Node parseCloseSpiky();
        Node parseNewLine();

        Node parseLiteral();
        Node parseIdentifier();

        static Precedence getTokenPrecedence(const Token& token);

        // Returns false when finished
        std::optional<Node> parseOneNode(Precedence precedence = Precedence::Other);

        public:
        Parser() = delete;
        Parser(const std::vector<Token>& input) : input(input) {}

        const Node& parse();
    };

}