import t, c
from stdint import *
import stdio
import string
import stdlib
import memhub
import viperlib
import w32.fileio as fileio
import w32.win32file
import w32.win32base
import ast
import llvmlite
import lib.core.VLogger as VLogger
import lib.core.Handles.HandlesTranslator as HandlesTranslator
import lib.core.Handles.HandlesStruct as HandlesStruct
import lib.core.Handles.HandlesType as HandlesType
import lib.core.Handles.HandlesExprCall as HandlesExprCall
import lib.core.Handles.HandlesImports as HandlesImports
import lib.core.Handles.HandlesClassDef as HandlesClassDef
import lib.core.IncludesScanner as IncludesScanner
import lib.core.StubMerger as StubMerger
import lib.core.BuildPipeline as BuildPipeline
import lib.Projectrans.Config as Config
import lib.StubGen.Converter as StubConverter

# 全局 mbuddy 指针
_mbuddy: memhub.MemManager | t.CPtr

# 源代码缓冲区大小（1MB）
SRC_BUF_SIZE: t.CDefine = 1048576

# pyi 缓冲区大小（256KB）
PYI_BUF_SIZE: t.CSizeT = 262144

# 拓扑排序相关常量
MAX_CLASSES: t.CDefine = 512
MAX_FILE_DEPS: t.CDefine = 256
MAX_DEP_EDGES: t.CDefine = 16
SHA1_LEN: t.CDefine = 17
CLASS_NAME_LEN: t.CDefine = 64

# 拓扑排序使用扁平字节数组存储类信息和文件依赖，
# 避免结构体中的 str 指针字段在 mb.alloc 零填充时为 NULL 导致崩溃。
# 类名/父类名存储在 class_names_buf/parent_names_buf（每个 CLASS_NAME_LEN 字节），
# 定义 SHA1 存储在 def_sha1s_buf（每个 SHA1_LEN 字节）。


# ============================================================
# _ScanClassInheritance - 预扫描 includes 文件，收集类继承关系
#
# 遍历所有可达 includes 文件，解析 AST 收集 ClassDef 的类名和父类名。
# 结果存入扁平字节数组，返回收集到的类数量。
#
# Args:
#   mb: 内存池
#   result: IncludesScanner 扫描结果
#   reachable_set: 可达 SHA1 集合
#   reachable_count: 可达 SHA1 数量
#   use_reachable: 是否使用可达集合过滤
#   sha1_set: SHA1 集合（use_reachable=0 时使用）
#   set_count: SHA1 集合数量
#   class_names_buf: 类名扁平数组（每个 CLASS_NAME_LEN 字节，连续内存）
#   parent_names_buf: 父类名扁平数组（每个 CLASS_NAME_LEN 字节，无父类填 '\0'）
#   def_sha1s_buf: 定义 SHA1 扁平数组（每个 SHA1_LEN 字节）
#
# Returns:
#   收集到的类数量，-1 失败
# ============================================================
def _ScanClassInheritance(mb: memhub.MemBuddy | t.CPtr,
                          result: IncludesScanner.ScanResult | t.CPtr,
                          reachable_set: str, reachable_count: int,
                          use_reachable: int,
                          sha1_set: str, set_count: int,
                          class_names_buf: bytes,
                          parent_names_buf: bytes,
                          def_sha1s_buf: bytes) -> int:
    """预扫描 includes 文件，收集类继承关系"""
    if result is None or class_names_buf is None or parent_names_buf is None or def_sha1s_buf is None:
        return -1

    entry_size: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
    class_count: int = 0

    for i in range(result.Count):
        entry_addr: t.CUInt64T = t.CUInt64T(result.Entries) + i * entry_size
        entry: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(entry_addr, t.CPtr))
        if entry is None or entry.Sha1 is None:
            continue

        sha1_e: str = entry.Sha1

        # 按需翻译过滤
        in_set: int = 0
        if use_reachable != 0:
            in_set = StubMerger._is_in_sha1_set(sha1_e, reachable_set, reachable_count)
        else:
            in_set = StubMerger._is_in_sha1_set(sha1_e, sha1_set, set_count)
        if in_set == 0:
            continue

        # 读取文件
        file_path: str = entry.Path
        f: fileio.File | t.CPtr = fileio.File(file_path, fileio.MODE.R)
        if f.closed:
            continue

        src_buf: bytes = stdlib.malloc(SRC_BUF_SIZE)
        if src_buf is None:
            f.close()
            continue

        bytes_read: LONG = f.read_all(src_buf, SRC_BUF_SIZE)
        f.close()
        if bytes_read <= 0:
            stdlib.free(src_buf)
            continue
        if bytes_read < SRC_BUF_SIZE:
            src_buf[bytes_read] = 0
        else:
            src_buf[SRC_BUF_SIZE - 1] = 0

        # 解析 AST
        lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
        if lx is None:
            stdlib.free(src_buf)
            continue
        ast._lexer_init(lx, src_buf, mb)
        tokens: ast.Token | t.CPtr = ast.tokenize(lx)
        tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
        if tree is None:
            stdlib.free(src_buf)
            continue

        # 遍历 AST 顶层节点，收集 ClassDef
        ch: list[ast.AST | t.CPtr] | t.CPtr = tree.children
        if ch is not None:
            cn: t.CSizeT = ch.__len__()
            for ci in range(cn):
                child: ast.AST | t.CPtr = ch.get(ci)
                if child is None:
                    continue
                kd: int = child.kind()
                if kd != ast.ASTKind.ClassDef:
                    continue

                cd: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child)
                if cd is None or cd.name is None:
                    continue

                if class_count >= MAX_CLASSES:
                    break

                # 填充扁平数组：类名（偏移 = class_count * CLASS_NAME_LEN）
                name_dst: str = class_names_buf + class_count * CLASS_NAME_LEN
                nm_len: t.CSizeT = string.strlen(cd.name)
                if nm_len >= CLASS_NAME_LEN:
                    string.strncpy(name_dst, cd.name, CLASS_NAME_LEN - 1)
                    name_dst[CLASS_NAME_LEN - 1] = '\0'
                else:
                    string.strcpy(name_dst, cd.name)

                # 填充扁平数组：父类名（无父类填 '\0'）
                parent_dst: str = parent_names_buf + class_count * CLASS_NAME_LEN
                parent_dst[0] = '\0'
                parent_nm: str = HandlesClassDef._get_parent_class(cd, None)
                # parent_nm 是 AST 节点内部指针，不需要释放
                if parent_nm is not None:
                    pnm_len: t.CSizeT = string.strlen(parent_nm)
                    if pnm_len >= CLASS_NAME_LEN:
                        string.strncpy(parent_dst, parent_nm, CLASS_NAME_LEN - 1)
                        parent_dst[CLASS_NAME_LEN - 1] = '\0'
                    else:
                        string.strcpy(parent_dst, parent_nm)

                # 填充扁平数组：定义 SHA1（偏移 = class_count * SHA1_LEN）
                sha1_dst: str = def_sha1s_buf + class_count * SHA1_LEN
                string.strcpy(sha1_dst, sha1_e)

                class_count += 1

        stdlib.free(src_buf)

    return class_count


