import t, c
from stdint import *
import memhub
import string
import llvmlite
import stdio
import ast
import hashtable


# ============================================================
# HandlesStruct - 结构体类型注册和字段查找
#
# 管理 class 定义的结构体类型信息:
# - 类名 → LLVM StructType
# - 字段名 → 字段索引和类型
#
# 使用全局数组存储，线性查找（结构体数量通常很少）
# ============================================================

STRUCT_MAX: t.CDefine = 512
FIELD_MAX: t.CDefine = 32
FIELD_NAME_MAX: t.CDefine = 64


# ============================================================
# FieldEntry - 字段信息条目
# ============================================================
@t.NoVTable
class FieldEntry:
    Name: t.CChar | t.CPtr           # 字段名（字符串）
    Index: int                    # 字段在结构体中的索引
    Ty: llvmlite.LLVMType | t.CPtr   # 字段的 LLVM 类型
    DefaultVal: ast.AST | t.CPtr     # 默认值 AST 节点（None=无默认值）
    AnnotClassName: t.CChar | t.CPtr    # 原始类型注解的类名（str 别名在结构体字段中触发编译器 bug，改用显式联合类型）


# ============================================================
# StructEntry - 结构体注册条目
# ============================================================
@t.NoVTable
class StructEntry:
    Name: t.CChar | t.CPtr               # 类名
    Ty: llvmlite.LLVMType | t.CPtr       # LLVM StructType
    FieldCount: int                  # 字段数量
    Fields: FieldEntry | t.CPtr         # 字段数组（FIELD_MAX 个槽位）
    IsUnion: int                     # 1=联合体 / 0=普通结构体
    IsOOP: int                       # 1=OOP结构体（有方法） / 0=纯内存结构体
    HasInit: int                     # 1=有__init__方法 / 0=无
    HasNew: int                      # 1=有__new__方法 / 0=无
    HasVTable: int                   # 1=有虚表 / 0=无虚表
    IsNoVTable: int                  # 1=明确标记 @t.NoVTable / 0=未标记
    ParentName: t.CChar | t.CPtr        # 父类名（None=无父类）
    VTableMethodCount: int           # 虚表中的方法数量
    VTableMethods: t.CChar | t.CPtr     # 虚表方法名数组（每个方法名 str，VTableMethodCount 个）
    ModuleSha1: t.CChar | t.CPtr        # 定义该类的模块 SHA1（None=无 SHA1）


# ============================================================
# 全局注册表（静态分配）
# ============================================================
_struct_table: StructEntry | t.CPtr = None
_struct_count: int = 0


# ============================================================
# 跨模块命名空间隔离：per-file 结构体可见性
#
# _visible_structs: 当前文件可见的结构体名（HashTable，O(1) 查找）
# _strict_visibility: 1=严格模式（仅本地+import可见）/ 0=宽松模式（全部可见）
#
# 每个文件翻译前调用 reset_visible_structs 重置
# ============================================================
_visible_structs: hashtable.HashTable | t.CPtr = None
_strict_visibility: int = 0


# ============================================================
# reset_visible_structs — 重置可见性状态（每个文件翻译前调用）
# ============================================================
def reset_visible_structs(pool: memhub.MemBuddy | t.CPtr, strict: int):
    """重置可见性状态（每个文件翻译前调用）

    pool: 内存分配器（严格模式下创建 HashTable）
    strict: 1=严格模式（用户文件），0=宽松模式（includes 文件）
    """
    global _visible_structs
    global _strict_visibility
    _strict_visibility = strict
    if strict != 0:
        # 严格模式：创建新的 HashTable 记录可见结构体
        _visible_structs = hashtable.HashTable(pool)
    else:
        # 宽松模式：全部可见，不需要 HashTable
        _visible_structs = None


