#ifndef PARSER_H
#define PARSER_H

#include "ast.h"
#include "lexer.h"

struct TypeAttrs {
    bool root = false;
    QString display;
};

class Parser {
public:
    explicit Parser(Lexer lex);

    Module parseModule();

private:
    TypeDef parseTypeDef();
    QVector<StmtPtr> parseBlock();

    StmtPtr parseStatement();
    StmtPtr parseScalarStmt();
    StmtPtr parseSkipStmt();
    StmtPtr parseAlignStmt();
    StmtPtr parseSeekStmt();
    StmtPtr parseIfStmt();
    StmtPtr parseWhileStmt();
    StmtPtr parseRepeatStmt();
    StmtPtr parseForStmt();
    StmtPtr parseAssignStmt();

    TypeAttrs parseTypeAttrs();
    UiFlags parseUiFlags(bool defaultUi);
    UiFlags parseInlineUiSuffix();

    QVector<StmtPtr> parseCriteriaBlock();
    StmtPtr parseRequireStmt();
    StmtPtr parseByteOrderStmt();
    StmtPtr parseBreakStmt();
    StmtPtr parseInlineStmt();
    StmtPtr parseArrayStmt();
    StmtPtr parseConstStmt();
    StmtPtr parseMatchStmt();

    ExprPtr parseExpr(int minPrec = 0);
    ExprPtr parsePrimary();
    ExprPtr parsePostfix(ExprPtr lhs);

    int precedence(const Token& t) const;
    QString tokenOpText(const Token& t) const;

    // pipeline: expr | stage | stage
    ExprPtr parsePipeIfAny(ExprPtr base);

    Token expect(TokenKind k, const char* msg) { return m_lex.expect(k, msg); }
    bool match(TokenKind k) { return m_lex.match(k); }
    const Token& peek() const { return m_lex.peek(); }

    ScalarType scalarFrom(TokenKind k) const;

    Lexer m_lex;
};

#endif // PARSER_H