# ============================================================
# _FindClassDefSha1 - 在扁平数组中查找类名对应的定义文件 SHA1
#
# Args:
#   class_names_buf: 类名扁平数组
#   def_sha1s_buf: 定义 SHA1 扁平数组
#   class_count: 类数量
#   class_name: 要查找的类名
#
# Returns:
#   SHA1 字符串指针（指向 def_sha1s_buf 内部偏移），None 未找到
# ============================================================
def _FindClassDefSha1(class_names_buf: bytes, def_sha1s_buf: bytes,
                      class_count: int, class_name: str) -> str:
    """查找类名对应的定义文件 SHA1"""
    if class_names_buf is None or def_sha1s_buf is None or class_name is None:
        return None
    for i in range(class_count):
        name_ptr: str = class_names_buf + i * CLASS_NAME_LEN
        if string.strcmp(name_ptr, class_name) == 0:
            return def_sha1s_buf + i * SHA1_LEN
    return None


# ============================================================
# _TopoSortFiles - 根据类继承关系对文件进行拓扑排序
#
# 算法（Kahn）：
#   1. 从扁平类信息数组构建"文件 SHA1 → 依赖文件 SHA1 集合"映射
#   2. 计算每个文件的入度（依赖数量）
#   3. 入度为 0 的文件先处理，处理后减少依赖它的文件入度
#   4. 重复直到所有文件处理完成
#
# 注意：依赖方向是"父类所在文件 → 子类所在文件"，
#       即父类文件必须先处理。Kahn 用 DepCount 作为剩余依赖计数，
#       依赖为 0 的先处理，初始化 InDegree = DepCount。
#
# Args:
#   mb: 内存池
#   result: IncludesScanner 扫描结果
#   reachable_set: 可达 SHA1 集合
#   reachable_count: 可达 SHA1 数量
#   use_reachable: 是否使用可达集合过滤
#   sha1_set: SHA1 集合
#   set_count: SHA1 集合数量
#   class_names_buf: 类名扁平数组
#   parent_names_buf: 父类名扁平数组
#   def_sha1s_buf: 定义 SHA1 扁平数组
#   class_count: 类数量
#   out_order: 输出拓扑顺序的文件索引数组（调用者分配，int 数组）
#   out_count: 输出文件数量
#
# Returns:
#   0 成功，-1 失败
# ============================================================
def _TopoSortFiles(mb: memhub.MemBuddy | t.CPtr,
                   result: IncludesScanner.ScanResult | t.CPtr,
                   reachable_set: str, reachable_count: int,
                   use_reachable: int,
                   sha1_set: str, set_count: int,
                   class_names_buf: bytes, parent_names_buf: bytes,
                   def_sha1s_buf: bytes, class_count: int,
                   out_order: t.CPtr, out_count: t.CPtr) -> int:
    """根据类继承关系对文件进行拓扑排序"""
    if result is None or out_order is None or out_count is None:
        return -1

    entry_size: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()

    # 1. 分配扁平数组：文件 SHA1、依赖 SHA1 列表、依赖数量、入度、处理状态
    #    用扁平数组代替 FileDepEntry 结构体，避免 str 指针字段 NULL 崩溃
    file_sha1s_buf: bytes = mb.alloc(MAX_FILE_DEPS * SHA1_LEN)
    file_deps_buf: bytes = mb.alloc(MAX_FILE_DEPS * MAX_DEP_EDGES * SHA1_LEN)
    file_dep_counts: t.CPtr = mb.alloc(MAX_FILE_DEPS * 4)
    file_indegrees: t.CPtr = mb.alloc(MAX_FILE_DEPS * 4)
    file_processed: t.CPtr = mb.alloc(MAX_FILE_DEPS * 4)

    if file_sha1s_buf is None or file_deps_buf is None or file_dep_counts is None or file_indegrees is None or file_processed is None:
        if file_sha1s_buf is not None:
            mb.free(file_sha1s_buf)
        if file_deps_buf is not None:
            mb.free(file_deps_buf)
        if file_dep_counts is not None:
            mb.free(file_dep_counts)
        if file_indegrees is not None:
            mb.free(file_indegrees)
        if file_processed is not None:
            mb.free(file_processed)
        return -1

    string.memset(file_sha1s_buf, 0, MAX_FILE_DEPS * SHA1_LEN)
    string.memset(file_deps_buf, 0, MAX_FILE_DEPS * MAX_DEP_EDGES * SHA1_LEN)
    string.memset(file_dep_counts, 0, MAX_FILE_DEPS * 4)
    string.memset(file_indegrees, 0, MAX_FILE_DEPS * 4)
    string.memset(file_processed, 0, MAX_FILE_DEPS * 4)

    file_count: int = 0
    # sha1→file_index 映射（简单线性查找，文件数不多）
    for i in range(result.Count):
        entry_addr: t.CUInt64T = t.CUInt64T(result.Entries) + i * entry_size
        entry: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(entry_addr, t.CPtr))
        if entry is None or entry.Sha1 is None:
            continue

        sha1_e: str = entry.Sha1
        in_set: int = 0
        if use_reachable != 0:
            in_set = StubMerger._is_in_sha1_set(sha1_e, reachable_set, reachable_count)
        else:
            in_set = StubMerger._is_in_sha1_set(sha1_e, sha1_set, set_count)
        if in_set == 0:
            continue

        if file_count >= MAX_FILE_DEPS:
            break

        # 初始化扁平数组：文件 SHA1（偏移 = file_count * SHA1_LEN）
        # DepCount/InDegree/Processed 已由 memset 清零
        sha1_dst: str = file_sha1s_buf + file_count * SHA1_LEN
        string.strcpy(sha1_dst, sha1_e)

        file_count += 1

    # 2. 构建依赖边：对每个类，找到父类定义所在文件，建立 子文件→父文件 依赖
    for ci in range(class_count):
        # 读取父类名（偏移 = ci * CLASS_NAME_LEN）
        parent_ptr: str = parent_names_buf + ci * CLASS_NAME_LEN
        if parent_ptr[0] == '\0':
            continue

        # 读取子类定义 SHA1（偏移 = ci * SHA1_LEN）
        child_def_sha1: str = def_sha1s_buf + ci * SHA1_LEN

        # 查找父类定义所在文件的 SHA1
        parent_sha1: str = _FindClassDefSha1(class_names_buf, def_sha1s_buf, class_count, parent_ptr)
        if parent_sha1 is None:
            continue  # 父类不在 includes 中（如 Object、CEnum 等标记基类）

        # 父类文件 SHA1 不能等于子类文件 SHA1（同文件内继承不需要依赖）
        if string.strcmp(parent_sha1, child_def_sha1) == 0:
            continue

        # 找到子类文件对应的索引，添加父文件 SHA1 到依赖列表
        for fi in range(file_count):
            fsha1: str = file_sha1s_buf + fi * SHA1_LEN
            if string.strcmp(fsha1, child_def_sha1) != 0:
                continue

            # 读取当前依赖数量
            cnt_addr: t.CUInt64T = t.CUInt64T(file_dep_counts) + fi * 4
            cnt_ptr: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(cnt_addr, t.CPtr))
            if cnt_ptr is None:
                break
            cur_cnt: int = cnt_ptr[0]

            # 检查依赖是否已添加（去重）
            already: int = 0
            for di in range(cur_cnt):
                dep_slot: str = file_deps_buf + fi * MAX_DEP_EDGES * SHA1_LEN + di * SHA1_LEN
                if string.strcmp(dep_slot, parent_sha1) == 0:
                    already = 1
                    break
            if already != 0:
                break

            if cur_cnt < MAX_DEP_EDGES:
                dep_dst: str = file_deps_buf + fi * MAX_DEP_EDGES * SHA1_LEN + cur_cnt * SHA1_LEN
                string.strcpy(dep_dst, parent_sha1)
                cnt_ptr[0] = cur_cnt + 1
            break

    # 3. Kahn 算法：InDegree = DepCount（依赖多少个父文件）
    #    依赖为 0 的先处理，处理后减少依赖它的文件入度
    for fi in range(file_count):
        cnt_addr3: t.CUInt64T = t.CUInt64T(file_dep_counts) + fi * 4
        cnt_ptr3: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(cnt_addr3, t.CPtr))
        ind_addr3: t.CUInt64T = t.CUInt64T(file_indegrees) + fi * 4
        ind_ptr3: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(ind_addr3, t.CPtr))
        if cnt_ptr3 is not None and ind_ptr3 is not None:
            ind_ptr3[0] = cnt_ptr3[0]

    # 4. 拓扑排序输出
    out_idx: int = 0
    changed: int = 1
    while changed != 0:
        changed = 0
        for fi in range(file_count):
            # 检查处理状态
            proc_addr4: t.CUInt64T = t.CUInt64T(file_processed) + fi * 4
            proc_ptr4: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(proc_addr4, t.CPtr))
            if proc_ptr4 is None or proc_ptr4[0] != 0:
                continue
            # 检查入度
            ind_addr4: t.CUInt64T = t.CUInt64T(file_indegrees) + fi * 4
            ind_ptr4: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(ind_addr4, t.CPtr))
            if ind_ptr4 is None or ind_ptr4[0] > 0:
                continue

            # 入度为 0，可以处理
            # 找到对应的 result.Entries 索引
            target_sha1: str = file_sha1s_buf + fi * SHA1_LEN
            for ri in range(result.Count):
                ea_r: t.CUInt64T = t.CUInt64T(result.Entries) + ri * entry_size
                ent_r: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(ea_r, t.CPtr))
                if ent_r is not None and ent_r.Sha1 is not None:
                    if string.strcmp(ent_r.Sha1, target_sha1) == 0:
                        # 写入输出索引数组
                        out_idx_addr: t.CUInt64T = t.CUInt64T(out_order) + out_idx * 4
                        out_int_ptr: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(out_idx_addr, t.CPtr))
                        if out_int_ptr is not None:
                            out_int_ptr[0] = ri
                        out_idx += 1
                        break

            # 标记已处理
            proc_ptr4[0] = 1
            changed = 1

            # 减少依赖该文件的其他文件的入度
            for fj in range(file_count):
                proc_addr5: t.CUInt64T = t.CUInt64T(file_processed) + fj * 4
                proc_ptr5: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(proc_addr5, t.CPtr))
                if proc_ptr5 is None or proc_ptr5[0] != 0:
                    continue
                # 读取 fj 的依赖数量
                cnt_addr5: t.CUInt64T = t.CUInt64T(file_dep_counts) + fj * 4
                cnt_ptr5: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(cnt_addr5, t.CPtr))
                if cnt_ptr5 is None:
                    continue
                fj_dep_cnt: int = cnt_ptr5[0]
                for di in range(fj_dep_cnt):
                    dep_slot5: str = file_deps_buf + fj * MAX_DEP_EDGES * SHA1_LEN + di * SHA1_LEN
                    if string.strcmp(dep_slot5, target_sha1) == 0:
                        ind_addr5: t.CUInt64T = t.CUInt64T(file_indegrees) + fj * 4
                        ind_ptr5: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(ind_addr5, t.CPtr))
                        if ind_ptr5 is not None:
                            ind_ptr5[0] = ind_ptr5[0] - 1
                        break

    # 处理循环依赖（未处理的文件按原顺序追加）
    if out_idx < file_count:
        for fi in range(file_count):
            proc_addr6: t.CUInt64T = t.CUInt64T(file_processed) + fi * 4
            proc_ptr6: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(proc_addr6, t.CPtr))
            if proc_ptr6 is None or proc_ptr6[0] != 0:
                continue
            target_sha1_2: str = file_sha1s_buf + fi * SHA1_LEN
            for ri in range(result.Count):
                ea_r2: t.CUInt64T = t.CUInt64T(result.Entries) + ri * entry_size
                ent_r2: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(ea_r2, t.CPtr))
                if ent_r2 is not None and ent_r2.Sha1 is not None:
                    if string.strcmp(ent_r2.Sha1, target_sha1_2) == 0:
                        out_idx_addr2: t.CUInt64T = t.CUInt64T(out_order) + out_idx * 4
                        out_int_ptr2: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(out_idx_addr2, t.CPtr))
                        if out_int_ptr2 is not None:
                            out_int_ptr2[0] = ri
                        out_idx += 1
                        break
            proc_ptr6[0] = 1

    # 写入输出数量
    out_count_ptr: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(out_count, t.CPtr))
    if out_count_ptr is not None:
        out_count_ptr[0] = out_idx

    # 释放扁平数组
    mb.free(file_sha1s_buf)
    mb.free(file_deps_buf)
    mb.free(file_dep_counts)
    mb.free(file_indegrees)
    mb.free(file_processed)

    return 0