# ============================================================
# add_visible_struct — 添加可见结构体名
# ============================================================
def add_visible_struct(pool: memhub.MemBuddy | t.CPtr, name: str):
    """添加可见结构体名（类定义时和 from-import 时调用）"""
    global _visible_structs
    if name is None:
        return
    # 宽松模式：全部可见，无需记录
    if _strict_visibility == 0:
        return
    if _visible_structs is None:
        return
    # 已存在则跳过（HashTable.__setitem__ 会覆盖，此处提前检查避免重复分配）
    if _visible_structs.__contains__(name) != 0:
        return
    _visible_structs.set_int(name, 1)


# ============================================================
# is_struct_visible — 检查结构体是否在当前文件可见
# ============================================================
def is_struct_visible(name: str) -> int:
    """检查结构体是否可见，返回 1=可见 / 0=不可见"""
    if _strict_visibility == 0:
        return 1
    if name is None or _visible_structs is None:
        return 0
    return _visible_structs.__contains__(name)


# ============================================================
# 初始化结构体注册表
# ============================================================
def init_struct_table(pool: memhub.MemBuddy | t.CPtr) -> int:
    """初始化结构体注册表，返回 1 成功"""
    global _struct_table
    global _struct_count

    if _struct_table is not None:
        return 1

    entry_size: t.CSizeT = StructEntry.__sizeof__()
    _struct_table = pool.alloc(entry_size * STRUCT_MAX)
    if _struct_table is None:
        return 0
    string.memset(_struct_table, 0, entry_size * STRUCT_MAX)
    _struct_count = 0
    return 1


# ============================================================
# _get_struct_entry — 获取第 i 个 StructEntry 槽位
# ============================================================
def _get_struct_entry(i: int) -> StructEntry | t.CPtr:
    """获取第 i 个结构体条目"""
    if _struct_table is None or i < 0 or i >= STRUCT_MAX:
        return None
    entry_size: t.CSizeT = StructEntry.__sizeof__()
    addr: t.CUInt64T = t.CUInt64T(_struct_table) + i * entry_size
    return (StructEntry | t.CPtr)(t.CVoid(addr, t.CPtr))


# ============================================================
# _get_field_entry — 获取结构体中第 i 个 FieldEntry 槽位
# ============================================================
def _get_field_entry(struct_entry: StructEntry | t.CPtr, i: int) -> FieldEntry | t.CPtr:
    """获取结构体中第 i 个字段条目"""
    if struct_entry is None or i < 0 or i >= FIELD_MAX:
        return None
    field_size: t.CSizeT = FieldEntry.__sizeof__()
    addr: t.CUInt64T = t.CUInt64T(struct_entry.Fields) + i * field_size
    return (FieldEntry | t.CPtr)(t.CVoid(addr, t.CPtr))


# ============================================================
# register_struct — 注册结构体类型
#
# 返回 StructEntry 指针，可用于添加字段
# ============================================================
def register_struct(pool: memhub.MemBuddy | t.CPtr,
                    name: str,
                    struct_ty: llvmlite.LLVMType | t.CPtr,
                    sha1: str = None) -> StructEntry | t.CPtr:
    """注册结构体类型，返回 StructEntry 指针

    用类型指针去重（is 比较），不用类名去重。
    这样跨模块同名类可以共存，各自有独立的字段定义。
    sha1 参数在注册时直接设置 ModuleSha1（避免 set_struct_sha1 找错 entry）。
    """
    if init_struct_table(pool) == 0:
        return None

    # 用类型指针去重（同一类型不重复注册，支持跨模块同名类）
    for i in range(_struct_count):
        existing: StructEntry | t.CPtr = _get_struct_entry(i)
        if existing is not None and existing.Ty is not None:
            if existing.Ty is struct_ty:
                return existing

    if _struct_count >= STRUCT_MAX:
        stdio.printf("[STRUCT] table full, cannot register %s\n", name)
        return None

    entry: StructEntry | t.CPtr = _get_struct_entry(_struct_count)
    if entry is None:
        return None

    # 分配字段数组
    field_size: t.CSizeT = FieldEntry.__sizeof__()
    entry.Fields = pool.alloc(field_size * FIELD_MAX)
    if entry.Fields is None:
        return None
    string.memset(entry.Fields, 0, field_size * FIELD_MAX)

    # 复制类名
    name_len: t.CSizeT = string.strlen(name)
    name_buf: t.CChar | t.CPtr = pool.alloc(name_len + 1)
    if name_buf is not None:
        string.strcpy(name_buf, name)
        entry.Name = name_buf

    entry.Ty = struct_ty
    entry.FieldCount = 0

    # 注册时直接设置 SHA1（避免 set_struct_sha1 跨模块同名时找错 entry）
    if sha1 is not None:
        sha1_len: t.CSizeT = string.strlen(sha1)
        sha1_buf: t.CChar | t.CPtr = pool.alloc(sha1_len + 1)
        if sha1_buf is not None:
            string.strcpy(sha1_buf, sha1)
            entry.ModuleSha1 = sha1_buf

    _struct_count += 1
    return entry


