from __future__ import annotations
from typing import TYPE_CHECKING, Dict, Tuple
if TYPE_CHECKING:
    from lib.core.translator import Translator
from lib.constants import config as _config
from lib.includes import t

import ast
from typing import List, Dict
from enum import IntFlag, auto
from lib.core.TypeSpec import TypeSpec, SymbolMeta, FIELD_ROUTES


EXCEPTION_CODE_MAP = {
    'ValueError': 1, 'TypeError': 2, 'RuntimeError': 3,
    'ZeroDivisionError': 4, 'IndexError': 5, 'KeyError': 6,
    'IOError': 7, 'OSError': 8, 'AssertionError': 9, 'Exception': 99,
}


class FuncMeta(IntFlag):
    NONE = 0
    STATIC_METHOD = auto()
    PROPERTY_GETTER = auto()
    PROPERTY_SETTER = auto()
    PROPERTY_DELETER = auto()
    CLASS_METHOD = auto()
    ABSTRACT = auto()


class CTypeInfo:
    """
    C 类型信息对象 - 统一符号表条目和类型计算

    设计原则:
    - BaseType 是 CType 实例（来自 t 模块），永远不使用硬编码字符串
    - 描述符分为两种:
      - VarConst/VarVolatile: 变量本身（指针）的限定符，如 int * const
      - DataConst/DataVolatile: 指向数据的限定符，如 const int *

    属性（类型计算）:
    - BaseType: t.CType - 基础类型实例 (如 t.CInt(), t.CVoid())
    - PtrCount: int - 指针层数
    - VarConst: bool - 变量本身（指针）是否 const，如 int * const
    - VarVolatile: bool - 变量本身（指针）是否 volatile
    - DataConst: bool - 指向的数据是否 const，如 const int *
    - DataVolatile: bool - 指向的数据是否 volatile
    - ArrayDims: List[str] - 数组维度
    - Storage: t.CType - 存储类 (static, extern 等)
    - IsFuncPtr: bool - 是否函数指针
    - FuncPtrParams: List[Tuple[str, CTypeInfo]] - 函数指针参数列表，每个元素是 (参数名, 参数类型)
    - FuncPtrReturn: CTypeInfo - 函数指针返回类型
    - IsBitField: bool - 是否位域
    - BitWidth: int - 位域宽度
    - IsTypedef/IsStruct/IsEnum/IsUnion: bool - 类型种类

    属性（符号表元数据）:
    - Name: str - 名称（struct/enum/union/typedef 名）
    - Members: Dict[str, CTypeInfo] - 成员字典（用于 struct/union）
    - OriginalType: str - typedef 的原始类型
    - DeclaredType: str - 声明类型
    - CreturnTypes: list - C 返回类型列表
    - Lineno: int - 定义行号
    - IsAnonymous: bool - 是否匿名类型
    - IsCpythonObject: bool - 是否 CPython 对象
    - IsEnumMember: bool - 是否枚举成员
    """

    def __init__(self):
        object.__setattr__(self, '_ts', TypeSpec())
        sm = SymbolMeta()
        sm.meta_list = FuncMeta.NONE
        object.__setattr__(self, '_sm', sm)

    # --- 新公共 API：供新代码直接访问 TypeSpec / SymbolMeta / SymbolKind ---
    @property
    def ts(self) -> TypeSpec:
        """TypeSpec — 纯类型描述（只读）"""
        return self._ts

    @property
    def sm(self) -> SymbolMeta:
        """SymbolMeta — 符号表元数据（只读）"""
        return self._sm

    @property
    def kind(self) -> 'SymbolKind':
        """SymbolKind — 符号类型种类枚举"""
        return self._sm.kind

    def __setattr__(self, name, value):
        """属性设置路由 — 将旧字段名委托到 _ts/_sm/_kind_flags"""
        if name == 'BaseType':
            # BaseType 有复杂的 property setter（自动设置 IsStruct/IsEnum/IsUnion）
            CTypeInfo.BaseType.fset(self, value)
            return
        if name in ('_ts', '_sm', 'ts', 'sm', 'kind'):
            # _ts/_sm 内部字段直接设置；ts/sm/kind 是只读 property，禁止设置
            if name in ('ts', 'sm', 'kind'):
                raise AttributeError(f"'CTypeInfo' attribute '{name}' is read-only")
            object.__setattr__(self, name, value)
            return
        if name in FIELD_ROUTES:
            target, field = FIELD_ROUTES[name]
            if target == 'ts':
                setattr(self._ts, field, value)
            elif target == 'sm':
                setattr(self._sm, field, value)
            elif target == 'kf':
                self._sm._kind_flags[field] = value
            return
        object.__setattr__(self, name, value)

    def __getattr__(self, name):
        """属性读取路由 — 将旧字段名委托到 _ts/_sm/_kind_flags"""
        try:
            ts = object.__getattribute__(self, '_ts')
            sm = object.__getattribute__(self, '_sm')
        except AttributeError:
            raise AttributeError(f"'CTypeInfo' object has no attribute '{name}'")
        if name in FIELD_ROUTES:
            target, field = FIELD_ROUTES[name]
            if target == 'ts':
                return getattr(ts, field)
            elif target == 'sm':
                return getattr(sm, field)
            elif target == 'kf':
                return sm._kind_flags.get(field, False)
        raise AttributeError(f"'CTypeInfo' object has no attribute '{name}'")



    @property
    def BaseType(self) -> t.CType | tuple:
        return self._ts._base_type

    @BaseType.setter
    def BaseType(self, value: t.CType | type | tuple | List):
        """设置 BaseType，接受以下类型：

        - None: 清空
        - t.CType 实例: 单个类型，自动设置 IsStruct/IsEnum/IsUnion 标志
        - type (CType 子类): 如 t.CStruct，自动实例化
        - tuple/list of t.CType: 多个组合类型
        """
        ts = self._ts
        kf = self._sm._kind_flags

        if value is None:
            ts._base_type = None
            kf['IsStruct'] = False
            kf['IsEnum'] = False
            kf['IsUnion'] = False
            kf['IsRenum'] = False
            return

        if isinstance(value, (tuple, list)):
            ts._base_type = tuple(value)
            for v in value:
                if isinstance(v, t.CStruct):
                    kf['IsStruct'] = True
                elif isinstance(v, t.CEnum):
                    kf['IsEnum'] = True
                elif isinstance(v, t.CUnion):
                    kf['IsUnion'] = True
                elif isinstance(v, t.REnum):
                    kf['IsRenum'] = True
                    kf['IsEnum'] = True
            return

        if isinstance(value, type) and issubclass(value, t.CType):
            ts._base_type = value()
            return

        if isinstance(value, t.CType):
            ts._base_type = value
            if isinstance(value, t.CStruct):
                kf['IsStruct'] = True
                kf['IsEnum'] = False
                kf['IsUnion'] = False
                kf['IsRenum'] = False
            elif isinstance(value, t.REnum):
                kf['IsRenum'] = True
                kf['IsEnum'] = True
                kf['IsStruct'] = False
                kf['IsUnion'] = False
            elif isinstance(value, t.CEnum):
                kf['IsEnum'] = True
                kf['IsStruct'] = False
                kf['IsUnion'] = False
                kf['IsRenum'] = False
            elif isinstance(value, t.CUnion):
                kf['IsUnion'] = True
                kf['IsStruct'] = False
                kf['IsEnum'] = False
                kf['IsRenum'] = False
            return

        raise TypeError(f"BaseType must be t.CType instance, type subclass, or tuple of t.CType, got {type(value)}")

    @property
    def TypeCls(self):
        """获取 CType 类（从 BaseType 推断）"""
        bt = self._ts._base_type
        if bt:
            return type(bt)
        kf = self._sm._kind_flags
        if kf.get('IsStruct'):
            return t.CStruct
        if kf.get('IsEnum'):
            return t.CEnum
        if kf.get('IsUnion'):
            return t.CUnion
        if kf.get('IsTypedef'):
            return t._CTypedef
        return None

    @property
    def IsPtr(self) -> bool:
        return self._ts.ptr_count > 0

    @property
    def IsVoid(self) -> bool:
        return isinstance(self._ts._base_type, t.CVoid)

    @property
    def IsStr(self) -> bool:
        return isinstance(self._ts._base_type, t.CChar) and self._ts.ptr_count > 0

    @property
    def IsInt(self) -> bool:
        bt = self._ts._base_type
        return isinstance(bt, t.CType) and getattr(bt, 'IsSigned', None) is not None and bt.IsSigned is True and not isinstance(bt, t.CVoid)

    @property
    def IsUInt(self) -> bool:
        bt = self._ts._base_type
        return isinstance(bt, t.CType) and getattr(bt, 'IsSigned', None) is False

    @property
    def IsFloat(self) -> bool:
        bt = self._ts._base_type
        return isinstance(bt, t.CType) and getattr(bt, 'IsSigned', None) is None and getattr(bt, 'Size', 0) in (32, 64, 128) and not isinstance(bt, t.CVoid)

    @property
    def IsDouble(self) -> bool:
        bt = self._ts._base_type
        return isinstance(bt, t.CDouble) or isinstance(bt, t.CFloat64T)

    @property
    def IsPointerToChar(self) -> bool:
        return isinstance(self._ts._base_type, t.CChar) and self._ts.ptr_count > 0

    def ToString(self) -> str:
        ts = self._ts
        sm = self._sm
        kf = sm._kind_flags
        bt = ts._base_type

        if ts.is_func_ptr:
            return 'Callable'
        parts = []

        if ts.storage and not isinstance(ts.storage, t.CExport):
            parts.append(ts.storage.CName)

        if ts.data_const or ts.data_volatile:
            qualifiers = []
            if ts.data_const:
                qualifiers.append("const")
            if ts.data_volatile:
                qualifiers.append("volatile")
            parts.append("_".join(qualifiers))

        if kf.get('IsTypedef') and sm.name:
            return sm.name
        elif kf.get('IsRenum') and sm.name:
            base_name = sm.name
        elif bt:
            base_name = getattr(bt, 'CName', None) or (bt if isinstance(bt, str) else str(bt))
        else:
            base_name = "void"

        if ts.is_array_ptr:
            ptr_str = ""
            if ts.ptr_count > 0:
                ptr_str = "*" * ts.ptr_count
            if ts.array_ptr:
                inner = ts.array_ptr.ToString()
                if ptr_str:
                    parts.append(f"{base_name} {ptr_str}({inner})")
                else:
                    parts.append(f"{base_name} ({inner})")
            else:
                if ptr_str:
                    parts.append(f"{base_name} {ptr_str}()")
                else:
                    parts.append(f"{base_name} ()")
        elif ts.array_ptr:
            inner = ts.array_ptr.ToString()
            if ts.ptr_count > 0:
                parts.append(f"{base_name} {'*' * ts.ptr_count}({inner})")
            else:
                parts.append(f"{base_name} ({inner})")
        else:
            parts.append(base_name)
            if ts.ptr_count > 0:
                parts.append("*" * ts.ptr_count)
                if ts.var_const:
                    parts.append("const")
                if ts.var_volatile:
                    parts.append("volatile")

        for dim in ts.array_dims:
            if dim:
                parts.append(f"[{dim}]")
            else:
                parts.append("[]")

        return " ".join(parts) if parts else "void"

    @staticmethod
    def CreateFromTypeName(TypeName: str) -> "CTypeInfo":
        """从类型名字符串创建 CTypeInfo（兼容旧 API）"""
        info = CTypeInfo()
        if TypeName.startswith('struct '):
            info.BaseType = t.CStruct(name=TypeName[7:].strip()) if TypeName[7:].strip() else t.CStruct()
        elif TypeName.startswith('enum '):
            info.BaseType = t.CEnum(name=TypeName[5:].strip()) if TypeName[5:].strip() else t.CEnum()
        elif TypeName.startswith('union '):
            info.BaseType = t.CUnion(name=TypeName[6:].strip()) if TypeName[6:].strip() else t.CUnion()
        else:
            info.BaseType = t.CStruct(name=TypeName)
        return info

    # LLVM primitive type name → (CTypeClass, PtrCount) mapping
    # Used when generic type inference produces LLVM type names like 'i64', 'double', etc.
    _LLVM_PRIMITIVE_MAP = None

    @classmethod
    def _get_llvm_primitive_map(cls):
        if cls._LLVM_PRIMITIVE_MAP is not None:
            return cls._LLVM_PRIMITIVE_MAP
        from lib.includes import t as _t
        cls._LLVM_PRIMITIVE_MAP = {
            'void': (_t.CVoid, 0),
            'i1': (_t.CInt, 0),
            'i8': (_t.CChar, 0),
            'i16': (_t.CShort, 0),
            'i32': (_t.CInt, 0),
            'i64': (_t.CLong, 0),
            'i128': (_t.CInt, 0),
            'float': (_t.CFloat, 0),
            'double': (_t.CDouble, 0),
            'fp128': (_t.CFloat128T, 0),
        }
        return cls._LLVM_PRIMITIVE_MAP

    @staticmethod
    def FromTypeName(TypeName: str) -> "CTypeInfo":
        """从简单类型名构造 CTypeInfo（不经过 FromStr 字符串解析）"""
        from lib.core.Handles.HandlesBase import BuiltinTypeMap

        # Handle pointer types like 'CUInt32T *', 'void *', etc.
        ptr_count = 0
        base_name = TypeName
        while base_name.endswith(' *') or base_name.endswith('*'):
            ptr_count += 1
            base_name = base_name.rstrip(' *').rstrip()

        entry = BuiltinTypeMap.Get(base_name)
        if entry:
            TypeClass, base_ptr = entry
            info = CTypeInfo()
            info.BaseType = TypeClass
            info.PtrCount = base_ptr + ptr_count
            return info
        # Handle LLVM primitive type names (e.g., 'i64', 'double' from generic type inference)
        llvm_map = CTypeInfo._get_llvm_primitive_map()
        llvm_entry = llvm_map.get(base_name)
        if llvm_entry:
            TypeClass, base_ptr = llvm_entry
            info = CTypeInfo()
            info.BaseType = TypeClass
            info.PtrCount = base_ptr + ptr_count
            return info
        # Fallback with pointer count
        info = CTypeInfo.CreateFromTypeName(TypeName)
        if ptr_count > 0:
            info.PtrCount = ptr_count
        return info

    # FromStr 已移除 - 类型解析不再经过中间字符串格式
    # typedef 展开直接走 CTypeInfo 对象，不经过字符串解析

    @staticmethod
    def TryEvalConstExpr(node, SymbolTable):
        from lib.core.ConstEvaluator import ConstEvaluator
        return ConstEvaluator.eval_with_symtab(node, SymbolTable)

    @classmethod
    def FromNode(cls, Node: ast.AST, SymbolTable: dict) -> "CTypeInfo":
        """从 AST 节点解析 CTypeInfo（类方法）

        Args:
            Node: AST 节点（如 ast.Name, ast.Attribute 等）
            SymbolTable: 符号表字典
        """
        if isinstance(Node, (ast.Constant, ast.Str)):
            return cls._FromNode_Constant(Node, SymbolTable)
        if isinstance(Node, ast.Name):
            return cls._FromNode_Name(Node, SymbolTable)
        if isinstance(Node, ast.Call):
            return cls._FromNode_Call(Node, SymbolTable)
        if isinstance(Node, ast.BinOp) and isinstance(Node.op, ast.BitOr):
            return cls._FromNode_BinOp(Node, SymbolTable)
        if isinstance(Node, ast.Subscript):
            return cls._FromNode_Subscript(Node, SymbolTable)
        if isinstance(Node, ast.Attribute):
            return cls._FromNode_Attribute(Node, SymbolTable)
        return cls()

    @classmethod
    def _FromNode_Constant(cls, Node: ast.AST, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.Constant / ast.Str 节点"""
        if isinstance(Node, ast.Constant):
            TypeName = Node.value
        else:
            TypeName = Node.s
        return cls.FromTypeName(TypeName)

    @classmethod
    def _FromNode_Name(cls, Node: ast.Name, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.Name 节点"""
        from lib.includes import t

        TypeName = Node.id
        TypeObj = CTypeHelper.GetTModuleCType(TypeName)
        if TypeObj is None:
            TypeObj = getattr(t, TypeName, None)
        if isinstance(TypeObj, type) and issubclass(TypeObj, t.CType) and TypeObj is not t.CType:
            if TypeObj == t.CPtr:
                Result = cls()
                Result.PtrCount = 1
                Result.BaseType = t.CVoid()
                return Result
            if TypeObj == t.State:
                Result = cls()
                Result.IsState = True
                Result.BaseType = t.CVoid()
                return Result
            Inst = TypeObj()
            Result = cls()
            Result.BaseType = TypeObj
            if hasattr(Inst, 'CName') and Inst.CName:
                Result.Name = Inst.CName
            if hasattr(Inst, 'IsSigned'):
                Result.IsSigned = Inst.IsSigned
            return Result
        if TypeName in SymbolTable:
            Entry = SymbolTable[TypeName]
            if Entry:
                if isinstance(Entry, CTypeInfo):
                    if Entry.IsTypedef:
                        if Entry.BaseType and (not isinstance(Entry.BaseType, (t._CTypedef,)) or Entry.PtrCount > 0):
                            Result = Entry.Copy()
                            Result.IsTypedef = True
                            Result.Name = TypeName
                            return Result
                        if Entry.OriginalType:
                            if isinstance(Entry.OriginalType, CTypeInfo) and Entry.OriginalType.IsFuncPtr:
                                Result = cls()
                                Result.IsFuncPtr = True
                                Result.FuncPtrReturn = Entry.OriginalType.FuncPtrReturn or CTypeInfo.VoidTypeInfo()
                                Result.FuncPtrParams = list(Entry.OriginalType.FuncPtrParams) if Entry.OriginalType.FuncPtrParams else []
                                Result.IsTypedef = True
                                Result.Name = TypeName
                                return Result
                            elif isinstance(Entry.OriginalType, CTypeInfo):
                                Resolved = Entry.OriginalType.Copy()
                            elif isinstance(Entry.OriginalType, str) and Entry.OriginalType == 'Callable':
                                Result = cls()
                                Result.IsFuncPtr = True
                                Result.FuncPtrReturn = CTypeInfo.VoidTypeInfo()
                                Result.FuncPtrParams = []
                                Result.IsTypedef = True
                                Result.Name = TypeName
                                return Result
                            elif isinstance(Entry.OriginalType, str):
                                Resolved = cls.FromTypeName(Entry.OriginalType)
                            else:
                                Resolved = Entry.OriginalType
                            Resolved.IsTypedef = True
                            Resolved.Name = TypeName
                            return Resolved
                        TypeEntry = BuiltinTypeMap.Get(TypeName)
                        if TypeEntry:
                            Result = cls()
                            Result.BaseType = TypeEntry[0]()
                            Result.PtrCount = TypeEntry[1]
                            Result.IsTypedef = True
                            Result.Name = TypeName
                            return Result
                        return Entry
                    if Entry.IsEnum:
                        Result = cls()
                        Result.BaseType = t.CInt()
                        Result.IsEnum = True
                        Result.Name = TypeName
                        return Result
                    if getattr(Entry, 'IsExceptionClass', None):
                        Result = cls()
                        Result.BaseType = t.CInt()
                        Result.IsExceptionClass = True
                        Result.Name = TypeName
                        return Result
                    if Entry.BaseType is None and (Entry.IsStruct or Entry.Name):
                        Entry.BaseType = t.CStruct(name=TypeName)
                        Entry.IsStruct = True
                    return Entry
                elif isinstance(Entry, dict):
                    if Entry.get('type') == 'typedef':
                        OriginalType = Entry.get('OriginalType', '')
                        if OriginalType:
                            if OriginalType == 'Callable':
                                Result = cls()
                                Result.IsFuncPtr = True
                                Result.FuncPtrReturn = CTypeInfo.VoidTypeInfo()
                                Result.FuncPtrParams = []
                                Result.IsTypedef = True
                                Result.Name = TypeName
                                return Result
                            Resolved = cls.FromTypeName(OriginalType)
                            Resolved.IsTypedef = True
                            Resolved.Name = TypeName
                            return Resolved
                        TypeEntry = BuiltinTypeMap.Get(TypeName)
                        if TypeEntry:
                            Result = cls()
                            Result.BaseType = TypeEntry[0]()
                            Result.PtrCount = TypeEntry[1]
                            Result.IsTypedef = True
                            Result.Name = TypeName
                            return Result
                        Result = cls()
                        Result.BaseType = t._CTypedef(TypeName)
                        Result.IsTypedef = True
                        Result.Name = TypeName
                        return Result
        # 特殊处理 str 类型，它应该是 char*（指针）
        if TypeName in ('str', 'bytes'):
            Result = cls()
            Result.BaseType = t.CChar()
            Result.PtrCount = 1
            return Result
        if TypeName == 'irq_handler_t':
            pass
        return cls.FromTypeName(TypeName)

    @classmethod
    def _FromNode_Call(cls, Node: ast.Call, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.Call 节点"""
        from lib.includes import t

        if isinstance(Node.func, ast.Name) and Node.func.id == 'callable':
            Result = cls()
            Result.IsFuncPtr = True
            Result.FuncPtrReturn = CTypeInfo.VoidTypeInfo()
            Result.FuncPtrParams = []
            try:
                if len(Node.args) > 0:
                    RetInfo = cls.FromNode(Node.args[0], SymbolTable)
                    if RetInfo:
                        Result.FuncPtrReturn = RetInfo
                for kw in Node.keywords:
                    ParamInfo = cls.FromNode(kw.value, SymbolTable)
                    if ParamInfo:
                        Result.FuncPtrParams.append((kw.arg or '', ParamInfo))
            except Exception as _e:
                if __import__('lib.constants.config', fromlist=['mode']).mode == "strict":
                    import warnings; warnings.warn(f"异常被忽略: {_e}")
            return Result
        if isinstance(Node.func, ast.Attribute):
            if isinstance(Node.func.value, ast.Name) and Node.func.value.id == 't':
                if Node.func.attr == 'Bit' and len(Node.args) > 0:
                    Result = cls()
                    Result.BaseType = t.CInt()
                    Result.IsBitField = True
                    if isinstance(Node.args[0], ast.Constant) and isinstance(Node.args[0].value, int):
                        Result.BitWidth = Node.args[0].value
                    else:
                        Result.BitWidth = 1
                    return Result
        return cls()

    @classmethod
    def _FromNode_BinOp(cls, Node: ast.BinOp, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.BinOp (BitOr) 节点"""
        from lib.includes import t

        LeftInfo = cls.FromNode(Node.left, SymbolTable)
        RightInfo = cls.FromNode(Node.right, SymbolTable)

        if LeftInfo.IsState or RightInfo.IsState:
            Result = cls()
            Result.IsState = True
            NonStateInfo = LeftInfo if not LeftInfo.IsState else RightInfo
            StateInfo = LeftInfo if LeftInfo.IsState else RightInfo
            if NonStateInfo.BaseType and (not isinstance(NonStateInfo.BaseType, (t._CTypedef,)) or NonStateInfo.PtrCount > 0):
                Result.BaseType = NonStateInfo.BaseType
            elif NonStateInfo.IsTypedef and NonStateInfo.Name:
                if NonStateInfo.BaseType and (not isinstance(NonStateInfo.BaseType, (t._CTypedef,)) or NonStateInfo.PtrCount > 0):
                    Result.BaseType = NonStateInfo.BaseType
                    Result.PtrCount = NonStateInfo.PtrCount
                    Result.IsTypedef = True
                    Result.Name = NonStateInfo.Name
                    if NonStateInfo.OriginalType:
                        Result.OriginalType = NonStateInfo.OriginalType
                else:
                    Result.BaseType = t.CStruct(name=NonStateInfo.Name)
                    Result.IsStruct = True
                Result.IsTypedef = True
                Result.Name = NonStateInfo.Name
                if NonStateInfo.OriginalType:
                    Result.OriginalType = NonStateInfo.OriginalType
            else:
                Result.BaseType = t.CVoid()
            Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
            if not Result.Storage:
                Result.Storage = t.CExport()
            if LeftInfo.Storage and not isinstance(LeftInfo.Storage, t.CExport):
                Result.Storage = LeftInfo.Storage
            elif RightInfo.Storage and not isinstance(RightInfo.Storage, t.CExport):
                Result.Storage = RightInfo.Storage
            if LeftInfo.DataConst or RightInfo.DataConst:
                Result.DataConst = True
            if LeftInfo.VarConst or RightInfo.VarConst:
                Result.VarConst = True
            return Result

        if LeftInfo.IsPtr or RightInfo.IsPtr:
            Result = cls()
            Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
            NonPtrInfo = LeftInfo if not LeftInfo.IsPtr else RightInfo
            PtrInfo = RightInfo if RightInfo.IsPtr else LeftInfo
            if NonPtrInfo.BaseType and (not isinstance(NonPtrInfo.BaseType, (t._CTypedef,)) or NonPtrInfo.PtrCount > 0):
                Result.BaseType = NonPtrInfo.BaseType
            elif NonPtrInfo.IsTypedef and NonPtrInfo.Name:
                if NonPtrInfo.BaseType and (not isinstance(NonPtrInfo.BaseType, (t._CTypedef,)) or NonPtrInfo.PtrCount > 0):
                    Result.BaseType = NonPtrInfo.BaseType
                    Result.IsTypedef = True
                    Result.Name = NonPtrInfo.Name
                    if NonPtrInfo.OriginalType:
                        Result.OriginalType = NonPtrInfo.OriginalType
                else:
                    Result.BaseType = t.CStruct(name=NonPtrInfo.Name)
                    Result.IsStruct = True
            elif PtrInfo.BaseType and (not isinstance(PtrInfo.BaseType, (t._CTypedef,)) or PtrInfo.PtrCount > 0):
                Result.BaseType = PtrInfo.BaseType
            else:
                Result.BaseType = t.CUnsignedChar()
            if LeftInfo.DataConst or RightInfo.DataConst:
                Result.DataConst = True
            if LeftInfo.VarConst or RightInfo.VarConst:
                Result.VarConst = True
            if LeftInfo.DataVolatile or RightInfo.DataVolatile:
                Result.DataVolatile = True
            if LeftInfo.VarVolatile or RightInfo.VarVolatile:
                Result.VarVolatile = True
            if LeftInfo.Storage:
                Result.Storage = LeftInfo.Storage
            elif RightInfo.Storage:
                Result.Storage = RightInfo.Storage
            return Result

        if LeftInfo.DataConst or RightInfo.DataConst:
            Result = cls()
            BaseTypeSide = LeftInfo if not LeftInfo.DataConst else RightInfo
            QualSide = LeftInfo if LeftInfo.DataConst else RightInfo
            Result.BaseType = BaseTypeSide.BaseType if BaseTypeSide.BaseType and (not isinstance(BaseTypeSide.BaseType, t.CVoid) or BaseTypeSide.PtrCount > 0) else QualSide.BaseType
            if not Result.BaseType:
                Result.BaseType = t.CInt()
            Result.DataConst = True
            Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
            if LeftInfo.VarConst or RightInfo.VarConst:
                Result.VarConst = True
            if LeftInfo.DataVolatile or RightInfo.DataVolatile:
                Result.DataVolatile = True
            if LeftInfo.Storage:
                Result.Storage = LeftInfo.Storage
            elif RightInfo.Storage:
                Result.Storage = RightInfo.Storage
            return Result

        if LeftInfo.DataVolatile or RightInfo.DataVolatile:
            Result = cls()
            BaseTypeSide = LeftInfo if not LeftInfo.DataVolatile else RightInfo
            QualSide = LeftInfo if LeftInfo.DataVolatile else RightInfo
            Result.BaseType = BaseTypeSide.BaseType if BaseTypeSide.BaseType and (not isinstance(BaseTypeSide.BaseType, t.CVoid) or BaseTypeSide.PtrCount > 0) else QualSide.BaseType
            if not Result.BaseType:
                Result.BaseType = t.CInt()
            Result.DataVolatile = True
            Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
            if LeftInfo.VarConst or RightInfo.VarConst:
                Result.VarConst = True
            if LeftInfo.Storage:
                Result.Storage = LeftInfo.Storage
            elif RightInfo.Storage:
                Result.Storage = RightInfo.Storage
            return Result

        if LeftInfo.Storage or RightInfo.Storage:
            Result = cls()
            BaseTypeSide = LeftInfo if not LeftInfo.Storage else RightInfo
            StorageSide = LeftInfo if LeftInfo.Storage else RightInfo
            if BaseTypeSide.IsState or StorageSide.IsState:
                Result.IsState = True
                Result.BaseType = t.CVoid()
                Result.Storage = LeftInfo.Storage if LeftInfo.Storage else RightInfo.Storage
                return Result
            Result.BaseType = BaseTypeSide.BaseType if BaseTypeSide.BaseType and (not isinstance(BaseTypeSide.BaseType, t.CVoid) or BaseTypeSide.PtrCount > 0) else StorageSide.BaseType
            if not Result.BaseType:
                Result.BaseType = t.CInt()
            Result.Storage = LeftInfo.Storage if LeftInfo.Storage else RightInfo.Storage
            Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
            if LeftInfo.DataConst or RightInfo.DataConst:
                Result.DataConst = True
            if LeftInfo.VarConst or RightInfo.VarConst:
                Result.VarConst = True
            return Result

        # 检查是否有位域类型 (t.Bit)
        if LeftInfo.IsBitField:
            Result = cls()
            Result.BaseType = LeftInfo.BaseType if LeftInfo.BaseType else t.CInt()
            Result.IsBitField = True
            Result.BitWidth = LeftInfo.BitWidth
            return Result
        if RightInfo.IsBitField:
            Result = cls()
            Result.BaseType = RightInfo.BaseType if RightInfo.BaseType else t.CInt()
            Result.IsBitField = True
            Result.BitWidth = RightInfo.BitWidth
            return Result

        # 处理字节序类型 (t.BigEndian, t.LittleEndian)
        if LeftInfo.ByteOrder:
            Result = cls()
            Result.BaseType = LeftInfo.BaseType if LeftInfo.BaseType else t.CInt()
            Result.ByteOrder = LeftInfo.ByteOrder
            return Result
        if RightInfo.ByteOrder:
            Result = cls()
            Result.BaseType = RightInfo.BaseType if RightInfo.BaseType else t.CInt()
            Result.ByteOrder = RightInfo.ByteOrder
            return Result

        if LeftInfo.IsFuncPtr or RightInfo.IsFuncPtr:
            Result = cls()
            FuncPtrSide = LeftInfo if LeftInfo.IsFuncPtr else RightInfo
            Result.IsFuncPtr = True
            Result.FuncPtrParams = list(FuncPtrSide.FuncPtrParams)
            Result.FuncPtrReturn = FuncPtrSide.FuncPtrReturn
            if LeftInfo.Storage:
                Result.Storage = LeftInfo.Storage
            elif RightInfo.Storage:
                Result.Storage = RightInfo.Storage
            return Result

        if LeftInfo.IsTypedef and RightInfo.BaseType:
            if LeftInfo.BaseType and (not isinstance(LeftInfo.BaseType, (t._CTypedef,)) or LeftInfo.PtrCount > 0):
                Result = LeftInfo.Copy()
                Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
                if RightInfo.Storage:
                    Result.Storage = RightInfo.Storage
                return Result
            return RightInfo
        if RightInfo.IsTypedef and LeftInfo.BaseType:
            if RightInfo.BaseType and (not isinstance(RightInfo.BaseType, (t._CTypedef,)) or RightInfo.PtrCount > 0):
                Result = RightInfo.Copy()
                Result.PtrCount = max(LeftInfo.PtrCount, RightInfo.PtrCount)
                if LeftInfo.Storage:
                    Result.Storage = LeftInfo.Storage
                return Result
            return LeftInfo

        if LeftInfo.BaseType:
            return LeftInfo
        elif RightInfo.BaseType:
            return RightInfo
        return cls()

    @classmethod
    def _FromNode_Subscript(cls, Node: ast.Subscript, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.Subscript 节点"""
        from lib.includes import t

        base = Node.value
        if isinstance(base, ast.Attribute):
            if isinstance(base.value, ast.Name) and base.value.id == 't' and base.attr == 'Bit':
                Result = cls()
                Result.BaseType = t.CInt()
                Result.IsBitField = True
                if isinstance(Node.slice, ast.Constant) and isinstance(Node.slice.value, int):
                    Result.BitWidth = Node.slice.value
                else:
                    Result.BitWidth = 1
                return Result
        if isinstance(base, ast.Name) and base.id == 'list':
            slice_node = Node.slice
            elts = []
            if isinstance(slice_node, ast.Tuple):
                elts = slice_node.elts
            elif isinstance(slice_node, (ast.Attribute, ast.Name, ast.Subscript)):
                elts = [slice_node]
            if elts:
                ElemInfo = cls.FromNode(elts[0], SymbolTable)
                if ElemInfo and ElemInfo.BaseType:
                    Result = cls()
                    Result.BaseType = ElemInfo.BaseType
                    Result.PtrCount = ElemInfo.PtrCount
                    Result.ArrayDims = list(ElemInfo.ArrayDims)
                    if len(elts) >= 2:
                        count_val = cls.TryEvalConstExpr(elts[1], SymbolTable)
                        if count_val is not None and isinstance(count_val, int) and count_val > 0:
                            Result.ArrayDims.insert(0, str(count_val))
                        else:
                            Result.PtrCount += 1
                    if ElemInfo.IsPtr and not ElemInfo.ArrayDims:
                        Result.PtrCount = max(Result.PtrCount, 1)
                    return Result
        if isinstance(base, ast.Attribute):
            parts = []
            current = base
            while isinstance(current, ast.Attribute):
                parts.insert(0, current.attr)
                current = current.value
            if isinstance(current, ast.Name):
                parts.insert(0, current.id)
            if parts and parts[0] == 't' and parts[-1] == t.CPtr.__name__:
                Result = cls()
                Result.BaseType = t.CVoid()
                Result.PtrCount = 1
                slice_node = Node.slice
                if isinstance(slice_node, ast.Subscript):
                    InnerInfo = cls.FromNode(slice_node, SymbolTable)
                    if InnerInfo:
                        if InnerInfo.PtrCount > 0:
                            Result.PtrCount += InnerInfo.PtrCount
                        if InnerInfo.BaseType and not isinstance(InnerInfo.BaseType, t.CVoid):
                            Result.BaseType = InnerInfo.BaseType
                elif isinstance(slice_node, ast.Attribute):
                    SliceInfo = cls.FromNode(slice_node, SymbolTable)
                    if SliceInfo:
                        if SliceInfo.IsPtr:
                            Result.PtrCount += SliceInfo.PtrCount
                        elif SliceInfo.BaseType and not isinstance(SliceInfo.BaseType, t.CVoid):
                            Result.BaseType = SliceInfo.BaseType
                elif isinstance(slice_node, ast.Name):
                    SliceType = getattr(t, slice_node.id, None)
                    if SliceType == t.CPtr:
                        Result.PtrCount += 1
                    else:
                        SliceInfo = cls.FromNode(slice_node, SymbolTable)
                        if SliceInfo and SliceInfo.BaseType and not isinstance(SliceInfo.BaseType, t.CVoid):
                            Result.BaseType = SliceInfo.BaseType
                return Result
            if parts and parts[0] == 't' and parts[-1] == 'Callable':
                Result = cls()
                Result.IsFuncPtr = True
                slice_node = Node.slice
                if isinstance(slice_node, ast.Tuple) and len(slice_node.elts) == 2:
                    params_list = slice_node.elts[0]
                    return_node = slice_node.elts[1]
                    ParamTypes = []
                    if isinstance(params_list, ast.List):
                        for elt in params_list.elts:
                            ParamTypeInfo = cls.FromNode(elt, SymbolTable)
                            if ParamTypeInfo:
                                ParamTypes.append(('', ParamTypeInfo))
                    if not ParamTypes:
                        ParamTypes.append(('', cls.FromTypeName('void')))
                    Result.FuncPtrParams = ParamTypes
                    ReturnTypeInfo = cls.FromNode(return_node, SymbolTable)
                    Result.FuncPtrReturn = ReturnTypeInfo if ReturnTypeInfo else CTypeInfo.VoidTypeInfo()
                return Result
        return cls()

    @classmethod
    def _FromNode_Attribute(cls, Node: ast.Attribute, SymbolTable: dict) -> "CTypeInfo":
        """处理 ast.Attribute 节点"""
        from lib.includes import t

        ModuleParts = []
        Current = Node
        while isinstance(Current, ast.Attribute):
            ModuleParts.insert(0, Current.attr)
            Current = Current.value

        if isinstance(Current, ast.Name):
            ModuleParts.insert(0, Current.id)

        if len(ModuleParts) >= 2:
            TypeName = ModuleParts[-1]
            ModulePath = '.'.join(ModuleParts[:-1])
        elif len(ModuleParts) == 1:
            TypeName = ModuleParts[0]
            ModulePath = None
        else:
            return cls()

        # 解析 import 别名: 如 import vpsdk.window as window -> window -> vpsdk.window
        if ModulePath:
            resolved = False
            if hasattr(SymbolTable, 'translator'):
                import_aliases = getattr(SymbolTable.translator, '_ImportAliases', {})
                if ModulePath in import_aliases:
                    ModulePath = import_aliases[ModulePath]
                    resolved = True
            if not resolved and ModulePath in SymbolTable:
                entry = SymbolTable[ModulePath]
                if isinstance(entry, CTypeInfo) and getattr(entry, 'IsModuleAlias', False):
                    resolved_name = getattr(entry, 'ResolvedModule', None)
                    if resolved_name:
                        ModulePath = resolved_name

        if ModulePath == 't' or (ModulePath and ModulePath.startswith('t.')):
            TypeClass = CTypeHelper.GetTModuleCType(TypeName)
            if TypeClass is None:
                TypeClass = getattr(t, TypeName, None)
            if TypeClass is not None and TypeClass.HasPosition(t.CType.POINTER):
                Info = cls()
                Info.PtrCount = 1
                if TypeClass == t.CArrayPtr:
                    Info.IsArrayPtr = True
                Info.BaseType = t.CVoid
                return Info
            if TypeClass is not None and TypeClass.IsStorageClass():
                Info = cls()
                Info.Storage = TypeClass()
                if TypeClass == t.State:
                    Info.IsState = True
                    Info.BaseType = t.CVoid()
                return Info
            if TypeClass is not None and TypeClass.IsTypeQualifier():
                Info = cls()
                if TypeClass == t.CConst:
                    Info.DataConst = True
                elif TypeClass == t.CVolatile:
                    Info.DataVolatile = True
                return Info
            if (TypeClass is not None
                and isinstance(TypeClass, type)
                and issubclass(TypeClass, t.CType)
                and TypeClass is not t.CType
                and TypeClass.HasPosition(t.CType.BASE)):
                if TypeClass == t.State:
                    Result = cls()
                    Result.IsState = True
                    Result.BaseType = t.CVoid()
                    return Result
                Inst = TypeClass()
                Result = cls()
                Result.BaseType = TypeClass
                if hasattr(Inst, 'CName') and Inst.CName:
                    Result.Name = Inst.CName
                if hasattr(Inst, 'IsSigned'):
                    Result.IsSigned = Inst.IsSigned
                return Result
            CNAME = CTypeHelper.GetCName(TypeName)
            if CNAME:
                return cls.FromTypeName(CNAME)

            # 处理字节序类型
            if TypeName == 'BigEndian':
                Result = cls()
                Result.BaseType = t.CInt()
                Result.ByteOrder = 'big'
                return Result
            if TypeName == 'LittleEndian':
                Result = cls()
                Result.BaseType = t.CInt()
                Result.ByteOrder = 'little'
                return Result

        FullName = f"{ModulePath}.{TypeName}" if ModulePath else TypeName

        if TypeName in SymbolTable:
            Entry = SymbolTable[TypeName]
            if Entry and getattr(Entry, 'IsTypedef', None):
                Resolved = Entry.Copy()
                if Resolved.BaseType is None:
                    Resolved.BaseType = t._CTypedef(TypeName)
                return Resolved
            if Entry and getattr(Entry, 'IsEnum', None):
                Result = cls()
                Result.BaseType = t.CInt()
                Result.IsEnum = True
                Result.Name = TypeName
                return Result
            if Entry and getattr(Entry, 'IsExceptionClass', None):
                Result = cls()
                Result.BaseType = t.CInt()
                Result.IsExceptionClass = True
                Result.Name = TypeName
                return Result
            if Entry:
                Result = Entry.Copy()
                if Result.BaseType is None and (Result.IsStruct or Result.IsCpythonObject or Result.Name):
                    Result.BaseType = t.CStruct(name=TypeName)
                    Result.IsStruct = True
                return Result
            return cls()

        if FullName in SymbolTable:
            Info = SymbolTable[FullName]
            if Info and Info.IsTypedef:
                OriginalType = Info.get('OriginalType', '')
                if OriginalType and 'typedef' in OriginalType:
                    parts = OriginalType.split()
                    if len(parts) >= 2:
                        BaseType_name = parts[1]
                        if not BaseType_name.startswith('C'):
                            BaseType_name = 'C' + BaseType_name
                        CNAME = CTypeHelper.GetCName(BaseType_name)
                        if CNAME:
                            return cls.FromTypeName(CNAME)
                Result = cls()
                Result.BaseType = t._CTypedef(TypeName)
                Result.IsTypedef = True
                return Result
            if Info:
                Result = Info.Copy()
                if Result.BaseType is None and (Result.IsStruct or Result.IsCpythonObject or Result.Name):
                    Result.BaseType = t.CStruct(name=TypeName)
                    Result.IsStruct = True
                return Result
            return cls()

        return cls()

    @classmethod
    def _HandleArraySubscript(cls, Node, SymbolTable):
        if not isinstance(Node, ast.Subscript):
            return None
        dims = []
        current = Node
        while isinstance(current, ast.Subscript):
            if isinstance(current.slice, ast.Constant) and isinstance(current.slice.value, int):
                dims.insert(0, str(current.slice.value))
            elif isinstance(current.slice, ast.Name):
                dims.insert(0, current.slice.id)
            else:
                return None
            current = current.value
        base_info = cls.FromNode(current, SymbolTable)
        if base_info and base_info.BaseType:
            base_info.ArrayDims = dims
            return base_info
        return None

    def Copy(self) -> "CTypeInfo":
        NewInfo = CTypeInfo()
        NewInfo._ts = self._ts.copy()
        NewInfo._sm = self._sm.copy()
        # CTypeInfo 引用字段需要深拷贝
        if isinstance(NewInfo._ts.func_ptr_return, CTypeInfo):
            NewInfo._ts.func_ptr_return = NewInfo._ts.func_ptr_return.Copy()
        if isinstance(NewInfo._ts.original_type, CTypeInfo):
            NewInfo._ts.original_type = NewInfo._ts.original_type.Copy()
        if NewInfo._ts.array_ptr:
            NewInfo._ts.array_ptr = NewInfo._ts.array_ptr.Copy()
        return NewInfo

    def get(self, key, default=None):
        """获取额外属性"""
        return self._sm._extra.get(key, default)

    def set(self, key, value):
        """设置额外属性"""
        self._sm._extra[key] = value

    @staticmethod
    def VoidTypeInfo() -> "CTypeInfo":
        info = CTypeInfo()
        info.BaseType = t.CVoid()
        return info

    def ToLLVM(self, Gen):
        from llvmlite import ir as _ir
        if Gen is None:
            return _ir.IntType(32)
        return Gen._ctype_to_llvm(self)

    def ToLLVMBase(self, Gen):
        from llvmlite import ir as _ir
        if Gen is None:
            return _ir.IntType(32)
        return Gen._base_ctype_to_llvm(self.BaseType, self)

    def __str__(self) -> str:
        return self.ToString()

    def __repr__(self) -> str:
        ts = self._ts
        kf = self._sm._kind_flags
        return f"CTypeInfo(BaseType={ts._base_type}, PtrCount={ts.ptr_count}, IsTypedef={kf.get('IsTypedef', False)}, OriginalType={ts.original_type!r}, VarConst={ts.var_const}, DataConst={ts.data_const})"


class CTypeHelper:

    @staticmethod
    def GetTModuleCType(TypeName: str):
        from lib.includes.t import CTypeRegistry
        result = CTypeRegistry.GetClassByName(TypeName)
        if result is not None:
            return result
        TypeClass = getattr(t, TypeName, None)
        if TypeClass and isinstance(TypeClass, type) and issubclass(TypeClass, t.CType):
            return TypeClass
        FallbackClass = getattr(t, f'_{TypeName}', None)
        if FallbackClass and isinstance(FallbackClass, type) and issubclass(FallbackClass, t.CType):
            return FallbackClass
        return None

    @staticmethod
    def GetCName(type_or_name) -> str:
        from lib.includes.t import CTypeRegistry
        if isinstance(type_or_name, str):
            cls = CTypeRegistry.GetClassByName(type_or_name)
            if cls is None:
                cls = CTypeHelper.GetTModuleCType(type_or_name)
            if cls:
                return CTypeRegistry.CTypeToCName(cls) or type_or_name
            return type_or_name
        elif isinstance(type_or_name, type) and issubclass(type_or_name, t.CType):
            return CTypeRegistry.CTypeToCName(type_or_name) or ''
        return ''

    @staticmethod
    def StripTypePrefix(TypeStr: str) -> str:
        for prefix in ('struct ', 'enum ', 'union '):
            if TypeStr.startswith(prefix):
                return TypeStr[len(prefix):].strip()
        return TypeStr

    @staticmethod
    def IsVoidType(TypeStr: str) -> bool:
        from lib.includes.t import CTypeRegistry
        cls = CTypeRegistry.GetClassByName(TypeStr) or CTypeRegistry.CNameToClass(TypeStr)
        if cls:
            return CTypeRegistry.CTypeToLLVM(cls) == 'void'
        return TypeStr == 'void' or TypeStr == 'struct void' or TypeStr == 'union void'

    @staticmethod
    def IsStrType(TypeStr: str) -> bool:
        from lib.includes.t import CTypeRegistry
        resolved = CTypeRegistry.ResolveName(TypeStr)
        if resolved:
            ctype_cls, ptr_level = resolved
            if CTypeRegistry.CTypeToLLVM(ctype_cls) == 'i8' and ptr_level > 0:
                return True
        return TypeStr in ('str', 'bytes', 'struct str', 'union str', 'c_char')


class BuiltinTypeMap:
    """
    内置类型映射表 - 字符串到 (CType类, PtrCount) 的映射

    用法：BuiltinTypeMap.Get('int') -> (t.CInt, 0)
         BuiltinTypeMap.Get('BYTEPTR') -> (t.CUnsignedChar, 1)
    """

    _map = None

    @classmethod
    def _build_map(cls):
        if cls._map is not None:
            return cls._map
        from lib.includes.t import CTypeRegistry
        CTypeRegistry._build()
        cls._map = {}
        for cname, ctype_cls in CTypeRegistry._cname_to_class.items():
            cls._map[cname] = (ctype_cls, 0)
        for pyname, ctype_cls in CTypeRegistry._name_to_class.items():
            pos = getattr(ctype_cls, 'position', frozenset())
            if t.CType.POINTER in pos and t.CType.BASE not in pos:
                cls._map[pyname] = (ctype_cls, 1)
            elif pyname not in cls._map:
                cls._map[pyname] = (ctype_cls, 0)
        _SPECIAL = {
            'str': (t.CChar, 1), 'bytes': (t.CChar, 1), 'unsigned': (t.CUnsigned, 0),
            'signed': (t.CInt, 0), 'signed int': (t.CInt, 0),
            'signed char': (t.CSignedChar, 0), 'bool': (t.CBool, 0),
            'void': (t.CVoid, 0), 'Void': (t.CVoid, 0),
        }
        for k, v in _SPECIAL.items():
            if k not in cls._map:
                cls._map[k] = v
        _PTR_ALIASES = {
            'INTPTR': (t.CInt, 1), 'UINTPTR': (t.CUnsignedInt, 1),
            'VOIDPTR': (t.CVoid, 1), 'BYTEPTR': (t.CUnsignedChar, 1),
            'CHAR8PTR': (t.CChar8T, 1), 'CHAR16PTR': (t.CChar16T, 1),
            'CHAR32PTR': (t.CChar32T, 1),
        }
        for k, v in _PTR_ALIASES.items():
            if k not in cls._map:
                cls._map[k] = v
        _FLOAT_ALIASES = {
            'FLOAT8': (t.CFloat8T, 0), 'FLOAT16': (t.CFloat16T, 0),
            'FLOAT32': (t.CFloat32T, 0), 'FLOAT64': (t.CFloat64T, 0),
            'FLOAT128': (t.CFloat128T, 0),
        }
        for k, v in _FLOAT_ALIASES.items():
            if k not in cls._map:
                cls._map[k] = v
        return cls._map

    @classmethod
    def Get(cls, type_name: str):
        """获取类型类和指针层级"""
        return cls._build_map().get(type_name)


class BaseHandle:
    def __init__(self, translator: "Translator") -> None:
        self.Trans: Translator = translator
        self._CurrentCpythonObjectClass: str = None

    @staticmethod
    def _attr(obj, name, default=None):
        if obj is None:
            return default
        return getattr(obj, name, default)

    @staticmethod
    def _is_char_pointer(val):
        """检查值是否为 char* (i8*) 指针"""
        from llvmlite import ir
        if not isinstance(val.type, ir.PointerType):
            return False
        pointee = val.type.pointee
        return isinstance(pointee, ir.IntType) and pointee.width == 8

    def HandleExprLlvm(self, Node, VarType=None):
        return self.Trans.ExprHandler.HandleExprLlvm(Node, VarType)

    def HandleBodyLlvm(self, Body):
        return self.Trans.BodyHandler.HandleBodyLlvm(Body)

    def _get_int_ptr(self, Node):
        import ast
        from llvmlite import ir
        Gen = self.Trans.LlvmGen
        if isinstance(Node, ast.Name):
            if Node.id in Gen.variables:
                return Gen.variables[Node.id]
        elif isinstance(Node, ast.Attribute):
            obj_val = self.HandleExprLlvm(Node.value)
            if not obj_val:
                return None
            if isinstance(obj_val.type, ir.PointerType):
                pointee = obj_val.type.pointee
                if isinstance(pointee, (ir.IdentifiedStructType, ir.LiteralStructType)):
                    StructName = None
                    if isinstance(pointee, ir.IdentifiedStructType):
                        StructName = pointee.name
                    if not StructName:
                        for ClassName, struct_type in Gen.structs.items():
                            if struct_type == pointee:
                                StructName = ClassName
                                break
                    if StructName and StructName in Gen.structs:
                        offset = self.Trans.ExprHandler._get_llvm_member_offset(Node.attr, StructName, Gen)
                        member_ptr = Gen.builder.gep(obj_val, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=f"{Node.attr}_ptr")
                        return member_ptr
        return None

    def _IsTModuleType(self, TypeName: str) -> bool:
        if TypeName in ('t', 'State', 'Bit', 'Anonymous', 'Postdefinition'):
            return True
        TypeClass = getattr(t, TypeName, None)
        if TypeClass and isinstance(TypeClass, type):
            if issubclass(TypeClass, t.CType):
                return True
        FallbackClass = getattr(t, f'_{TypeName}', None)
        if FallbackClass and isinstance(FallbackClass, type):
            if issubclass(FallbackClass, t.CType):
                return True
        return False


StrictMode = _config.mode == 'strict'