import t, c
from stdint import *
import memhub
import string

# Import submodule
from .tokens import (
    Token, TokenType, Keyword, TokOp, _init_tables,
)
# Common Section: Base Classes, Enums, Constants, Helper Functions, Dump
from .base import (
    AST, ASTKind, ASTCtx, OpKind, ASTFlag,
    # Constants
    CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, CONST_CHAR,
    FLAG_IS_ASYNC, FLAG_SIMPLE, FLAG_HAS_STAR,
    # Helper Functions
    _init_ast, _copy_str, _set_pos, _inherit_pos, _set_parent_list,
    _binop_from_op, _augop_from_op, _cmpop_from_op,
    _emit, _emit_str, _emit_int, _dump_list,
    dump, _op_name,
)
# Statement Nodes: Module, Expression, Interactive, FunctionType
from .stmts import (
    # Module Layer
    Module, Expression, Interactive, FunctionType,
    # Statement
    FunctionDef, ClassDef, Return, Delete, Assign, AugAssign, AnnAssign,
    For, While, If, With, Raise, Try, Assert, Global, Nonlocal,
    Pass, Break, Continue, Expr, Import, ImportFrom, Match,
)
# Expression Nodes: BoolOp, BinOp, UnaryOp, Lambda, IfExp, Dict, Set
from .exprs import (
    # Expression Layer
    BoolOp, BinOp, UnaryOp, Lambda, IfExp, Dict, Set,
    ListComp, SetComp, DictComp, GeneratorExp,
    Await, Yield, YieldFrom, FormattedValue, JoinedStr,
    Constant, NamedExpr, Attribute, Subscript, Starred, Name,
    List, Tuple, Slice,
    Call, Compare, OpNode,
)
# Auxiliary Nodes
from .astaux import (
    ExceptHandler, Arguments, Arg, Keyword, Alias, WithItem,
    Comprehension,
)
# Pattern Matching
from .match import (
    MatchCase, MatchValue, MatchSingleton, MatchSequence,
    MatchMapping, MatchClass, MatchStar, MatchAs, MatchOr,
)
# from .visitor import ASTVisitor
from .lexer import Lexer, _lexer_init, tokenize, new_lexer
from .parser import Parser, _parser_init, parse_tokens, new_parser
from .parser import _parse_test
from .parser import _dbg_lookup_lit_val, _dbg_lit_found
from .parser import get_parse_err_line, get_parse_err_col, get_parse_err_msg

# ============================================================
# Global Memory Pool Pointer (follows project rules: declare _mbuddy)
# User initializes in main: ast._mbuddy = memhub.MemBuddy(arena, size)
# ============================================================
_mbuddy: memhub.MemBuddy | t.CPtr


# ============================================================
# Common API: parse
# ============================================================

def parse(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr:
    """Parse Python source code, return the AST Module node.

    Parameters:
        src: NUL source code string, terminated with NUL
        pool: memhub.MemManager instance, to allocate AST nodes

    Returns:
        AST Module node, or None
    """
    if src is None or pool is None:
        return None
    _init_tables(pool)
    lx: Lexer | t.CPtr = new_lexer(pool)
    if lx is None:
        return None
    _lexer_init(lx, src, pool)
    tokens: Token | t.CPtr = tokenize(lx)
    if tokens is None:
        return None
    tree: AST | t.CPtr = parse_tokens(pool, tokens)
    return tree


def parse_expression(src: str, pool: memhub.MemManager | t.CPtr) -> AST | t.CPtr:
    """Parse a single expression, return the Expression node.

    Parameters:
        src: NUL expression string, terminated with NUL
        pool: memhub.MemManager instance, to allocate AST nodes

    Returns:
        Expression node, or None
    """
    if src is None or pool is None:
        return None
    _init_tables(pool)
    lx: Lexer | t.CPtr = new_lexer(pool)
    if lx is None: return None
    _lexer_init(lx, src, pool)
    tokens: Token | t.CPtr = tokenize(lx)
    if tokens is None: return None
    ps: Parser | t.CPtr = new_parser(pool)
    if ps is None: return None
    _parser_init(ps, tokens, pool)
    body: AST | t.CPtr = _parse_test(ps)
    return Expression(pool, body)