# ============================================================
# set_struct_sha1 — 设置结构体所属模块的 SHA1
#
# 在翻译类定义时调用，记录类所属模块的 SHA1。
# 跨模块方法调用时（如 __before_init__/__init__），通过 SHA1
# 构造正确的函数名（"{sha1}.{ClassName}.{method}"）。
# ============================================================
def set_struct_sha1(pool: memhub.MemBuddy | t.CPtr,
                    class_name: str, sha1: str) -> int:
    """设置结构体所属模块的 SHA1，返回 1=成功 / 0=失败"""
    if class_name is None or sha1 is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(class_name)
    if entry is None:
        return 0
    # 复制 SHA1 字符串（避免悬空指针）
    sha1_len: t.CSizeT = string.strlen(sha1)
    sha1_buf: t.CChar | t.CPtr = pool.alloc(sha1_len + 1)
    if sha1_buf is None:
        return 0
    string.strcpy(sha1_buf, sha1)
    entry.ModuleSha1 = sha1_buf
    return 1


# ============================================================
# get_struct_sha1 — 获取结构体所属模块的 SHA1
#
# 跨模块方法调用时使用，返回 None=无 SHA1（本模块定义或无 SHA1）
# ============================================================
def get_struct_sha1(class_name: str) -> str:
    """获取结构体所属模块的 SHA1，返回 None=无 SHA1"""
    if class_name is None or _struct_table is None:
        return None
    entry: StructEntry | t.CPtr = find_struct(class_name)
    if entry is None:
        return None
    return entry.ModuleSha1


# ============================================================
# add_field — 向结构体添加字段信息
# ============================================================
def add_field(pool: memhub.MemBuddy | t.CPtr,
              struct_entry: StructEntry | t.CPtr,
              field_name: str,
              field_ty: llvmlite.LLVMType | t.CPtr,
              default_val: ast.AST | t.CPtr = None,
              annot_class_name: t.CChar | t.CPtr = None) -> int:
    """向结构体添加字段，返回字段索引（-1 失败）

    default_val: 字段默认值 AST 节点（可选，None=无默认值）
    annot_class_name: 原始类型注解的类名（可选，用于联合类型字段的方法调用解析）
    """
    if struct_entry is None or field_name is None or field_ty is None:
        return -1

    if struct_entry.FieldCount >= FIELD_MAX:
        stdio.printf("[STRUCT] field table full for %s\n", struct_entry.Name)
        return -1

    idx: int = struct_entry.FieldCount
    fe: FieldEntry | t.CPtr = _get_field_entry(struct_entry, idx)
    if fe is None:
        return -1

    # 复制字段名
    name_len: t.CSizeT = string.strlen(field_name)
    name_buf: t.CChar | t.CPtr = pool.alloc(name_len + 1)
    if name_buf is not None:
        string.strcpy(name_buf, field_name)
        fe.Name = name_buf

    fe.Index = idx
    fe.Ty = field_ty
    fe.DefaultVal = default_val
    fe.AnnotClassName = annot_class_name

    struct_entry.FieldCount = idx + 1
    return idx


