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.TypeAnnotationResolver import TypeAnnotationResolver
        return TypeAnnotationResolver.from_type_name(TypeName)

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

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

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

        Args:
            Node: AST 节点（如 ast.Name, ast.Attribute 等）
            SymbolTable: 符号表字典
        """
        from lib.core.TypeAnnotationResolver import TypeAnnotationResolver
        return TypeAnnotationResolver.from_node(Node, SymbolTable)


    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'