# ============================================================
# RunPhase1 - Phase1: 扫描 includes 目录，按需翻译并生成 stub
#
# 对每个 .py 文件检查 stub 是否已存在，若不存在则翻译并分离 stub。
# "按需翻译"：仅对 stub 不存在的文件执行翻译，避免重复工作。
#
# Args:
#   mb: 内存池
#   includes_dir: includes 目录路径
#   temp_dir: 临时目录（保存 stub）
#   log: 日志器
#
# Returns:
#   0 成功，非 0 失败
# ============================================================
def RunPhase1(mb: memhub.MemBuddy | t.CPtr, includes_dir: str, temp_dir: str,
              log: VLogger.Logger | t.CPtr) -> int:
    """Phase1: 扫描 includes 目录，按需翻译并生成 stub"""
    if includes_dir is None or temp_dir is None:
        VLogger.warning("includes_dir 或 temp_dir 为空，跳过", "Phase1")
        return 1

    # 设置全局 temp_dir（供跨模块 CDefine 查找使用）
    HandlesType.set_temp_dir(temp_dir)

    # 确保 temp 目录存在（build_dir/temp 可能尚未创建）
    BuildPipeline.ensure_dir(temp_dir)

    if log is not None:
        log.banner("Phase1: 扫描 includes（按需翻译）")

    # 扫描 includes 目录
    result: IncludesScanner.ScanResult | t.CPtr = IncludesScanner.scan_includes(mb, includes_dir)
    if result is None:
        VLogger.error("扫描失败", "Phase1")
        return 1

    # 从扫描结果直接构建 SHA1 集合（不依赖 _sha1_map.txt 文件）
    # Phase1 作为编译器自身，应从内存中的扫描结果获取 SHA1，避免外部文件依赖
    sha1_set: str = stdlib.malloc(StubMerger.MAX_INCLUDES_SHA1 * 17)
    if sha1_set is None:
        VLogger.error("sha1_set 分配失败", "Phase1")
        return 1
    string.memset(sha1_set, 0, StubMerger.MAX_INCLUDES_SHA1 * 17)
    set_count: int = 0
    p1_entry_size_init: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()
    for se_i in range(result.Count):
        if set_count >= StubMerger.MAX_INCLUDES_SHA1:
            break
        se_addr: t.CUInt64T = t.CUInt64T(result.Entries) + se_i * p1_entry_size_init
        se_ent: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(se_addr, t.CPtr))
        if se_ent is None or se_ent.Sha1 is None:
            continue
        string.strcpy(sha1_set + set_count * 17, se_ent.Sha1)
        set_count += 1
    if set_count <= 0:
        VLogger.warning("扫描结果无有效 SHA1，跳过 Phase1（项目可能无 includes 依赖）", "Phase1")
        stdlib.free(sha1_set)
        return 0
    # 写入 _sha1_map.txt（人类可读输出，程序内部不读取；机器分析使用 PopulateSha1MapStore 内存存储器）
    StubMerger.WriteIncludesSha1Map(mb, temp_dir, result, None, 0)
    # 填充全局 SHA1 映射存储器（内存中，不依赖 _sha1_map.txt 文件）
    StubMerger.PopulateSha1MapStore(result)
    # 构建模块 SHA1 映射（供跨模块函数调用名混淆使用）
    td_len_p1map: t.CSizeT = string.strlen(temp_dir)
    p1_sha1_arr: bytes = stdlib.malloc(StubMerger.MAX_INCLUDES * 17)
    p1_mod_arr: bytes = stdlib.malloc(StubMerger.MAX_INCLUDES * 64)
    p1_inc_count: int = 0
    if p1_sha1_arr is not None and p1_mod_arr is not None:
        p1_inc_count = StubMerger._BuildIncludesSha1Map(temp_dir, td_len_p1map, p1_sha1_arr, p1_mod_arr)
    HandlesExprCall.set_module_sha1_map(p1_sha1_arr, p1_mod_arr, p1_inc_count)

    # 初始化 AST 表（只需一次）
    ast._init_tables(mb)

    # FileEntry 结构体大小（Phase 1a 和 1b 共用）
    entry_size: t.CSizeT = IncludesScanner.FileEntry.__sizeof__()

    # ============================================================
    # Phase 1a-pre: 扫描所有 includes 文件的 import 依赖
    #
    # 只处理 Import/ImportFrom 语句，跳过 ClassDef/FunctionDef 等，
    # 不调用 resolve_annotation_type，避免 list[...] 等不支持的语法触发 crash。
    # 生成 .deps.txt 供依赖图按需翻译使用。
    # ============================================================
    p1a_registered: int = 0
    p1a_skipped: int = 0
    p1a_failed: int = 0

    for i in range(result.Count):
        entry_addr_a: t.CUInt64T = t.CUInt64T(result.Entries) + i * entry_size
        entry_a: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(entry_addr_a, t.CPtr))
        if entry_a is None:
            p1a_failed += 1
            continue

        sha1_a: str = entry_a.Sha1
        if sha1_a is None:
            p1a_failed += 1
            continue

        if StubMerger._is_in_sha1_set(sha1_a, sha1_set, set_count) == 0:
            p1a_skipped += 1
            continue

        # 读取文件内容
        file_path_a: str = entry_a.Path
        f_a: fileio.File | t.CPtr = fileio.File(file_path_a, fileio.MODE.R)
        if f_a.closed:
            p1a_failed += 1
            continue

        src_buf_a: bytes = stdlib.malloc(SRC_BUF_SIZE)
        if src_buf_a is None:
            f_a.close()
            p1a_failed += 1
            continue

        bytes_read_a: LONG = f_a.read_all(src_buf_a, SRC_BUF_SIZE)
        f_a.close()
        if bytes_read_a <= 0:
            stdlib.free(src_buf_a)
            p1a_failed += 1
            continue
        if bytes_read_a < SRC_BUF_SIZE:
            src_buf_a[bytes_read_a] = 0
        else:
            src_buf_a[SRC_BUF_SIZE - 1] = 0

        # 解析 AST
        lx_a: ast.Lexer | t.CPtr = ast.new_lexer(mb)
        if lx_a is None:
            stdlib.free(src_buf_a)
            p1a_failed += 1
            continue
        ast._lexer_init(lx_a, src_buf_a, mb)
        tokens_a: ast.Token | t.CPtr = ast.tokenize(lx_a)
        tree_a: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens_a)
        if tree_a is None:
            stdlib.free(src_buf_a)
            p1a_failed += 1
            continue

        # 创建 Translator，设置 _declare_only=2（只扫描 import，跳过 ClassDef）
        tr_a: HandlesTranslator.Translator | t.CPtr = HandlesTranslator.Translator()
        if tr_a is None:
            stdlib.free(src_buf_a)
            p1a_failed += 1
            continue
        tr_a.ModuleSha1 = sha1_a
        tr_a._declare_only = 2
        tr_a.CurrentPackage = HandlesImports.compute_package_from_relpath(mb, entry_a.RelPath)
        HandlesType.set_current_file(file_path_a)
        HandlesType.set_current_module_sha1(sha1_a)
        HandlesType.clear_cdefine_constants()
        HandlesStruct.reset_visible_structs(mb, 0)
        ret_a: int = tr_a.translate(tree_a)
        if ret_a != 0:
            p1a_failed += 1
        else:
            p1a_registered += 1

        # 生成 .deps.txt（记录依赖模块名，供依赖图按需翻译使用）
        td_len_a: t.CSizeT = string.strlen(temp_dir)
        deps_path_a: str = StubMerger._sliced_path(temp_dir, td_len_a, sha1_a, "deps.txt")
        if deps_path_a is not None:
            df_a: fileio.File | t.CPtr = fileio.File(deps_path_a, fileio.MODE.W)
            if not df_a.closed:
                if tr_a._imported_modules is not None:
                    dl_a: t.CSizeT = string.strlen(tr_a._imported_modules)
                    df_a.write(tr_a._imported_modules, dl_a)
                df_a.close()
            stdlib.free(deps_path_a)

        # 释放 Translator 的 C malloc 资源
        if tr_a._global_names is not None:
            stdlib.free(tr_a._global_names)
        if tr_a._nonlocal_names is not None:
            stdlib.free(tr_a._nonlocal_names)

        stdlib.free(src_buf_a)

    # ============================================================
    # 依赖图按需翻译：构建可达 SHA1 集合
    #
    # 从 Config.SourceDir 的源文件开始，解析 import 语句，递归收集
    # 可达的 includes 文件 SHA1。Phase 1b 只翻译可达集合中的文件，
    # 避免翻译不需要的 includes（如 Test 不依赖 llvmlite，则不翻译）。
    # 如果 Config.SourceDir 不可用（仅运行 Phase1），回退到 sha1_set。
    # ============================================================
    reachable_set: str = None
    reachable_count: int = 0
    use_reachable: int = 0
    if Config.SourceDir is not None:
        reachable_set = stdlib.malloc(StubMerger.MAX_INCLUDES_SHA1 * 17)
        if reachable_set is not None:
            string.memset(reachable_set, 0, StubMerger.MAX_INCLUDES_SHA1 * 17)
            reachable_count = StubMerger._BuildReachableSha1Set(mb, Config.SourceDir, temp_dir, reachable_set)
            if reachable_count > 0:
                use_reachable = 1
                # 用可达集合重新生成 _sha1_map.txt（按图求索的最终产物）
                # Phase B+ 只遍历这些条目，避免编译不需要的 includes（如 asm.py）
                StubMerger.WriteIncludesSha1Map(mb, temp_dir, result, reachable_set, reachable_count)
                # 重新加载 sha1_set，使后续 Phase 1a-pre/1a/1b 的过滤也使用可达集合
                string.memset(sha1_set, 0, StubMerger.MAX_INCLUDES_SHA1 * 17)
                set_count = StubMerger._load_includes_sha1_set(mb, temp_dir, sha1_set)
            else:
                stdlib.free(reachable_set)
                reachable_set = None

    # ============================================================
    # Phase 1a: 注册可达 includes 文件的 struct/enum/union
    #
    # 解决字母序依赖问题：按字母顺序翻译时，后面的 struct 未注册
    # 前面就需要用。Phase 1a 先注册所有 struct/enum/union 到全局表，
    # Phase 1b 全量翻译时 struct 已注册，走 existing 路径只翻译方法体。
    # 只处理可达文件，避免翻译不需要的 includes（如 Test 不依赖 ast 模块）。
    #
    # 拓扑排序：预扫描所有文件收集类继承关系，按依赖顺序处理文件，
    # 确保父类所在文件先于子类所在文件处理（如 base.py 先于 astaux.py）。
    # ============================================================
    p1a_reg: int = 0
    p1a_skp: int = 0
    p1a_fl: int = 0

    # 预扫描类继承关系，构建拓扑顺序（用扁平字节数组，避免结构体 str 指针 NULL 崩溃）
    class_names_buf: bytes = mb.alloc(MAX_CLASSES * CLASS_NAME_LEN)
    parent_names_buf: bytes = mb.alloc(MAX_CLASSES * CLASS_NAME_LEN)
    def_sha1s_buf: bytes = mb.alloc(MAX_CLASSES * SHA1_LEN)
    topo_order: t.CPtr = mb.alloc(4 * MAX_FILE_DEPS)
    topo_count_box: t.CPtr = mb.alloc(4)
    topo_count: int = 0

    if class_names_buf is not None and parent_names_buf is not None and def_sha1s_buf is not None and topo_order is not None and topo_count_box is not None:
        string.memset(class_names_buf, 0, MAX_CLASSES * CLASS_NAME_LEN)
        string.memset(parent_names_buf, 0, MAX_CLASSES * CLASS_NAME_LEN)
        string.memset(def_sha1s_buf, 0, MAX_CLASSES * SHA1_LEN)
        string.memset(topo_order, 0, 4 * MAX_FILE_DEPS)
        string.memset(topo_count_box, 0, 4)

        class_count_scanned: int = _ScanClassInheritance(
            mb, result, reachable_set, reachable_count,
            use_reachable, sha1_set, set_count,
            class_names_buf, parent_names_buf, def_sha1s_buf)

        if class_count_scanned > 0:
            ret_topo: int = _TopoSortFiles(
                mb, result, reachable_set, reachable_count,
                use_reachable, sha1_set, set_count,
                class_names_buf, parent_names_buf, def_sha1s_buf, class_count_scanned,
                topo_order, topo_count_box)
            if ret_topo == 0:
                tc_ptr: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(topo_count_box, t.CPtr))
                if tc_ptr is not None:
                    topo_count = tc_ptr[0]
                fb_topo: t.CChar | t.CPtr = VLogger.fmt_buf()
                if fb_topo is not None:
                    viperlib.snprintf(fb_topo, 1024,
                                      "拓扑排序: %d 个类, %d 个文件按依赖顺序处理",
                                      class_count_scanned, topo_count)
                    VLogger.info(fb_topo, "Phase1")
            else:
                VLogger.warning("拓扑排序失败，回退到字母序", "Phase1")
                topo_count = 0
        else:
            VLogger.warning("类继承预扫描无结果，回退到字母序", "Phase1")
            topo_count = 0

    # 遍历文件：优先使用拓扑顺序，回退到字母序
    iter_count: int = topo_count if topo_count > 0 else result.Count
    for i in range(iter_count):
        # 获取文件索引：拓扑顺序或字母序
        file_idx: int = i
        if topo_count > 0:
            od_addr: t.CUInt64T = t.CUInt64T(topo_order) + i * 4
            od_ptr: t.CPtr = (t.CInt | t.CPtr)(t.CVoid(od_addr, t.CPtr))
            if od_ptr is not None:
                file_idx = od_ptr[0]

        entry_addr_r: t.CUInt64T = t.CUInt64T(result.Entries) + file_idx * entry_size
        entry_r: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(entry_addr_r, t.CPtr))
        if entry_r is None:
            p1a_fl += 1
            continue

        sha1_r: str = entry_r.Sha1
        if sha1_r is None:
            p1a_fl += 1
            continue

        # 按需翻译过滤（拓扑排序已过滤，但字母序回退需要检查）
        if topo_count == 0:
            if use_reachable != 0:
                if StubMerger._is_in_sha1_set(sha1_r, reachable_set, reachable_count) == 0:
                    p1a_skp += 1
                    continue
            else:
                if StubMerger._is_in_sha1_set(sha1_r, sha1_set, set_count) == 0:
                    p1a_skp += 1
                    continue

        # 读取文件内容
        file_path_r: str = entry_r.Path
        f_r: fileio.File | t.CPtr = fileio.File(file_path_r, fileio.MODE.R)
        if f_r.closed:
            p1a_fl += 1
            continue

        src_buf_r: bytes = stdlib.malloc(SRC_BUF_SIZE)
        if src_buf_r is None:
            f_r.close()
            p1a_fl += 1
            continue

        bytes_read_r: LONG = f_r.read_all(src_buf_r, SRC_BUF_SIZE)
        f_r.close()
        if bytes_read_r <= 0:
            stdlib.free(src_buf_r)
            p1a_fl += 1
            continue
        if bytes_read_r < SRC_BUF_SIZE:
            src_buf_r[bytes_read_r] = 0
        else:
            src_buf_r[SRC_BUF_SIZE - 1] = 0

        # 解析 AST
        lx_r: ast.Lexer | t.CPtr = ast.new_lexer(mb)
        if lx_r is None:
            stdlib.free(src_buf_r)
            p1a_fl += 1
            continue
        ast._lexer_init(lx_r, src_buf_r, mb)
        tokens_r: ast.Token | t.CPtr = ast.tokenize(lx_r)
        tree_r: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens_r)
        if tree_r is None:
            stdlib.free(src_buf_r)
            p1a_fl += 1
            continue

        # 创建 Translator，设置 _declare_only=1（注册 struct/enum/union）
        tr_r: HandlesTranslator.Translator | t.CPtr = HandlesTranslator.Translator()
        if tr_r is None:
            stdlib.free(src_buf_r)
            p1a_fl += 1
            continue
        tr_r.ModuleSha1 = sha1_r
        tr_r._declare_only = 1
        tr_r.CurrentPackage = HandlesImports.compute_package_from_relpath(mb, entry_r.RelPath)
        HandlesType.set_current_file(file_path_r)
        HandlesType.set_current_module_sha1(sha1_r)
        HandlesType.clear_cdefine_constants()
        HandlesStruct.reset_visible_structs(mb, 0)
        ret_r: int = tr_r.translate(tree_r)
        if ret_r != 0:
            p1a_fl += 1
        else:
            p1a_reg += 1

        # 释放 Translator 的 C malloc 资源
        if tr_r._global_names is not None:
            stdlib.free(tr_r._global_names)
        if tr_r._nonlocal_names is not None:
            stdlib.free(tr_r._nonlocal_names)
        stdlib.free(src_buf_r)

    # 释放拓扑排序资源
    if class_names_buf is not None:
        mb.free(class_names_buf)
    if parent_names_buf is not None:
        mb.free(parent_names_buf)
    if def_sha1s_buf is not None:
        mb.free(def_sha1s_buf)
    if topo_order is not None:
        mb.free(topo_order)
    if topo_count_box is not None:
        mb.free(topo_count_box)

    # ============================================================
    # Phase 1b: 全量翻译（struct 已注册，走 existing 路径翻译方法体）
    # ============================================================
    # 遍历每个文件
    translated: int = 0
    skipped: int = 0
    failed: int = 0

    for i in range(result.Count):
        # 获取 entry
        entry_addr: t.CUInt64T = t.CUInt64T(result.Entries) + i * entry_size
        entry: IncludesScanner.FileEntry | t.CPtr = (IncludesScanner.FileEntry | t.CPtr)(t.CVoid(entry_addr, t.CPtr))
        if entry is None:
            failed += 1
            continue

        sha1: str = entry.Sha1
        if sha1 is None:
            failed += 1
            continue

        # 检查 SHA1 是否在翻译集合中（按需翻译：只翻译可达的文件）
        in_set: int = 0
        if use_reachable != 0:
            in_set = StubMerger._is_in_sha1_set(sha1, reachable_set, reachable_count)
        else:
            in_set = StubMerger._is_in_sha1_set(sha1, sha1_set, set_count)
        if in_set == 0:
            skipped += 1
            continue

        # 构造 stub 路径: {temp_dir}/{sha1}.stub.ll
        dir_len: t.CSizeT = string.strlen(temp_dir)
        sha1_len: t.CSizeT = string.strlen(sha1)
        stub_path: str = StubMerger._sliced_path(temp_dir, dir_len, sha1, "stub.ll")
        if stub_path is None:
            failed += 1
            continue

        # 检查 stub 是否已存在（按需翻译：跳过已存在的）
        sf: fileio.File | t.CPtr = fileio.File(stub_path, fileio.MODE.R)
        if not sf.closed:
            sf.close()
            # 检查 text.ll 是否也存在（虚表扫描需要 text.ll）
            text_path: str = StubMerger._sliced_path(temp_dir, dir_len, sha1, "text.ll")
            if text_path is not None:
                tf: fileio.File | t.CPtr = fileio.File(text_path, fileio.MODE.R)
                if not tf.closed:
                    tf.close()
                    stdlib.free(text_path)
                    stdlib.free(stub_path)
                    continue
                stdlib.free(text_path)
            # text.ll 不存在，需要重新翻译
            rp: str = entry.RelPath
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "text.ll 不存在，重新翻译: %s (sha1=%s)", rp, sha1)
                VLogger.info(fb, "Phase1")
        else:
            # stub 不存在，需要翻译
            rp: str = entry.RelPath
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "翻译: %s (sha1=%s)", rp, sha1)
                VLogger.info(fb, "Phase1")

        stdlib.free(stub_path)

        # 读取文件内容
        file_path: str = entry.Path
        f: fileio.File | t.CPtr = fileio.File(file_path, fileio.MODE.R)
        if f is None:
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "无法打开(None): %s", file_path)
                VLogger.error(fb, "Phase1")
            failed += 1
            continue
        if f.closed:
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "无法打开: %s", file_path)
                VLogger.error(fb, "Phase1")
            failed += 1
            continue

        src_buf: bytes = stdlib.malloc(SRC_BUF_SIZE)
        if src_buf is None:
            f.close()
            failed += 1
            continue

        bytes_read: LONG = f.read_all(src_buf, SRC_BUF_SIZE)
        f.close()
        if bytes_read <= 0:
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "读取失败: %s", file_path)
                VLogger.error(fb, "Phase1")
            stdlib.free(src_buf)
            failed += 1
            continue
        if bytes_read < SRC_BUF_SIZE:
            src_buf[bytes_read] = 0
        else:
            src_buf[SRC_BUF_SIZE - 1] = 0

        # 解析 AST
        stdio.printf("[P1B-1] parse %s\n", entry.RelPath)
        lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
        if lx is None:
            stdlib.free(src_buf)
            failed += 1
            continue
        ast._lexer_init(lx, src_buf, mb)
        tokens: ast.Token | t.CPtr = ast.tokenize(lx)
        tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
        stdio.printf("[P1B-1a] parse-done %s\n", entry.RelPath)
        if tree is None:
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "AST 解析失败: %s", file_path)
                VLogger.error(fb, "Phase1")
            stdlib.free(src_buf)
            failed += 1
            continue

        # 生成 .pyi 存根文件（直接遍历 AST，不依赖 PythonToStubConverter）
        stdio.printf("[P1B-2] pyi %s\n", entry.RelPath)
        pyi_buf: bytes = stdlib.malloc(PYI_BUF_SIZE)
        if pyi_buf is not None:
            pyi_pos: t.CSizeT = StubConverter._GeneratePyiFromAst(mb, tree, entry.RelPath, pyi_buf, PYI_BUF_SIZE)
            if pyi_pos > 0:
                pyi_path: str = StubMerger._sliced_path(temp_dir, dir_len, sha1, "pyi")
                if pyi_path is not None:
                    pf: fileio.File | t.CPtr = fileio.File(pyi_path, fileio.MODE.W)
                    if not pf.closed:
                        pf.write(pyi_buf, pyi_pos)
                        pf.close()
                    stdlib.free(pyi_path)
            stdlib.free(pyi_buf)

        # 翻译 AST → LLVM IR
        stdio.printf("[P1B-3] translate %s\n", entry.RelPath)
        tr: HandlesTranslator.Translator | t.CPtr = HandlesTranslator.Translator()
        if tr is None:
            stdlib.free(src_buf)
            failed += 1
            continue
        tr.ModuleSha1 = sha1
        tr.CurrentPackage = HandlesImports.compute_package_from_relpath(mb, entry.RelPath)
        HandlesType.set_current_file(file_path)
        HandlesType.set_current_module_sha1(sha1)
        HandlesType.clear_cdefine_constants()
        HandlesStruct.reset_visible_structs(mb, 0)
        ret: int = tr.translate(tree)
        stdio.printf("[P1B-3a] translate-done %s ret=%d\n", entry.RelPath, ret)
        if ret != 0:
            fb: t.CChar | t.CPtr = VLogger.fmt_buf()
            if fb is not None:
                viperlib.snprintf(fb, 1024, "翻译失败: %s", file_path)
                VLogger.error(fb, "Phase1")
            stdlib.free(src_buf)
            if tr._global_names is not None:
                stdlib.free(tr._global_names)
            if tr._nonlocal_names is not None:
                stdlib.free(tr._nonlocal_names)
            failed += 1
            continue

        # dump stub IR (declarations only)
        stdio.printf("[P1B-4] stub %s\n", entry.RelPath)
        PHASE1_IR_SIZE: t.CSizeT = 1048576
        stub_buf: bytes = stdlib.malloc(PHASE1_IR_SIZE)
        if stub_buf is None:
            stdlib.free(src_buf)
            if tr._global_names is not None:
                stdlib.free(tr._global_names)
            if tr._nonlocal_names is not None:
                stdlib.free(tr._nonlocal_names)
            failed += 1
            continue
        tr.dump_ir(stub_buf, PHASE1_IR_SIZE, llvmlite.OUTPUT_STUB)
        stub_len: t.CSizeT = string.strlen(stub_buf)

        # save stub.ll
        dir_len_p1: t.CSizeT = string.strlen(temp_dir)
        stub_path_p1: str = StubMerger._sliced_path(temp_dir, dir_len_p1, sha1, "stub.ll")
        if stub_path_p1 is not None:
            sf_p1: fileio.File | t.CPtr = fileio.File(stub_path_p1, fileio.MODE.W)
            if not sf_p1.closed:
                sf_p1.write(stub_buf, stub_len)
                sf_p1.close()
            stdlib.free(stub_path_p1)
        stdlib.free(stub_buf)

        # dump text IR (definitions only)
        stdio.printf("[P1B-5] text %s\n", entry.RelPath)
        text_buf: bytes = stdlib.malloc(PHASE1_IR_SIZE)
        if text_buf is None:
            stdlib.free(src_buf)
            if tr._global_names is not None:
                stdlib.free(tr._global_names)
            if tr._nonlocal_names is not None:
                stdlib.free(tr._nonlocal_names)
            failed += 1
            continue
        tr.dump_ir(text_buf, PHASE1_IR_SIZE, llvmlite.OUTPUT_TEXT)
        text_len: t.CSizeT = string.strlen(text_buf)

        # save text.ll
        text_path_p1: str = StubMerger._sliced_path(temp_dir, dir_len_p1, sha1, "text.ll")
        if text_path_p1 is not None:
            tf_p1: fileio.File | t.CPtr = fileio.File(text_path_p1, fileio.MODE.W)
            if not tf_p1.closed:
                tf_p1.write(text_buf, text_len)
                tf_p1.close()
            stdlib.free(text_path_p1)
        stdlib.free(text_buf)

        # save dependencies (_imported_modules) for Phase B
        deps_path_p1: str = StubMerger._sliced_path(temp_dir, dir_len_p1, sha1, "deps.txt")
        if deps_path_p1 is not None:
            df_p1: fileio.File | t.CPtr = fileio.File(deps_path_p1, fileio.MODE.W)
            if not df_p1.closed:
                if tr._imported_modules is not None:
                    dl: t.CSizeT = string.strlen(tr._imported_modules)
                    df_p1.write(tr._imported_modules, dl)
                df_p1.close()
            stdlib.free(deps_path_p1)

        # 释放 Translator 的 C malloc 资源
        if tr._global_names is not None:
            stdlib.free(tr._global_names)
        if tr._nonlocal_names is not None:
            stdlib.free(tr._nonlocal_names)

        # 所有 dump_ir 完成，src_buf 不再需要
        stdlib.free(src_buf)

        translated += 1

    fb: t.CChar | t.CPtr = VLogger.fmt_buf()
    if fb is not None:
        viperlib.snprintf(fb, 1024, "完成: 翻译=%d 跳过=%d 失败=%d", translated, skipped, failed)
        VLogger.info(fb, "Phase1")

    # 释放可达 SHA1 集合（如果分配了）
    if reachable_set is not None:
        stdlib.free(reachable_set)

    return 0