# ============================================================
# find_struct — 按类名查找结构体
# ============================================================
def find_struct(name: str) -> StructEntry | t.CPtr:
    """按类名查找结构体，返回 StructEntry 或 None"""
    if name is None or _struct_table is None:
        return None
    for i in range(_struct_count):
        entry: StructEntry | t.CPtr = _get_struct_entry(i)
        if entry is not None and entry.Name is not None:
            if string.strcmp(entry.Name, name) == 0:
                return entry
    return None


# ============================================================
# find_struct_by_module — 按类名 + SHA1 查找结构体
#
# 跨模块同名类区分：Phase B 重新翻译时，必须找到当前模块
# 注册的结构体（而非第一个同名条目），否则 struct type、
# 字段布局、GEP 索引全部错误。
# ============================================================
def find_struct_by_module(name: str, sha1: str) -> StructEntry | t.CPtr:
    """按类名 + SHA1 查找结构体，返回 StructEntry 或 None

    SHA1 非 None 时：精确匹配 name+sha1，未找到返回 None（不回退，避免跨模块同名找错）
    SHA1 为 None 时：回退到 find_struct(name) 按类名查找第一个
    """
    if name is None or _struct_table is None:
        return None
    if sha1 is not None:
        for i in range(_struct_count):
            entry: StructEntry | t.CPtr = _get_struct_entry(i)
            if entry is not None and entry.Name is not None:
                if string.strcmp(entry.Name, name) == 0:
                    if entry.ModuleSha1 is not None:
                        if string.strcmp(entry.ModuleSha1, sha1) == 0:
                            return entry
        # SHA1 查找失败：不回退到 find_struct（会返回跨模块同名错误 entry）
        # 返回 None 让调用方创建新类型，避免 Phase B 用错误类型短路
        return None
    # 无 SHA1：按类名查找第一个
    return find_struct(name)


# ============================================================
# find_struct_by_type — 按类型指针查找结构体（is 身份比较）
#
# 用于 _translate_oop_methods 等已有 struct_ty 的场景，
# 直接用指针身份定位 entry，规避跨模块同名类 find_struct 找错的问题。
# ============================================================
def find_struct_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> StructEntry | t.CPtr:
    """按类型指针查找结构体（is 比较），返回 StructEntry 或 None"""
    if struct_ty is None or _struct_table is None:
        return None
    for i in range(_struct_count):
        entry: StructEntry | t.CPtr = _get_struct_entry(i)
        if entry is not None and entry.Ty is not None:
            if entry.Ty is struct_ty:
                return entry
    return None


# ============================================================
# lookup_field — 按结构体类型和字段名查找字段信息
# ============================================================
def lookup_field(struct_ty: llvmlite.LLVMType | t.CPtr,
                 field_name: str) -> FieldEntry | t.CPtr:
    """按结构体类型和字段名查找字段信息

    两遍查找策略（跨模块同名类冲突的根本修复）:
    第一遍: 类型指针 is 身份比较（最高优先级，类型唯一确定 entry）
    第二遍: 名称回退（is 未匹配时，按类名/strstr 匹配，字段未找到时 continue）
    """
    if struct_ty is None or field_name is None or _struct_table is None:
        return None

    # ============================================================
    # 两遍查找策略（跨模块同名类冲突的根本修复）:
    #
    # 第一遍: 用类型指针 is 身份比较（最高优先级）
    #   - is 匹配唯一确定 entry，字段未找到直接返回 None
    #   - 规避联合类型 == BUG，且不受遍历顺序影响
    #
    # 第二遍: 名称回退（is 未匹配到任何 entry 时才执行）
    #   - 用于未注册类型或 is 不可靠的场景
    #   - 名称匹配但字段未找到时 continue（继续检查其他同名 entry）
    # ============================================================

    # 第一遍: is 身份比较
    for i in range(_struct_count):
        entry: StructEntry | t.CPtr = _get_struct_entry(i)
        if entry is not None and entry.Ty is not None:
            if entry.Ty is struct_ty:
                # is 匹配，查找字段
                for fi in range(entry.FieldCount):
                    fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
                    if fe is not None and fe.Name is not None:
                        if string.strcmp(fe.Name, field_name) == 0:
                            return fe
                # is 匹配但字段未找到（类型唯一确定，无需继续）
                return None

    # 第二遍: 名称回退（is 未匹配到）
    ty_name: str = _extract_struct_name(struct_ty)
    if ty_name is not None:
        for i in range(_struct_count):
            entry: StructEntry | t.CPtr = _get_struct_entry(i)
            if entry is not None and entry.Name is not None:
                matched: int = 0
                if string.strcmp(entry.Name, ty_name) == 0:
                    matched = 1
                elif string.strstr(ty_name, entry.Name) is not None:
                    matched = 1
                if matched != 0:
                    # 查找字段
                    for fi in range(entry.FieldCount):
                        fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
                        if fe is not None and fe.Name is not None:
                            if string.strcmp(fe.Name, field_name) == 0:
                                return fe
                    # 名称匹配但字段未找到，继续检查其他同名 entry（跨模块同名）
                    continue
    # 所有条目都未匹配
    return None


