#ifndef COMDEL_PARSER_H
#define COMDEL_PARSER_H

#include "source_error.h"
#include "presult.h"
#include "token.h"
#include "ast_nodes.h"

#include <optional>
#include <set>
#include <vector>

/// Records the current span and can later be called on
/// an ast node to apply the entire span to that node
///
/// Spanner's call operator MOVES from the node so it should
/// be always used last.
class Spanner {
    // REFERENCE to the parser's prevSpan. After parsing a node this will
    // "point" to the span of the last token contained in the node.
    const Span &prevSpan;

public:
    const Span lo; // the low end of the span, beginning of the node

    Spanner(Span lo, Span &prevSpan) : lo(lo), prevSpan(prevSpan) {}

    template<typename T, typename = std::enable_if<std::is_base_of<AstNode, T>::value>>
    typename std::remove_reference_t<T> operator()(T &&astNode) const {
        astNode.span = lo.to(prevSpan);
        return std::forward<T>(astNode);
    }
};

class ComdelParser {
private:
    std::vector<Token> tokens;
    std::set<TokenType> expectedTokens;

    unsigned int position;
    std::vector<SourceError> errors;

    Span &getPreviousSpan();

    /** Skips current token */
    void bump();
    /** Checks if next token is of given type and if it is consumes it */
    bool consume(TokenType tokenType);
    /** Checks if next token is of given type */
    bool check(TokenType tokenType);
    /** Skips until next keyword on same level
     * Used to continue parsing on error
     * */
    void skipUntilNextKeyword();
    /** Retuns current token */
    Token &current();

    /** Throws error of unexpected types */
    [[nodiscard]] PError unexpected();

    template<typename T>
    PResult<std::vector<T>> parseList(std::optional<TokenType> openDelim,
                                      TokenType closeDelim,
                                      std::optional<TokenType> separator,
                                      bool allowTrailing,
                                      const std::function<PResult<T>()> &parse_f);

    Spanner getSpanner();

    /** Base types */
    PResult<StringNode> parseString();
    PResult<ColorNode> parseColor();
    PResult<IdentifierNode> parseIdentifier();
    PResult<NumberNode> parseNumber();
    PResult<NumberPairNode> parseNumberPair();
    PResult<PropertyNode> parseProperty(std::optional<TokenType> valueType);
    PResult<StringPropertyNode> parseStringProperty();
    PResult<ValueNode> parseValue();

    /** Library types */
    PResult<ValueNode> parseConnectionWire();
    PResult<ComponentNode> parseComponent();
    PResult<EnumNode<ComponentNode::ComponentType>> parseComponentType();
    PResult<AddressSpaceNode> parseAddress();
    PResult<PinNode> parsePin();
    PResult<DisplayNode> parseDisplay();
    PResult<AttributeNode> parseAttribute();
    PResult<PopupNode> parsePopup();
    PResult<RuleNode> parseRule();
    PResult<BusNode> parseBus();
    PResult<WireNode> parseWire();
    PResult<ConnectionNode> parseConnection();
    PResult<ConnectionComponentNode> parseConnectionComponent();
    PResult<DisplayItemNode> parseDisplayItem();
    PResult<IfStatementNode> parseIfStatement();
    PResult<EnumNode<BusNode::BusType>> parseBusType();

    /** Schema types */
    PResult<InstanceNode> parseInstance();
    PResult<InstanceAttributeNode> parseInstanceAttribute();
    PResult<ConnectionInstanceNode> parseConnectionInstance();
    PResult<ConnectionComponentInstanceNode> parseConnectionComponentInstance();

public:
    explicit ComdelParser(std::vector<Token> tokens);

    std::optional<SchemaNode> parseSchema();
    std::optional<LibraryNode> parseLibrary();
    const std::vector<SourceError> &getErrors();
};

#endif // COMDEL_PARSER_H