# ============================================================
# lookup_field_by_class — 按类名和字段名查找字段信息
# ============================================================
def lookup_field_by_class(class_name: str,
                          field_name: str,
                          sha1: str = None) -> FieldEntry | t.CPtr:
    """按类名和字段名查找字段信息

    优先用 SHA1 匹配（跨模块同名类区分），无 SHA1 时按类名查找第一个
    """
    if class_name is None or field_name is None:
        return None

    # 优先用 SHA1 匹配（跨模块同名类区分）
    if sha1 is not None:
        sha1_matched: int = 0
        for i in range(_struct_count):
            entry: StructEntry | t.CPtr = _get_struct_entry(i)
            if entry is not None and entry.Name is not None:
                if string.strcmp(entry.Name, class_name) == 0:
                    if entry.ModuleSha1 is not None:
                        if string.strcmp(entry.ModuleSha1, sha1) == 0:
                            sha1_matched = 1
                            # SHA1 + 类名匹配，查找字段
                            for fi in range(entry.FieldCount):
                                fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
                                if fe is not None and fe.Name is not None:
                                    if string.strcmp(fe.Name, field_name) == 0:
                                        return fe
                            return None

    # 回退: 无 SHA1 或 SHA1 匹配失败，按类名查找第一个
    entry = find_struct(class_name)
    if entry is None:
        return None
    for fi in range(entry.FieldCount):
        fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
        if fe is not None and fe.Name is not None:
            if string.strcmp(fe.Name, field_name) == 0:
                return fe
    return None


# ============================================================
# get_struct_type — 按类名获取结构体的 LLVM 类型
# ============================================================
def get_struct_type(class_name: str) -> llvmlite.LLVMType | t.CPtr:
    """按类名获取结构体的 LLVM 类型"""
    entry: StructEntry | t.CPtr = find_struct(class_name)
    if entry is not None:
        return entry.Ty
    return None


# ============================================================
# get_field_by_index — 按类名和字段索引获取字段信息
#
# 用于构造函数 Point(10, 20) 按顺序访问字段
# ============================================================
def get_field_by_index(class_name: str,
                       idx: int) -> FieldEntry | t.CPtr:
    """按类名和字段索引获取字段信息"""
    if class_name is None:
        return None
    entry: StructEntry | t.CPtr = find_struct(class_name)
    if entry is None:
        return None
    if idx < 0 or idx >= entry.FieldCount:
        return None
    return _get_field_entry(entry, idx)


# ============================================================
# struct_has_defaults — 检查结构体是否有任何带默认值的字段
# ============================================================
def struct_has_defaults(class_name: str) -> int:
    """检查结构体是否有任何带默认值的字段，返回 1=有 / 0=无"""
    if class_name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(class_name)
    if entry is None:
        return 0
    for fi in range(entry.FieldCount):
        fe: FieldEntry | t.CPtr = _get_field_entry(entry, fi)
        if fe is not None and fe.DefaultVal is not None:
            return 1
    return 0


# ============================================================
# get_struct_type_from_value — 从 LLVM Value 的类型推断结构体类型
#
# 如果 value 是 Ptr(Struct(...))，返回 Struct 类型
# ============================================================
def _is_struct_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """检查 ty 是否是 Struct 类型（独立函数，规避嵌套 match 编译器 BUG）"""
    if ty is None:
        return 0
    match ty:
        case llvmlite.LLVMType.Struct(fields, fcount, name):
            return 1
        case _:
            return 0


def get_struct_type_from_value(val: llvmlite.Value | t.CPtr) -> llvmlite.LLVMType | t.CPtr:
    """从 Value 的类型推断结构体类型"""
    if val is None or val.Ty is None:
        return None
    match val.Ty:
        case llvmlite.LLVMType.Ptr(pointee):
            if _is_struct_type(pointee) != 0:
                return pointee
            return None
        case _:
            return None


# ============================================================
# 联合体支持函数
# ============================================================

# ============================================================
# mark_as_union — 标记已注册的结构体为联合体
#
# 联合体用 Struct([Array(Int8, max_size)]) 表示，
# 注册时用 register_struct 注册类型，再用此函数标记 IsUnion=1
# ============================================================
def mark_as_union(name: str) -> int:
    """标记已注册的结构体为联合体，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.IsUnion = 1
    return 1


# ============================================================
# is_union_by_name — 按类名检查是否为联合体
# ============================================================
def is_union_by_name(name: str) -> int:
    """按类名检查是否为联合体，返回 1=是 / 0=否"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.IsUnion


# ============================================================
# is_union_by_type — 按类型指针检查是否为联合体
# ============================================================
def is_union_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> int:
    """按类型指针检查是否为联合体，返回 1=是 / 0=否

    先尝试类型指针 == 比较，失败时回退到名称匹配
    """
    if struct_ty is None or _struct_table is None:
        return 0
    ty_name: str = _extract_struct_name(struct_ty)
    for i in range(_struct_count):
        entry: StructEntry | t.CPtr = _get_struct_entry(i)
        if entry is not None and entry.Ty is not None:
            matched: int = 0
            if entry.Ty is struct_ty:
                matched = 1
            elif ty_name is not None and entry.Name is not None:
                if string.strcmp(entry.Name, ty_name) == 0:
                    matched = 1
                elif string.strstr(ty_name, entry.Name) is not None:
                    matched = 1
            if matched != 0:
                return entry.IsUnion
    return 0


# ============================================================
# OOP 支持函数
# ============================================================

# ============================================================
# mark_as_oop — 标记已注册的结构体为 OOP（有方法）
# ============================================================
def mark_as_oop(name: str) -> int:
    """标记已注册的结构体为 OOP，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.IsOOP = 1
    return 1


# ============================================================
# is_oop_by_name — 按类名检查是否为 OOP 结构体
# ============================================================
def is_oop_by_name(name: str) -> int:
    """按类名检查是否为 OOP 结构体，返回 1=是 / 0=否"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.IsOOP


# ============================================================
# mark_has_init — 标记结构体拥有 __init__ 方法
# ============================================================
def mark_has_init(name: str) -> int:
    """标记结构体拥有 __init__ 方法，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.HasInit = 1
    return 1


# ============================================================
# has_init_by_name — 按类名检查是否有 __init__ 方法
# ============================================================
def has_init_by_name(name: str) -> int:
    """按类名检查是否有 __init__ 方法，返回 1=有 / 0=无"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.HasInit


# ============================================================
# mark_has_new — 标记结构体拥有 __new__ 方法
# ============================================================
def mark_has_new(name: str) -> int:
    """标记结构体拥有 __new__ 方法，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.HasNew = 1
    return 1


# ============================================================
# has_new_by_name — 按类名检查是否有 __new__ 方法
# ============================================================
def has_new_by_name(name: str) -> int:
    """按类名检查是否有 __new__ 方法，返回 1=有 / 0=无"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.HasNew


# ============================================================
# get_class_name_by_type — 按 LLVM 类型指针查找类名
#
# 用于方法调用：从变量类型 Ptr(Struct(...)) 反查类名，
# 以构造 ClassName.method_name 进行方法查找
# ============================================================
def get_class_name_by_type(pool: memhub.MemBuddy | t.CPtr,
                           struct_ty: llvmlite.LLVMType | t.CPtr) -> str:
    """按类型指针查找类名，返回类名字符串或 None"""
    if struct_ty is None or _struct_table is None:
        return None
    for i in range(_struct_count):
        entry: StructEntry | t.CPtr = _get_struct_entry(i)
        if entry is not None and entry.Ty is not None:
            if entry.Ty is struct_ty:
                return entry.Name
    # 回退: 类型指针比较失败时，遍历所有注册的结构体按名称匹配
    # 提取 struct_ty 的 Name 字段（可能是 "SHA1.ClassName" 格式）
    ty_name: str = _extract_struct_name(struct_ty)
    if ty_name is not None:
        for j in range(_struct_count):
            entry2: StructEntry | t.CPtr = _get_struct_entry(j)
            if entry2 is not None and entry2.Name is not None:
                # 构造 "SHA1.ClassName" 格式进行比较
                entry2_sha1: str = entry2.ModuleSha1
                if entry2_sha1 is not None:
                    full_nm: t.CChar | t.CPtr = pool.alloc(128)
                    if full_nm is not None:
                        viperlib.snprintf(full_nm, 128, "%s.%s", entry2_sha1, entry2.Name)
                        if string.strcmp(full_nm, ty_name) == 0:
                            return entry2.Name
                # 也直接比较类名（struct_ty 的 Name 可能无 SHA1 前缀）
                if string.strcmp(entry2.Name, ty_name) == 0:
                    return entry2.Name
                # 最后回退: strstr 检查包含关系
                # ty_name 可能是 "SHA1.Counter"，entry2.Name 是 "Counter"
                if string.strstr(ty_name, entry2.Name) is not None:
                    return entry2.Name
    return None


# ============================================================
# _extract_struct_name — 从 LLVMType 提取 Struct 变体的 Name 字段
# ============================================================
def _extract_struct_name(ty: llvmlite.LLVMType | t.CPtr) -> str:
    """从 LLVMType 提取 Struct 变体的 Name 字段，返回 None 非 Struct"""
    if ty is None:
        return None
    match ty:
        case llvmlite.LLVMType.Struct(fields, fcount, name):
            return name
        case _:
            return None


# ============================================================
# VTable 支持函数
# ============================================================

# ============================================================
# mark_has_vtable — 标记结构体拥有虚表
# ============================================================
def mark_has_vtable(name: str) -> int:
    """标记结构体拥有虚表，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.HasVTable = 1
    return 1


# ============================================================
# has_vtable_by_name — 按类名检查是否有虚表
# ============================================================
def has_vtable_by_name(name: str) -> int:
    """按类名检查是否有虚表，返回 1=有 / 0=无"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.HasVTable


# ============================================================
# mark_novtable — 标记结构体为 @t.NoVTable
# ============================================================
def mark_novtable(name: str) -> int:
    """标记结构体为 NoVTable，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.IsNoVTable = 1
    return 1


# ============================================================
# is_novtable_by_name — 按类名检查是否为 NoVTable
# ============================================================
def is_novtable_by_name(name: str) -> int:
    """按类名检查是否为 NoVTable，返回 1=是 / 0=否"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.IsNoVTable


# ============================================================
# set_parent_name — 设置父类名
# ============================================================
def set_parent_name(name: str, parent_name: str) -> int:
    """设置结构体的父类名，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.ParentName = parent_name
    return 1


# ============================================================
# get_parent_name — 获取父类名
# ============================================================
def get_parent_name(name: str) -> str:
    """获取结构体的父类名，返回 None=无父类"""
    if name is None:
        return None
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return None
    return entry.ParentName


# ============================================================
# set_vtable_methods — 设置虚表方法名数组
#
# methods 是一个 str 数组（每个元素是方法名字符串指针），
# count 是方法数量。数组直接引用，不复制。
# ============================================================
def set_vtable_methods(name: str, methods: t.CChar | t.CPtr, count: int) -> int:
    """设置虚表方法名数组，返回 1=成功 / 0=失败"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    entry.VTableMethods = methods
    entry.VTableMethodCount = count
    return 1


# ============================================================
# get_vtable_method_index — 获取方法在虚表中的索引
#
# 在 VTableMethods 数组中查找方法名，返回索引（-1=未找到）
# ============================================================
def get_vtable_method_index(name: str, method_name: str) -> int:
    """获取方法在虚表中的索引，返回 -1=未找到"""
    if name is None or method_name is None:
        return -1
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None or entry.VTableMethods is None:
        return -1
    # VTableMethods 字段声明为 t.CChar*，但实际存储的是 t.CSizeT 数组
    # 必须转换为 t.CSizeT* 才能正确读取 8 字节指针值
    methods_arr: t.CSizeT | t.CPtr = (t.CSizeT | t.CPtr)(t.CVoid(entry.VTableMethods, t.CPtr))
    for i in range(entry.VTableMethodCount):
        mname_addr: t.CSizeT = methods_arr[i]
        if mname_addr == 0:
            continue
        mname: str = (str | t.CPtr)(t.CVoid(mname_addr, t.CPtr))
        if mname is not None and string.strcmp(mname, method_name) == 0:
            return i
    return -1


# ============================================================
# get_vtable_method_count — 获取虚表方法数量
# ============================================================
def get_vtable_method_count(name: str) -> int:
    """获取虚表方法数量"""
    if name is None:
        return 0
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return 0
    return entry.VTableMethodCount


# ============================================================
# get_vtable_method_name — 获取虚表中第 idx 个方法名
#
# 返回方法名字符串指针，None=越界或未设置
# ============================================================
def get_vtable_method_name(name: str, idx: int) -> str:
    """获取虚表中第 idx 个方法名，返回 None=越界"""
    if name is None or idx < 0:
        return None
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None or entry.VTableMethods is None:
        return None
    if idx >= entry.VTableMethodCount:
        return None
    methods_arr: t.CSizeT | t.CPtr = (t.CSizeT | t.CPtr)(t.CVoid(entry.VTableMethods, t.CPtr))
    mname_addr: t.CSizeT = methods_arr[idx]
    if mname_addr == 0:
        return None
    return (str | t.CPtr)(t.CVoid(mname_addr, t.CPtr))


# ============================================================
# get_field_count — 获取结构体字段数量（访问器，绕过 stub 类型限制）
# ============================================================
def get_field_count(name: str) -> int:
    """获取结构体字段数量，返回 -1=未找到"""
    if name is None:
        return -1
    entry: StructEntry | t.CPtr = find_struct(name)
    if entry is None:
        return -1
    return entry.FieldCount


# ============================================================
# get_field_name_ptr — 获取 FieldEntry 的字段名指针（访问器）
# ============================================================
def get_field_name_ptr(fe: FieldEntry | t.CPtr) -> str:
    """获取 FieldEntry 的字段名，返回 None=未设置"""
    if fe is None:
        return None
    return fe.Name


# ============================================================
# get_field_type_ptr — 获取 FieldEntry 的字段类型指针（访问器）
# ============================================================
def get_field_type_ptr(fe: FieldEntry | t.CPtr) -> llvmlite.LLVMType | t.CPtr:
    """获取 FieldEntry 的字段类型，返回 None=未设置"""
    if fe is None:
        return None
    return fe.Ty


# ============================================================
# get_field_default_ptr — 获取 FieldEntry 的默认值 AST 指针（访问器）
# ============================================================
def get_field_default_ptr(fe: FieldEntry | t.CPtr) -> ast.AST | t.CPtr:
    """获取 FieldEntry 的默认值 AST 节点，返回 None=无默认值"""
    if fe is None:
        return None
    return fe.DefaultVal


# ============================================================
# get_field_annot_class_name — 获取 FieldEntry 的注解类名（访问器）
# ============================================================
def get_field_annot_class_name(fe: FieldEntry | t.CPtr) -> str:
    """获取 FieldEntry 的原始类型注解类名，返回 None=未设置"""
    if fe is None:
        return None
    return fe.AnnotClassName