#!/usr/bin/env python3
"""
obfuscate_symbols.py  —  Swift 类型名符号混淆工具
用法:
  python3 AutoPacking/obfuscation/obfuscate_symbols.py --scan-dir readoor/3.0        # 仅预览，不修改
  python3 AutoPacking/obfuscation/obfuscate_symbols.py --scan-dir readoor/3.0 --apply  # 真正替换
  python3 AutoPacking/obfuscation/obfuscate_symbols.py --deobfuscate crash.log         # 还原 crash 符号
"""

import os
import re
import json
import hashlib
import argparse
import sys
import secrets
import time
import shutil
import tempfile
import multiprocessing
import subprocess
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from obfuscation_runtime.canonical import (
    build_canonical_symbol_tables,
    build_method_mapping_from_canonical_table,
    build_type_mappings_from_canonical_table,
)
from obfuscation_runtime.discovery import discover_files, prefilter_files_with_rg
from obfuscation_runtime.json_cache import IncrementalAnalysisCache, load_json_file, save_json_file

# ── 配置 ──────────────────────────────────────────────────────────────────────

# 扫描这些目录（相对于脚本所在目录）。默认改为项目根以覆盖整个仓库，
# 也可通过命令行的 --scan-dir 覆盖为更精确的子目录。
DEFAULT_SCAN_DIRS = ["."]

# 排除目录（含这些路径片段的文件跳过）
EXCLUDE_PATH_FRAGMENTS = [
    ".build/",
    ".git/",
    "Pods/",
    "Carthage/",
    "Tests/",
    "readoorTests/",
    "DerivedData/",
    "RDObfuscateMacro/",   # 我们自己的宏包，不混淆
    ".framework/",
    ".xcframework/",
]
THIRD_PARTY_PROTOCOL_EXCLUDE_PATH_FRAGMENTS = [
    frag for frag in EXCLUDE_PATH_FRAGMENTS
    if frag not in {"Pods/", ".framework/", ".xcframework/"}
]

# 目录名白名单：完全匹配这些目录名则在提取阶段忽略（例如第三方/工具目录）
EXCLUDE_DIR_NAMES = ("Factorys",)
METHOD_REPLACEMENT_SKIP_DIR_NAMES = ("Pods",)
# 始终保留（白名单）的符号，完全匹配
SYMBOL_WHITELIST = {
    # AppKit / UIKit 入口
    "AppDelegate", "SceneDelegate",
    # 常见系统协议实现类型
    "Error", "Result", "Event",
    # Swift 内建类型
    "String", "Int", "Bool", "Double", "Float", "Data", "URL", "Date",
    "Array", "Dictionary", "Set", "Optional",
    # JSON 编解码保留（必须与 JSON key 名一致，混淆会导致解码失败）
    "CodingKeys",
    # StoreKit / 内购 相关类型（保留，避免混淆第三方/系统 IAP 协议/模型）
    "SKProduct", "SKProductsRequest", "SKProductsResponse", "SKPayment", "SKPaymentQueue",
    "SKPaymentTransaction", "SKPaymentTransactionObserver", "SKProductsRequestDelegate",
    "SKReceiptRefreshRequest", "SKStoreProductViewController", "SKMutablePayment",
    # StoreKit 2 及 App Store 相关通用类型
    "Product", "Transaction", "StoreKit", "AppStore",
}

# 前缀白名单：含这些前缀的符号跳过（第三方/系统）
SYMBOL_PREFIX_WHITELIST = ("NS", "UI", "AV", "CL", "MK", "SK", "CG", "CA", "WK")

# 一些语言/运行时保留标识符，绝对不能被替换（例如 Objective-C/Swift 的 `self`/`super` 等）
RESERVED_IDENTIFIERS = {
    # Obj-C instance/reference keywords
    "self", "super",
    # Obj-C literals / common macros
    "nil", "NULL", "YES", "NO",
    # Swift / JSON booleans
    "true", "false",
}

# 仅混淆这些 Swift 声明关键字（保守策略，先不动 func/var）
DECL_KEYWORDS = ("class", "struct", "enum", "protocol")

# 混淆后名称前缀（让 crash 还原时还能快速识别来源）
# 类型名使用 YMH；方法名使用 ymh，避免 Swift 导入 Obj-C 时出现
# “'YMHxxxx()' has been renamed to 'ymhxxxx()'” 提示。
TYPE_OBFUSCATED_PREFIX = "YMH"
METHOD_OBFUSCATED_PREFIX = "ymh"
OBFUSCATED_PREFIX = TYPE_OBFUSCATED_PREFIX
# 混淆哈希长度（hex 字符数）。增大此值可显著降低不同运行间重复概率。
OBFUSCATED_HASH_LEN = 10
LEGACY_OBFUSCATED_HASH_LENGTHS = (6, 8, 10)
ALREADY_OBFUSCATED_PREFIXES = (TYPE_OBFUSCATED_PREFIX, METHOD_OBFUSCATED_PREFIX)

# 仅对这些文件名前缀进行混淆（基于文件名，不含扩展）
# 例如 Swift 文件 `RDWereadOAuthWebViewController.swift` 会匹配 'RD'
SWIFT_FILENAME_PREFIXES = ("RD", "RB")
# 对 Obj-C 文件匹配的前缀（例如 `STS... .m/.h`）
OBJC_FILENAME_PREFIXES = ("STS", "RB")

# 仅混淆这些符号名前缀（避免在 RD 文件中误混淆第三方或通用类）
SWIFT_SYMBOL_PREFIXES = ("RD", "RB")
OBJC_SYMBOL_PREFIXES = ("STS", "RB")

# 映射表保存路径
MAP_OUTPUT_PATH = "obfuscation_map.json"
APPLY_STATE_PATH = ".obfuscate_apply_state.json"
SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_METHOD_IGNORE_FILE_PATH = str(SCRIPT_DIR / "system_methods_ignore.txt")
AUTO_DETECTED_METHOD_IGNORE_BEGIN = "# BEGIN AUTO-DETECTED-OBJC-DOT-SYNTAX"
AUTO_DETECTED_METHOD_IGNORE_END = "# END AUTO-DETECTED-OBJC-DOT-SYNTAX"
SOURCE_FILE_EXTENSIONS = (".swift", ".m", ".mm", ".h", ".pch")
# 方法映射输出（dry-run）
METHOD_MAP_OUTPUT_PATH = "tmp_method_map.json"
DEFAULT_WORKERS = max(1, min(8, os.cpu_count() or 4))
IOS_SYSTEM_SYMBOL_CACHE_PATH = ".ios_system_symbols_cache.json"
IOS_SYSTEM_SYMBOL_CACHE_VERSION = 2
EXTRACTION_CACHE_PATH = ".obfuscate_extraction_cache.json"
EXTRACTION_CACHE_VERSION = 3
IOS_SYSTEM_SYMBOL_SCAN_DIRS = (
    "System/Library/Frameworks",
    "usr/include",
)
THIRD_PARTY_PROTOCOL_ROOT_NAMES = ("Pods", "Factorys")
METHOD_CANDIDATE_PREFIXES = ("STS", "RD", "RB")
METHOD_CANDIDATE_EXTENSIONS = (".swift", ".m", ".mm", ".h")
RG_DISCOVERY_EXTENSIONS = SOURCE_FILE_EXTENSIONS
RG_CHUNK_SIZE = 256
PROJECT_SOURCE_ANALYSIS_KIND = "project_source"
THIRD_PARTY_MEMBER_ANALYSIS_KIND = "third_party_member"
_EXTRACTION_ANALYSIS_CACHE = IncrementalAnalysisCache(EXTRACTION_CACHE_PATH, EXTRACTION_CACHE_VERSION)

TYPE_DECLARATION_RG_PATTERN = r"\b(?:class|struct|enum|protocol)\s+[A-Za-z_]|@(?:interface|implementation|protocol)\s+[A-Za-z_]"
METHOD_DECLARATION_RG_PATTERN = r"\bfunc\s+[A-Za-z_]|^[[:space:]]*[+-][[:space:]]*\("
PROPERTY_DECLARATION_RG_PATTERN = r"@property\b|\b(?:var|let)\s+[A-Za-z_]"
SELECTOR_LITERAL_RG_PATTERN = r'@"[A-Za-z_][A-Za-z0-9_:@]*"'
OBJC_DOT_SYNTAX_MEMBER_RG_PATTERN = r"\.\s*[A-Za-z_]"

# 常见系统成员名兜底（即使 SDK 扫描失败，也不要混淆这些高风险名字）
COMMON_SYSTEM_MEMBER_NAMES = {
    # 来源: Apple Developer Documentation (常用 UIKit / Delegate / DataSource / WebKit / UserNotifications API)
    #  - https://developer.apple.com/documentation/uikit/uiviewcontroller
    #  - https://developer.apple.com/documentation/uikit/uiview
    #  - https://developer.apple.com/documentation/uikit/uislider
    #  - https://developer.apple.com/documentation/uikit/uiscrollviewdelegate
    #  - https://developer.apple.com/documentation/uikit/uitableviewdelegate
    #  - https://developer.apple.com/documentation/uikit/uitableviewdatasource
    #  - https://developer.apple.com/documentation/uikit/uicollectionviewdelegate
    #  - https://developer.apple.com/documentation/uikit/uicollectionviewdatasource
    #  - https://developer.apple.com/documentation/uikit/uiapplicationdelegate
    #  - https://developer.apple.com/documentation/uikit/uiscenedelegate
    #  - https://developer.apple.com/documentation/usernotifications/unusernotificationcenterdelegate
    #  - https://developer.apple.com/documentation/uikit/uigesturerecognizerdelegate
    #  - https://developer.apple.com/documentation/webkit/wkwebview
    #  - https://developer.apple.com/documentation/webkit/wknavigationdelegate

    # 基本 Obj-C/Swift setter/getter 名
    "set",
    "get",

    # UIViewController lifecycle / layout
    "viewDidLoad", "viewWillAppear", "viewDidAppear", "viewWillDisappear", "viewDidDisappear",
    "viewWillLayoutSubviews", "viewDidLayoutSubviews", "viewSafeAreaInsetsDidChange",
    "viewWillLayoutSubviews", "viewDidLayoutSubviews", "viewWillLayoutSubviews",
    "didReceiveMemoryWarning", "traitCollectionDidChange", "awakeFromNib", "deinit",
    "prepareForSegue", "loadView", "loadViewIfNeeded", "setNeedsUpdateProperties",

    # UIView / view hierarchy
    "layoutSubviews", "layoutIfNeeded", "setNeedsLayout", "setNeedsDisplay",
    "addSubview", "removeFromSuperview", "willMoveToSuperview", "didMoveToSuperview",
    "willMoveToWindow", "didMoveToWindow", "didAddSubview", "willRemoveSubview",
    "draw", "drawRect", "setNeedsDisplay", "tintColorDidChange",
    "systemLayoutSizeFittingSize", "systemLayoutSizeFittingSize:",
    "systemLayoutSizeFitting", "systemLayoutSizeFitting(_:withHorizontalFittingPriority:verticalFittingPriority:)",

    # UIResponder / touch handling
    "touchesBegan", "touchesMoved", "touchesEnded", "touchesCancelled",

    # Gesture recognizer
    "gestureRecognizerShouldBegin", "gestureRecognizer", "gestureRecognizer:shouldReceiveTouch:",
    "gestureRecognizer(_:shouldRecognizeSimultaneouslyWith:)",

    # Scroll / Zoom delegate
    "scrollViewDidScroll", "scrollViewWillBeginDragging", "scrollViewWillEndDragging",
    "scrollViewDidEndDragging", "scrollViewDidEndDecelerating", "scrollViewDidEndScrollingAnimation",
    "scrollViewDidZoom", "scrollViewWillBeginZooming", "viewForZooming(in:)",
    "scrollViewDidChangeAdjustedContentInset",

    # TableView delegate / datasource (常见签名关键词)
    "tableView", "didSelectRowAt", "didDeselectRowAt", "willSelectRowAt", "willDeselectRowAt",
    "cellForRowAt", "numberOfRowsInSection", "numberOfSections", "heightForRowAt", "estimatedHeightForRowAt",
    "willDisplayCell", "didEndDisplayingCell", "commit", "canEditRowAt", "moveRowAt",
    "accessoryButtonTappedForRowWith", "leadingSwipeActionsConfigurationForRowAt", "trailingSwipeActionsConfigurationForRowAt",

    # CollectionView delegate / datasource
    "collectionView", "cellForItemAt", "numberOfItemsInSection", "didSelectItemAt", "didDeselectItemAt",
    "willDisplayCellForItemAt", "didEndDisplayingCellForItemAt", "targetContentOffsetForProposedContentOffset",

    # App / Scene lifecycle
    "application:didFinishLaunchingWithOptions:", "application:open:options:",
    "applicationDidBecomeActive", "applicationWillResignActive", "applicationDidEnterBackground",
    "applicationWillEnterForeground", "applicationWillTerminate",
    "application:didRegisterForRemoteNotificationsWithDeviceToken:",
    "application:didFailToRegisterForRemoteNotificationsWithError:",
    "application:didReceiveRemoteNotification:fetchCompletionHandler:",

    # Scene delegate
    "scene(_:willConnectTo:options:)", "sceneDidDisconnect", "sceneWillEnterForeground",
    "sceneDidBecomeActive", "sceneWillResignActive", "sceneDidEnterBackground",

    # Notifications / UNUserNotificationCenterDelegate
    "userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:",
    "userNotificationCenter:willPresentNotification:withCompletionHandler:",
    "userNotificationCenter:openSettingsFor:",

    # WebKit / WKNavigationDelegate
    "webView(_:decidePolicyFor:decisionHandler:)", "webView(_:didStartProvisionalNavigation:)",
    "webView(_:didFinish:)", "webView(_:didFail:withError:)",

    # WKWebView documented instance methods (avoid obfuscating WebKit entry points used directly in app code)
    "loadHTMLString", "loadFileURL", "loadFileRequest", "loadSimulatedRequest",
    "reloadFromOrigin", "stopLoading", "goBack", "goForward", "go(to:)",
    "evaluateJavaScript", "callAsyncJavaScript", "takeSnapshot", "createPDF",
    "createWebArchiveData", "startDownload", "resumeDownload", "setMagnification",
    "pauseAllMediaPlayback", "requestMediaPlaybackState", "setAllMediaPlaybackSuspended",
    "closeAllMediaPresentations", "setCameraCaptureState", "setMicrophoneCaptureState",
    "find", "setMinimumViewportInset", "fetchData", "restoreData",

    # UISlider documented methods and subclass override points
    "setValue", "minimumTrackImage", "setMinimumTrackImage",
    "maximumTrackImage", "setMaximumTrackImage", "thumbImage", "setThumbImage",
    "minimumValueImageRect", "maximumValueImageRect", "trackRect", "thumbRect",

    # StoreKit / In-App Purchase callbacks (Obj-C selectors / Swift method names)
    "paymentQueue:updatedTransactions:", "paymentQueueRestoreCompletedTransactionsFinished",
    "paymentQueue:restoreCompletedTransactionsFailedWithError:", "productsRequest:didReceiveResponse:",
    "request:didFailWithError:", "paymentQueue:removedTransactions:", "paymentQueue:updatedDownloads:",

    # Text input delegates
    "textFieldShouldBeginEditing", "textFieldDidBeginEditing", "textFieldShouldReturn",
    "textField(_:shouldChangeCharactersIn:replacementString:)",
    "textViewDidChange", "textViewDidBeginEditing", "textViewDidEndEditing",

    # Common focus / state restoration hooks
    "encodeRestorableState", "decodeRestorableState", "applicationFinishedRestoringState",
    "archivedValue",
    "responds", "forwardingTarget", "respondsToSelector", "forwardingTargetForSelector:",

    # SwiftUI lightweight hooks (common closure names)
    "onAppear", "onDisappear",
    # Project-specific API exemptions
    "consigneeCreate", "consigneeUpdate",
    "addRightHandleClick",
    "topModel",
    "topPageVc",
    "modelList",
    "bookTypeToItemType",
    "vocabularyArray",
    "letterArray",
}

# UINavigationController 常用方法/属性（来源：Apple Developer Documentation）
COMMON_SYSTEM_MEMBER_NAMES.update({
    # Properties
    "topViewController", "visibleViewController", "viewControllers",
    "navigationBar", "toolbar", "isNavigationBarHidden", "isToolbarHidden",
    "interactivePopGestureRecognizer", "interactiveContentPopGestureRecognizer",
    "hidesBarsOnTap", "hidesBarsOnSwipe", "hidesBarsWhenVerticallyCompact",
    "hidesBarsWhenKeyboardAppears", "barHideOnTapGestureRecognizer", "barHideOnSwipeGestureRecognizer",
    "hideShowBarDuration",

    # Swift-style method bases
    "pushViewController", "popViewController", "popToViewController", "popToRootViewController",
    "setViewControllers", "setNavigationBarHidden", "setToolbarHidden", "show", "showDetailViewController",

    # Obj-C selectors / Obj-C-style names (保守兼容)
    "pushViewController:animated:", "popViewControllerAnimated:", "popToViewController:animated:",
    "popToRootViewControllerAnimated:", "setViewControllers:animated:",
    "setNavigationBarHidden:animated:", "setToolbarHidden:animated:",
})

IOS_SYSTEM_MEMBER_NAMES = set()
IOS_SYSTEM_SYMBOLS_LOADED = False
# If enabled, allow rewriting `#import "X.h"` lines and rename corresponding header files.
# This is risky: filenames may diverge from disk unless headers are renamed accordingly.
REWRITE_IMPORTS_ALLOWED = False
# Pods / Factorys 中声明过的第三方成员名。保守处理：这些名字一律不参与方法混淆，
# 以避免继承第三方类、实现第三方 Delegate/DataSource 时把回调或重写方法改坏。
THIRD_PARTY_PROTOCOL_METHOD_NAMES = set()
THIRD_PARTY_PROTOCOL_METHODS_LOADED = False
PROJECT_PROPERTY_MEMBER_NAMES = set()
PROJECT_PROPERTY_MEMBERS_LOADED = False
PROJECT_METHOD_IGNORE_NAMES = set()
PROJECT_METHOD_IGNORE_PATTERNS = []

OBJC_PROPERTY_DECL_RE = re.compile(r"@property\b(?P<body>.*?);", re.S)
OBJC_PROPERTY_GETTER_ATTR_RE = re.compile(r"\bgetter\s*=\s*([A-Za-z_][A-Za-z0-9_]*)")
OBJC_PROPERTY_SETTER_ATTR_RE = re.compile(r"\bsetter\s*=\s*([A-Za-z_][A-Za-z0-9_]*:)")
OBJC_SYNTHESIZE_IVAR_RE = re.compile(r"@synthesize\s+[A-Za-z_][A-Za-z0-9_]*\s*=\s*_([A-Za-z_][A-Za-z0-9_]*)\s*;")
SWIFT_INTERFACE_FUNC_RE = re.compile(r"\bfunc\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(")
SWIFT_INTERFACE_PROPERTY_RE = re.compile(r"\b(?:var|let)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:")
SWIFT_PROPERTY_DECL_RE = re.compile(
    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^\n]*?\))?\s*)*"
    r"(?:(?:public|private|fileprivate|internal|open|final|weak|unowned|lazy|static|class|override|required|optional|dynamic|mutating|nonmutating|convenience|indirect)\s+)*"
    r"(?:var|let)\s+([A-Za-z_][A-Za-z0-9_]*)\b",
    re.M,
)
THIRD_PARTY_PROTOCOL_NAME_RE = re.compile(r"(?:Delegate|DataSource)\b", re.I)
SWIFT_PROTOCOL_DECL_RE = re.compile(r"\bprotocol\s+([A-Za-z_][A-Za-z0-9_]*)\b[^\{]*\{")

# ── 工具函数 ──────────────────────────────────────────────────────────────────

def short_hash(name: str, salt: str) -> str:
    """生成可复现的伪随机 ID，长度由 OBFUSCATED_HASH_LEN 控制。"""
    h = hashlib.sha256(f"{salt}{name}".encode()).hexdigest()[:OBFUSCATED_HASH_LEN]
    return h

def obfuscated_name(original: str, salt: str, nonce: int = 0, prefix: str = TYPE_OBFUSCATED_PREFIX) -> str:
    # nonce 用于极端哈希冲突时重试，保证本次映射唯一
    payload = original if nonce == 0 else f"{original}:{nonce}"
    return f"{prefix}{short_hash(payload, salt)}"

def build_unique_mapping(symbols: list, salt: str, prefix: str = TYPE_OBFUSCATED_PREFIX) -> dict:
    mapping = {}
    used_obf = set()
    for name in symbols:
        nonce = 0
        while True:
            obf = obfuscated_name(name, salt, nonce, prefix=prefix)
            if obf not in used_obf:
                mapping[name] = obf
                used_obf.add(obf)
                break
            nonce += 1
    return mapping

def should_exclude_path(path: str) -> bool:
    return any(frag in path for frag in EXCLUDE_PATH_FRAGMENTS)

def collect_swift_files(scan_dirs: list) -> list:
    return discover_files(scan_dirs, (".swift",), EXCLUDE_PATH_FRAGMENTS, skip_dir_names=EXCLUDE_DIR_NAMES)

def collect_objc_files(scan_dirs: list) -> list:
    return discover_files(scan_dirs, (".m", ".mm", ".h"), EXCLUDE_PATH_FRAGMENTS, skip_dir_names=EXCLUDE_DIR_NAMES)

def collect_source_files(scan_dirs: list) -> list:
    """收集所有可恢复源码文件，不受 RD/STS 文件名前缀限制。"""
    return discover_files(scan_dirs, SOURCE_FILE_EXTENSIONS, EXCLUDE_PATH_FRAGMENTS)

def collect_method_candidate_files(scan_dirs: list) -> list:
    """仅收集用于方法提取的候选文件：文件名以 STS 或 RD 开头，忽略 Factorys 等目录。"""
    files = discover_files(
        scan_dirs,
        METHOD_CANDIDATE_EXTENSIONS,
        EXCLUDE_PATH_FRAGMENTS,
        skip_dir_names=EXCLUDE_DIR_NAMES,
        basename_prefixes=METHOD_CANDIDATE_PREFIXES,
    )
    return prefilter_files_with_rg(files, METHOD_DECLARATION_RG_PATTERN, chunk_size=RG_CHUNK_SIZE)

def collect_apply_target_files(scan_dirs: list, enable_objc_symbols: bool) -> list:
    """收集实际执行替换的源码文件。

    定义提取仍可只看 RD/STS 前缀文件，但符号引用可能出现在任意业务源码文件中，
    因此替换阶段需要覆盖全部源码文件，否则会遗漏 String+xxx 之类的引用文件。
    """
    return discover_files(scan_dirs, SOURCE_FILE_EXTENSIONS, EXCLUDE_PATH_FRAGMENTS)

def collect_resource_strings(scan_dirs: list) -> set:
    """扫描 storyboard/xib 等资源，收集 class/outlet/selector 等字符串作为白名单。"""
    strs = set()
    pattern_attr = re.compile(r'(?:customClass|customModule|placeholder|storyboardIdentifier|reuseIdentifier|userLabel|selector)\s*=\s*"([A-Za-z_][A-Za-z0-9_:@]*)"')
    pattern_tag = re.compile(r'<[^>]+\bclass\s*=\s*"([A-Za-z_][A-Za-z0-9_]*)"')
    resource_files = discover_files(scan_dirs, ('.storyboard', '.xib', '.xml'), EXCLUDE_PATH_FRAGMENTS)
    for full in resource_files:
        try:
            text = Path(full).read_text(encoding='utf-8')
        except Exception:
            continue
        for m in pattern_attr.finditer(text):
            strs.add(m.group(1))
        for m in pattern_tag.finditer(text):
            strs.add(m.group(1))
    return strs


def _discover_third_party_protocol_roots(scan_dirs: list) -> list:
    roots = set()
    excluded_dir_names = {"Pods", ".git", ".build", "Carthage", "Tests", "readoorTests", "DerivedData", "RDObfuscateMacro"}

    search_roots = {str(Path(os.getcwd()).resolve())}
    for scan_dir in scan_dirs:
        try:
            resolved_scan_dir = Path(scan_dir).resolve()
        except Exception:
            continue
        if resolved_scan_dir.exists():
            search_roots.add(str(resolved_scan_dir))

    for search_root in sorted(search_roots):
        base_path = Path(search_root)
        if not base_path.exists():
            continue
        if base_path.name in THIRD_PARTY_PROTOCOL_ROOT_NAMES:
            roots.add(str(base_path.resolve()))
        for root, dirs, _ in os.walk(base_path):
            current_root = Path(root)
            for directory in list(dirs):
                if directory in THIRD_PARTY_PROTOCOL_ROOT_NAMES:
                    roots.add(str((current_root / directory).resolve()))
            dirs[:] = [
                directory for directory in dirs
                if directory not in excluded_dir_names and directory not in THIRD_PARTY_PROTOCOL_ROOT_NAMES
            ]

    return sorted(roots)


def _iter_protocol_source_files(root_dirs: list):
    seen = set()
    candidates = discover_files(root_dirs, (".h", ".swift"), THIRD_PARTY_PROTOCOL_EXCLUDE_PATH_FRAGMENTS)
    prefetched = prefilter_files_with_rg(candidates, PROPERTY_DECLARATION_RG_PATTERN + "|" + METHOD_DECLARATION_RG_PATTERN)
    for file_path in prefetched:
        full_path = os.path.realpath(file_path)
        if full_path in seen:
            continue
        seen.add(full_path)
        yield file_path


def _extract_swift_property_members(text: str) -> set:
    return {match.group(1) for match in SWIFT_PROPERTY_DECL_RE.finditer(text)}


def _empty_project_source_analysis() -> dict:
    return {
        "swift_symbols": [],
        "objc_symbols": [],
        "raw_direct_names": [],
        "raw_objc_selectors": [],
        "raw_swift_signatures": {},
        "property_members": [],
        "selector_literals": [],
    }


def _empty_third_party_member_analysis() -> dict:
    return {
        "member_names": [],
    }


def load_extraction_cache() -> dict:
    return _EXTRACTION_ANALYSIS_CACHE.load_state()


def save_extraction_cache():
    _EXTRACTION_ANALYSIS_CACHE.save_if_dirty()


def _build_analysis_cache_key(analysis_kind: str, path: str) -> str:
    return IncrementalAnalysisCache.build_cache_key(analysis_kind, path)


def _read_text_with_hash(path: str):
    return IncrementalAnalysisCache._read_text_with_hash(path)


def _get_cached_file_analysis(path: str, analysis_kind: str, analyzer):
    return _EXTRACTION_ANALYSIS_CACHE.get_or_compute(path, analysis_kind, analyzer)


def _analyze_project_source_text(text: str, path: str) -> dict:
    analysis = _empty_project_source_analysis()
    if not text:
        return analysis

    if path.endswith(".swift"):
        analysis["swift_symbols"] = sorted(_extract_swift_symbols_from_text(text))
        direct_names, swift_signatures = _extract_swift_methods_from_text(text)
        analysis["raw_direct_names"] = sorted(direct_names)
        analysis["raw_swift_signatures"] = swift_signatures
        analysis["property_members"] = sorted(_extract_swift_property_members(text))
        return analysis

    if path.endswith((".h", ".m", ".mm", ".pch")):
        direct_names, objc_selectors = _extract_objc_methods_from_text(text)
        analysis["objc_symbols"] = sorted(_extract_objc_symbols_from_text(text))
        analysis["raw_direct_names"] = sorted(direct_names)
        analysis["raw_objc_selectors"] = sorted(objc_selectors)
        analysis["property_members"] = sorted(_extract_objc_property_members(text))
        analysis["selector_literals"] = sorted(_collect_selector_literals_from_text(text))

    return analysis


def _analyze_third_party_member_text(text: str, path: str) -> dict:
    analysis = _empty_third_party_member_analysis()
    if not text:
        return analysis

    if path.endswith(".swift"):
        analysis["member_names"] = sorted(_extract_delegate_protocol_methods_from_swift_text(text))
    else:
        analysis["member_names"] = sorted(_extract_delegate_protocol_methods_from_objc_text(text))
    return analysis


def ensure_project_property_members_loaded(scan_dirs: list) -> set:
    global PROJECT_PROPERTY_MEMBERS_LOADED

    if PROJECT_PROPERTY_MEMBERS_LOADED:
        return PROJECT_PROPERTY_MEMBER_NAMES

    property_members = set()
    source_files = collect_apply_target_files(scan_dirs, enable_objc_symbols=True)
    property_files = prefilter_files_with_rg(source_files, PROPERTY_DECLARATION_RG_PATTERN)
    for file_path in property_files:
        analysis = _get_cached_file_analysis(file_path, PROJECT_SOURCE_ANALYSIS_KIND, _analyze_project_source_text)
        property_members.update(analysis.get("property_members", []))

    PROJECT_PROPERTY_MEMBER_NAMES.clear()
    PROJECT_PROPERTY_MEMBER_NAMES.update(property_members)
    PROJECT_PROPERTY_MEMBERS_LOADED = True
    save_extraction_cache()
    return PROJECT_PROPERTY_MEMBER_NAMES


def _protocol_name_is_delegate_like(name: str) -> bool:
    return bool(THIRD_PARTY_PROTOCOL_NAME_RE.search(name or ""))


def _extract_delegate_protocol_methods_from_objc_text(text: str) -> set:
    protected = set()
    protected.update(_extract_objc_property_members(text))

    for method_match in OBJC_METHOD_DECL_RE.finditer(text):
        declaration = method_match.group(1).strip()
        selector_parts = re.findall(r'([A-Za-z_][A-Za-z0-9_]*:)', declaration)
        if selector_parts:
            # Obj-C 带参数方法在 Swift 中实现时通常会以首段 selector 作为 base name，
            # 例如 `tencentDidNotLogin:` -> `func tencentDidNotLogin(_:)`。
            # 这里同时保护完整 selector 和 Swift 可见的 base name，
            # 避免实现第三方 Delegate/DataSource 或重写第三方类方法时被误混淆。
            protected.add("".join(selector_parts))
            protected.add(selector_parts[0][:-1])
            continue

        simple_match = re.match(r'([A-Za-z_][A-Za-z0-9_]*)', declaration)
        if simple_match:
            protected.add(simple_match.group(1))

    return protected


def _extract_delegate_protocol_methods_from_swift_text(text: str) -> set:
    protected = set(_extract_swift_property_members(text))
    for method_match in SWIFT_METHOD_DECL_RE.finditer(text):
        protected.add(method_match.group(1))

    return protected


def ensure_third_party_protocol_methods_loaded(scan_dirs: list) -> set:
    global THIRD_PARTY_PROTOCOL_METHODS_LOADED

    if THIRD_PARTY_PROTOCOL_METHODS_LOADED:
        return THIRD_PARTY_PROTOCOL_METHOD_NAMES

    # 保守策略：Pods / Factorys 里声明过的成员名全部视为受保护，
    # 这样第三方基类重写、第三方 Delegate / DataSource 实现都不会进入方法映射。
    protected = set()
    protocol_roots = _discover_third_party_protocol_roots(scan_dirs)
    for file_path in _iter_protocol_source_files(protocol_roots):
        analysis = _get_cached_file_analysis(file_path, THIRD_PARTY_MEMBER_ANALYSIS_KIND, _analyze_third_party_member_text)
        protected.update(analysis.get("member_names", []))

    THIRD_PARTY_PROTOCOL_METHOD_NAMES.clear()
    THIRD_PARTY_PROTOCOL_METHOD_NAMES.update(protected)
    THIRD_PARTY_PROTOCOL_METHODS_LOADED = True
    save_extraction_cache()
    return THIRD_PARTY_PROTOCOL_METHOD_NAMES


def _path_contains_dir_name(path: str, dir_names: tuple) -> bool:
    wanted = {name.lower() for name in dir_names}
    return any(part.lower() in wanted for part in Path(path).parts)


def should_skip_method_replacements(path: str) -> bool:
    return _path_contains_dir_name(path, METHOD_REPLACEMENT_SKIP_DIR_NAMES)


def _run_command_capture_stdout(args: list) -> str:
    try:
        completed = subprocess.run(
            args,
            capture_output=True,
            text=True,
            check=True,
        )
    except Exception:
        return ""
    return (completed.stdout or "").strip()


def _discover_ios_sdk_paths() -> list:
    sdk_paths = []

    env_sdk_root = os.environ.get("SDKROOT")
    if env_sdk_root and os.path.exists(env_sdk_root):
        sdk_paths.append(os.path.realpath(env_sdk_root))

    for sdk_name in ("iphoneos", "iphonesimulator"):
        sdk_path = _run_command_capture_stdout(["xcrun", "--sdk", sdk_name, "--show-sdk-path"])
        if sdk_path and os.path.exists(sdk_path):
            sdk_paths.append(os.path.realpath(sdk_path))

    unique_paths = []
    seen = set()
    for sdk_path in sdk_paths:
        if sdk_path in seen:
            continue
        seen.add(sdk_path)
        unique_paths.append(sdk_path)
    return unique_paths


def _load_cached_ios_system_symbols(sdk_paths: list):
    payload = load_json_file(IOS_SYSTEM_SYMBOL_CACHE_PATH, {})
    if not isinstance(payload, dict):
        return None

    cache_version = payload.get("cache_version")
    cached_sdk_paths = payload.get("sdk_paths")
    cached_symbols = payload.get("symbols")
    if cache_version != IOS_SYSTEM_SYMBOL_CACHE_VERSION or cached_sdk_paths != sdk_paths or not isinstance(cached_symbols, list):
        return None

    return set(symbol for symbol in cached_symbols if isinstance(symbol, str) and symbol)


def _save_ios_system_symbols_cache(sdk_paths: list, symbols: set):
    payload = {
        "cache_version": IOS_SYSTEM_SYMBOL_CACHE_VERSION,
        "sdk_paths": sdk_paths,
        "symbols": sorted(symbols),
    }
    try:
        save_json_file(IOS_SYSTEM_SYMBOL_CACHE_PATH, payload)
    except Exception:
        pass


def _iter_ios_sdk_symbol_files(sdk_path: str):
    seen = set()
    sdk_root = Path(sdk_path)
    for relative_dir in IOS_SYSTEM_SYMBOL_SCAN_DIRS:
        base_dir = sdk_root / relative_dir
        if not base_dir.exists():
            continue
        for root, dirs, files in os.walk(base_dir):
            dirs[:] = [directory for directory in dirs if not directory.endswith(".docc")]
            for filename in files:
                if not filename.endswith((".h", ".swiftinterface")):
                    continue
                full_path = os.path.realpath(os.path.join(root, filename))
                if full_path in seen:
                    continue
                seen.add(full_path)
                yield full_path


def _default_objc_setter_name(property_name: str) -> str:
    if property_name.startswith("is") and len(property_name) > 2 and property_name[2].isupper():
        setter_base = property_name[2:]
    else:
        setter_base = property_name[:1].upper() + property_name[1:]
    return f"set{setter_base}:"


def _extract_objc_property_members(text: str) -> set:
    members = set()
    for match in OBJC_PROPERTY_DECL_RE.finditer(text):
        body = " ".join(match.group("body").split())
        if not body:
            continue

        name_match = re.search(r"([A-Za-z_][A-Za-z0-9_]*)\s*$", body)
        if not name_match:
            continue

        property_name = name_match.group(1)
        members.add(property_name)

        getter_match = OBJC_PROPERTY_GETTER_ATTR_RE.search(body)
        if getter_match:
            members.add(getter_match.group(1))
        else:
            members.add(property_name)

        if "readonly" in body:
            continue

        setter_match = OBJC_PROPERTY_SETTER_ATTR_RE.search(body)
        if setter_match:
            members.add(setter_match.group(1))
        else:
            members.add(_default_objc_setter_name(property_name))

    for match in OBJC_SYNTHESIZE_IVAR_RE.finditer(text):
        property_name = match.group(1)
        members.add(property_name)
        members.add(_default_objc_setter_name(property_name))

    return members


def _extract_objc_sdk_members(text: str) -> set:
    members = set()
    members.update(_extract_objc_property_members(text))

    for match in OBJC_METHOD_DECL_RE.finditer(text):
        declaration = match.group(1).strip()
        selector_parts = re.findall(r'([A-Za-z_][A-Za-z0-9_]*:)', declaration)
        if selector_parts:
            members.add("".join(selector_parts))
            continue

        simple_match = re.match(r'([A-Za-z_][A-Za-z0-9_]*)', declaration)
        if simple_match:
            members.add(simple_match.group(1))

    return members


def _extract_swift_sdk_members(text: str) -> set:
    members = set()
    for match in SWIFT_INTERFACE_FUNC_RE.finditer(text):
        members.add(match.group(1))
    for match in SWIFT_INTERFACE_PROPERTY_RE.finditer(text):
        members.add(match.group(1))
    return members


def _extract_ios_system_symbols_from_sdk(sdk_path: str) -> set:
    members = set(COMMON_SYSTEM_MEMBER_NAMES)
    for file_path in _iter_ios_sdk_symbol_files(sdk_path):
        try:
            text = Path(file_path).read_text(encoding="utf-8", errors="ignore")
        except Exception:
            continue

        if file_path.endswith(".swiftinterface"):
            members.update(_extract_swift_sdk_members(text))
        else:
            members.update(_extract_objc_sdk_members(text))

    return members


def ensure_ios_system_symbols_loaded(verbose: bool = True) -> set:
    global IOS_SYSTEM_SYMBOLS_LOADED

    if IOS_SYSTEM_SYMBOLS_LOADED:
        return IOS_SYSTEM_MEMBER_NAMES

    sdk_paths = _discover_ios_sdk_paths()
    symbols = _load_cached_ios_system_symbols(sdk_paths)
    if symbols is None:
        symbols = set(COMMON_SYSTEM_MEMBER_NAMES)
        for sdk_path in sdk_paths:
            symbols.update(_extract_ios_system_symbols_from_sdk(sdk_path))
        if sdk_paths:
            _save_ios_system_symbols_cache(sdk_paths, symbols)

    IOS_SYSTEM_MEMBER_NAMES.clear()
    IOS_SYSTEM_MEMBER_NAMES.update(symbols)
    IOS_SYSTEM_SYMBOLS_LOADED = True

    if verbose:
        if sdk_paths:
            print(f"🛡️  已加载 {len(IOS_SYSTEM_MEMBER_NAMES)} 个 iOS SDK 系统方法/属性名")
        else:
            print("⚠️  未找到 iOS SDK，当前仅使用内置系统方法保护列表")

    return IOS_SYSTEM_MEMBER_NAMES

# ── 提取阶段 ─────────────────────────────────────────────────────────────────

# 匹配声明前修饰符（注解行或同行），用于过滤不应混淆的符号
UNSAFE_MODIFIERS_RE = re.compile(
    r"@objc\b|@objcMembers\b|@IBAction\b|@IBOutlet\b|@IBInspectable\b"
    r"|@NSManaged\b|@NSApplicationMain\b|@UIApplicationMain\b"
    r"|\bopen\b|\bpublic\b"
)

# 捕获类型声明：  [class|struct|enum|protocol] TypeName
DECL_RE = re.compile(
    r"(?<!\w)(?:" + "|".join(DECL_KEYWORDS) + r")\s+([A-Z][a-zA-Z0-9_]+)"
)

def build_already_obfuscated_re() -> re.Pattern:
    lengths = sorted(set(LEGACY_OBFUSCATED_HASH_LENGTHS))
    suffix = "|".join(f"[a-f0-9]{{{length}}}" for length in lengths)
    prefixes = "|".join(re.escape(prefix) for prefix in sorted(set(ALREADY_OBFUSCATED_PREFIXES), key=len, reverse=True))
    return re.compile(rf"^(?:{prefixes})(?:{suffix})$")


ALREADY_OBFUSCATED_RE = build_already_obfuscated_re()

# 方法抽取正则（Swift / Obj-C）
SWIFT_FUNC_RE = re.compile(r"^\s*(?:@[^\n]+\s*)*(?:public|private|fileprivate|internal|open|static|class|override|final|mutating|nonmutating|async|throws|rethrows|lazy|weak|unowned|convenience|required|optional|override|protocol|extension|extension\s+|actor|struct|enum|actor\s+)?\s*func\s+([a-zA-Z_][a-zA-Z0-9_]+)")
SWIFT_METHOD_DECL_RE = re.compile(r"\bfunc\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(")
SWIFT_PARAM_LABEL_RE = re.compile(
    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_.]*(?:\([^)]*\))?\s+)*"
    r"(?:(?:inout|borrowing|consuming|isolated|__shared|__owned|sending)\s+)*"
    r"(?P<label>_|[A-Za-z_][A-Za-z0-9_]*)(?:\s+(?P<local>[A-Za-z_][A-Za-z0-9_]*))?\s*$"
)
SWIFT_ARGUMENT_LABEL_RE = re.compile(r"^\s*(?P<label>_|[A-Za-z_][A-Za-z0-9_]*)\s*$")
SWIFT_SIGNATURE_KEY_RE = re.compile(r"^([A-Za-z_][A-Za-z0-9_]*)\((.*)\)$")
OBJC_SELECTOR_RE = re.compile(r"@selector\\s*\\(\\s*([A-Za-z0-9_:@]+)\\s*\\)")
OBJC_STRING_SELECTOR_RE = re.compile(r'@"([A-Za-z_][A-Za-z0-9_:@]*)"')
OBJC_METHOD_DECL_RE = re.compile(r"[+-]\s*\([^)]*\)\s*([^{;]+)")
# 方法名前缀排除（例如私有下划线或第三方前缀）
METHOD_PREFIX_EXCLUDE = ("_", "qmui")

# 常见系统/Delegate 方法名排除模式（不应当混淆）
METHOD_EXCLUDE_PATTERNS = [
    # UIKit / App lifecycle
    r'(?i)viewDidLoad', r'(?i)viewWillAppear', r'(?i)viewDidAppear', r'(?i)viewWillDisappear', r'(?i)viewDidDisappear',
    r'(?i)viewWillLayoutSubviews', r'(?i)viewDidLayoutSubviews', r'(?i)didReceiveMemoryWarning', r'(?i)traitCollectionDidChange',
    # Init / dealloc / coder
    r'(?i)^init$', r'(?i)^init:$', r'(?i)^initWith', r'(?i)^dealloc$', r'(?i)awakeFromNib', r'(?i)initWithCoder', r'(?i)encodeWithCoder',
    # Table/collection/scroll delegate datasource
    r'(?i)tableView', r'(?i)collectionView', r'(?i)scrollView', r'(?i)numberOfSectionsInTableView', r'(?i)numberOfRowsInSection',
    r'(?i)cellForRowAtIndexPath', r'(?i)didSelectRowAtIndexPath', r'(?i)canEditRowAtIndexPath', r'(?i)heightForRowAtIndexPath',
    r'(?i)willDisplayCell', r'(?i)reloadData', r'(?i)scrollViewDid',
    # UICollectionViewLayout / UIView constraint hooks
    r'(?i)^shouldInvalidateLayout(?:$|:|\()', r'(?i)^layoutAttributesFor(?:$|[A-Z]|:|\()',
    r'(?i)^invalidationContext(?:$|[A-Z]|:|\()', r'(?i)^targetContentOffset(?:$|[A-Z]|:|\()',
    r'(?i)^addConstraint(?:s)?(?:$|:|\()',
    # UIPickerView delegate / datasource
    r'(?i)^pickerView(?:$|:|\()', r'(?i)^numberOfComponentsInPickerView(?:$|:|\()', r'(?i)^numberOfComponents$',
    # UITextField / UITextView delegate
    r'(?i)^textField(?:$|:|\()', r'(?i)^textFieldShould', r'(?i)^textFieldDid', r'(?i)^textFieldWill',
    r'(?i)^textView(?:$|:|\()', r'(?i)^textViewShould', r'(?i)^textViewDid', r'(?i)^textViewWill',
    # WebKit delegate / handler
    r'(?i)^webView(?:$|:|\()', r'(?i)^userContentController(?:$|:|\()',
    # Common Swift datasource base names
    r'(?i)^numberOfSections$',
    # Touches / gestures
    r'(?i)touchesBegan', r'(?i)touchesEnded', r'(?i)touchesMoved', r'(?i)gestureRecognizer',
    # App delegate / URL handling
    r'(?i)application:', r'(?i)didFinishLaunchingWithOptions', r'(?i)applicationWillResignActive', r'(?i)applicationDidEnterBackground',
    r'(?i)applicationWillEnterForeground', r'(?i)applicationDidBecomeActive', r'(?i)applicationWillTerminate', r'(?i)application:openURL',
    # Drawing / layout
    r'(?i)layoutSubviews', r'(?i)sizeThatFits', r'(?i)drawRect', r'(?i)drawRect:',
    r'(?i)^systemLayoutSizeFitting(?:Size)?(?:$|:|\()',
    # Obj-C runtime / selector helpers
    r'(?i)^responds$', r'(?i)^forwardingTarget$',
    r'(?i)respondsToSelector', r'(?i)performSelector', r'(?i)NSSelectorFromString', r'(?i)forwardingTargetForSelector',
    # Swift common lifecycle
    r'(?i)deinit', r'(?i)awakeFromNib', r'(?i)prepareForSegue', r'(?i)encodeRestorableStateWithCoder', r'(?i)decodeRestorableStateWithCoder',
    r'(?i)^archivedValue$',
    # common prefixes to avoid
    r'(?i)^set[A-Z]',

    # Explicitly exclude Obj-C style setter selectors like setFoo: or setFoo:withBar:
    r'(?i)^set[A-Z][A-Za-z0-9_]*:',

    # Third-party layout DSLs (SnapKit / Masonry) must never be obfuscated
    r'(?i)^(?:make|remake|update)Constraints$',
    r'(?i)^(?:mas_)?(?:make|remake|update)Constraints:$',

    # Layout / view hierarchy helpers
    r'(?i)didMoveToSuperview', r'(?i)didMoveToWindow', r'(?i)willMoveToSuperview', r'(?i)willMoveToWindow',
    r'(?i)^setNeedsLayout$', r'(?i)^setNeedsDisplay$', r'(?i)^layoutIfNeeded$',
    r'(?i)^addSubview$', r'(?i)^removeFromSuperview$', r'(?i)^bringSubviewToFront$', r'(?i)^sendSubviewToBack$', r'(?i)^insertSubview',

    # Navigation / Tab controller hooks
    r'(?i)navigationController', r'(?i)tabBarController',

    # More scroll / gesture delegate methods
    r'(?i)scrollViewDidScroll', r'(?i)scrollViewDidEndDragging', r'(?i)scrollViewWillBeginDragging',
    r'(?i)gestureRecognizerShouldBegin',

    # Scene / App lifecycle (SceneDelegate / AppDelegate)
    r'(?i)^sceneWillEnterForeground', r'(?i)^sceneDidEnterBackground', r'(?i)^sceneWillResignActive', r'(?i)^sceneDidBecomeActive',
    r'(?i)^application:didRegisterForRemoteNotificationsWithDeviceToken', r'(?i)^application:didFailToRegisterForRemoteNotificationsWithError',
    r'(?i)^application:didReceiveRemoteNotification',

    # UserNotifications / UNUserNotificationCenter callbacks
    r'(?i)^userNotificationCenter:',

    # SwiftUI lifecycle closures
    r'(?i)^onAppear$', r'(?i)^onDisappear$',

    # Additional common prefixes and selectors collected from Apple docs
    r'(?i)^viewSafeAreaInsetsDidChange$',
    r'(?i)^gestureRecognizer:',
    r'(?i)^tableView:', r'(?i)^collectionView:', r'(?i)^webView:',
    r'(?i)^scrollView', r'(?i)^didSelectRowAt', r'(?i)^cellForRowAt',
    r'(?i)^numberOfRowsInSection', r'(?i)^numberOfItemsInSection',
    r'(?i)^application:open:', r'(?i)^scene', r'(?i)^userNotificationCenter:',

    # WKWebView documented high-risk API surface
    r'(?i)^loadHTMLString(?:$|:|\()', r'(?i)^loadFileURL(?:$|:|\()', r'(?i)^loadFileRequest(?:$|:|\()',
    r'(?i)^loadSimulatedRequest(?:$|:|\()', r'(?i)^reloadFromOrigin(?:$|:|\()', r'(?i)^stopLoading(?:$|:|\()',
    r'(?i)^goBack(?:$|:|\()', r'(?i)^goForward(?:$|:|\()', r'(?i)^go\s*\((?:$|:|\()',
    r'(?i)^evaluateJavaScript(?:$|:|\()', r'(?i)^callAsyncJavaScript(?:$|:|\()',
    r'(?i)^takeSnapshot(?:$|:|\()', r'(?i)^createPDF(?:$|:|\()', r'(?i)^createWebArchiveData(?:$|:|\()',
    r'(?i)^startDownload(?:$|:|\()', r'(?i)^resumeDownload(?:$|:|\()', r'(?i)^setMagnification(?:$|:|\()',
    r'(?i)^pauseAllMediaPlayback(?:$|:|\()', r'(?i)^requestMediaPlaybackState(?:$|:|\()',
    r'(?i)^setAllMediaPlaybackSuspended(?:$|:|\()', r'(?i)^closeAllMediaPresentations(?:$|:|\()',
    r'(?i)^setCameraCaptureState(?:$|:|\()', r'(?i)^setMicrophoneCaptureState(?:$|:|\()',
    r'(?i)^find(?:$|:|\()', r'(?i)^setMinimumViewportInset(?:$|:|\()',
    r'(?i)^fetchData(?:$|:|\()', r'(?i)^restoreData(?:$|:|\()',

    # UISlider documented override points and public API
    r'(?i)^minimumTrackImage(?:$|:|\()', r'(?i)^setMinimumTrackImage(?:$|:|\()',
    r'(?i)^maximumTrackImage(?:$|:|\()', r'(?i)^setMaximumTrackImage(?:$|:|\()',
    r'(?i)^thumbImage(?:$|:|\()', r'(?i)^setThumbImage(?:$|:|\()',
    r'(?i)^minimumValueImageRect(?:$|:|\()', r'(?i)^maximumValueImageRect(?:$|:|\()',
    r'(?i)^trackRect(?:$|:|\()', r'(?i)^thumbRect(?:$|:|\()',

    # StoreKit / In-App Purchase common callbacks and prefixes
    r'(?i)^paymentQueue', r'(?i)^productsRequest', r'(?i)^productsResponse',
    r'(?i)^restoreCompletedTransactions', r'(?i)^refreshReceipt', r'(?i)^SKStoreProductViewController',
]

METHOD_EXCLUDE_RE = [re.compile(p) for p in METHOD_EXCLUDE_PATTERNS]

# 支持从仓库根目录加载自定义忽略模式（每行一条正则或文字）
def _is_literal_method_ignore_entry(value: str) -> bool:
    return bool(value) and all(char.isalnum() or char in '_:' for char in value)


def _load_project_method_ignore_entries() -> tuple:
    names = set()
    patterns = []
    try:
        extra_path = os.path.join(os.getcwd(), PROJECT_METHOD_IGNORE_FILE_PATH)
        if os.path.exists(extra_path):
            with open(extra_path, 'r', encoding='utf-8') as f:
                for ln in f:
                    s = ln.strip()
                    if not s or s.startswith('#'):
                        continue
                    if _is_literal_method_ignore_entry(s):
                        names.add(s)
                        continue
                    try:
                        patterns.append(re.compile(s))
                    except Exception:
                        pass
    except Exception:
        pass
    return names, patterns


def refresh_project_method_ignore_entries() -> set:
    global PROJECT_METHOD_IGNORE_NAMES, PROJECT_METHOD_IGNORE_PATTERNS

    names, patterns = _load_project_method_ignore_entries()
    PROJECT_METHOD_IGNORE_NAMES.clear()
    PROJECT_METHOD_IGNORE_NAMES.update(names)
    PROJECT_METHOD_IGNORE_PATTERNS = patterns
    return PROJECT_METHOD_IGNORE_NAMES


refresh_project_method_ignore_entries()

def is_system_method(name: str) -> bool:
    if (
        name in COMMON_SYSTEM_MEMBER_NAMES or
        name in IOS_SYSTEM_MEMBER_NAMES or
        name in THIRD_PARTY_PROTOCOL_METHOD_NAMES or
        name in PROJECT_PROPERTY_MEMBER_NAMES or
        name in PROJECT_METHOD_IGNORE_NAMES
    ):
        return True

    # 兼容 Obj-C selector，按分段判断系统 setter/getter 等场景
    if ':' in name:
        selector_parts = split_objc_selector(name)
        if selector_parts:
            for selector_part in selector_parts:
                part_name = selector_part[:-1]
                if (
                    selector_part in IOS_SYSTEM_MEMBER_NAMES or
                    selector_part in THIRD_PARTY_PROTOCOL_METHOD_NAMES or
                    selector_part in PROJECT_PROPERTY_MEMBER_NAMES or
                    selector_part in PROJECT_METHOD_IGNORE_NAMES or
                    part_name in COMMON_SYSTEM_MEMBER_NAMES or
                    part_name in IOS_SYSTEM_MEMBER_NAMES or
                    part_name in THIRD_PARTY_PROTOCOL_METHOD_NAMES or
                    part_name in PROJECT_PROPERTY_MEMBER_NAMES or
                    part_name in PROJECT_METHOD_IGNORE_NAMES
                ):
                    return True

    for rx in METHOD_EXCLUDE_RE:
        if rx.search(name):
            return True
    for rx in PROJECT_METHOD_IGNORE_PATTERNS:
        if rx.search(name):
            return True
    return False

def is_safe_to_rename_method(name: str, preceding_lines: str) -> bool:
    # 方法名级别的安全检查（与类型类似，但允许小写开头）
    if ALREADY_OBFUSCATED_RE.match(name):
        return False
    if name in SYMBOL_WHITELIST:
        return False
    if name in RESERVED_IDENTIFIERS:
        return False
    if name.startswith(SYMBOL_PREFIX_WHITELIST):
        return False
    if UNSAFE_MODIFIERS_RE.search(preceding_lines):
        return False
    # 避免混淆 override / dynamic / protocol 实现
    if re.search(r"\\boverride\\b|\\bdynamic\\b", preceding_lines):
        return False
    return True

def _find_matching_delimiter(text: str, start: int, open_char: str, close_char: str) -> int:
    depth = 1
    index = start + 1
    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('"', "'"):
            index = _skip_quoted_text(text, index)
            continue
        if char == open_char:
            depth += 1
        elif char == close_char:
            depth -= 1
            if depth == 0:
                return index
        index += 1
    return -1


def _find_top_level_char(text: str, target: str, track_angles: bool = False) -> int:
    paren_depth = 0
    brace_depth = 0
    bracket_depth = 0
    angle_depth = 0
    index = 0

    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('"', "'"):
            index = _skip_quoted_text(text, index)
            continue

        if char == '(':
            paren_depth += 1
        elif char == ')' and paren_depth > 0:
            paren_depth -= 1
        elif char == '{':
            brace_depth += 1
        elif char == '}' and brace_depth > 0:
            brace_depth -= 1
        elif char == '[':
            bracket_depth += 1
        elif char == ']' and bracket_depth > 0:
            bracket_depth -= 1
        elif track_angles and char == '<':
            angle_depth += 1
        elif track_angles and char == '>' and angle_depth > 0:
            angle_depth -= 1
        elif char == target and paren_depth == 0 and brace_depth == 0 and bracket_depth == 0 and angle_depth == 0:
            return index

        index += 1

    return -1


def _split_top_level_segments(text: str, separator: str = ',', track_angles: bool = False) -> list:
    segments = []
    start = 0
    paren_depth = 0
    brace_depth = 0
    bracket_depth = 0
    angle_depth = 0
    index = 0

    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('"', "'"):
            index = _skip_quoted_text(text, index)
            continue

        if char == '(':
            paren_depth += 1
        elif char == ')' and paren_depth > 0:
            paren_depth -= 1
        elif char == '{':
            brace_depth += 1
        elif char == '}' and brace_depth > 0:
            brace_depth -= 1
        elif char == '[':
            bracket_depth += 1
        elif char == ']' and bracket_depth > 0:
            bracket_depth -= 1
        elif track_angles and char == '<':
            angle_depth += 1
        elif track_angles and char == '>' and angle_depth > 0:
            angle_depth -= 1
        elif char == separator and paren_depth == 0 and brace_depth == 0 and bracket_depth == 0 and angle_depth == 0:
            segments.append((text[start:index], start, index))
            start = index + 1

        index += 1

    segments.append((text[start:], start, len(text)))
    return segments


def _find_previous_identifier(text: str, start: int):
    index = start - 1
    while index >= 0 and text[index].isspace():
        index -= 1
    end = index + 1
    while index >= 0 and (text[index].isalnum() or text[index] == '_'):
        index -= 1
    if end <= index + 1:
        return None
    return text[index + 1:end]


def _serialize_swift_params(params: list) -> list:
    return [
        {
            "label": param["label"],
            "has_default": param["has_default"],
            "allows_trailing_closure": bool(param.get("allows_trailing_closure", False)),
        }
        for param in params
    ]


def _build_swift_signature_key(name: str, params: list) -> str:
    labels = []
    for param in params:
        labels.append(f"{param['label']}:")
    return f"{name}({''.join(labels)})"


def _split_swift_signature_key(signature_key: str):
    match = SWIFT_SIGNATURE_KEY_RE.match(signature_key)
    if not match:
        return None, None
    return match.group(1), match.group(2)


def _swift_param_type_allows_trailing_closure(type_text: str) -> bool:
    return "->" in type_text


def _parse_swift_decl_parameters(params_text: str):
    params = []
    for segment, start, _ in _split_top_level_segments(params_text, separator=',', track_angles=True):
        if not segment.strip():
            continue

        colon_index = _find_top_level_char(segment, ':', track_angles=True)
        if colon_index == -1:
            return None

        prefix = segment[:colon_index]
        match = SWIFT_PARAM_LABEL_RE.match(prefix)
        if not match:
            return None

        label = match.group("label")
        local_name = match.group("local")
        label_span = None
        local_span = None
        if label != "_":
            label_span = (start + match.start("label"), start + match.end("label"))
        if local_name:
            local_span = (start + match.start("local"), start + match.end("local"))

        type_and_default = segment[colon_index + 1:]
        default_index = _find_top_level_char(type_and_default, '=', track_angles=True)
        has_default = default_index != -1
        type_text = type_and_default if default_index == -1 else type_and_default[:default_index]
        params.append({
            "label": label,
            "local_name": local_name,
            "has_default": has_default,
            "allows_trailing_closure": _swift_param_type_allows_trailing_closure(type_text),
            "span": label_span,
            "local_span": local_span,
        })

    return params


def _swift_runtime_param_name(param: dict):
    local_name = param.get("local_name")
    if local_name:
        return local_name

    label = param.get("label")
    if label and label != "_":
        return label

    return None


def _find_swift_decl_body_start(text: str, index: int):
    paren_depth = 0
    bracket_depth = 0
    angle_depth = 0

    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('\"', "'"):
            index = _skip_quoted_text(text, index)
            continue

        if char == '(':
            paren_depth += 1
        elif char == ')' and paren_depth > 0:
            paren_depth -= 1
        elif char == '[':
            bracket_depth += 1
        elif char == ']' and bracket_depth > 0:
            bracket_depth -= 1
        elif char == '<':
            angle_depth += 1
        elif char == '>' and angle_depth > 0:
            angle_depth -= 1
        elif char == '{' and paren_depth == 0 and bracket_depth == 0 and angle_depth == 0:
            return index
        elif char == ';' and paren_depth == 0 and bracket_depth == 0 and angle_depth == 0:
            return None

        index += 1

    return None


def _collect_swift_local_param_scopes(text: str):
    scopes = []

    for match in SWIFT_METHOD_DECL_RE.finditer(text):
        open_paren = match.end() - 1
        close_paren = _find_matching_delimiter(text, open_paren, '(', ')')
        if close_paren == -1:
            continue

        params = _parse_swift_decl_parameters(text[open_paren + 1:close_paren])
        if params is None:
            continue

        local_names = {
            runtime_name
            for runtime_name in (_swift_runtime_param_name(param) for param in params)
            if runtime_name
        }
        if not local_names:
            continue

        body_start = _find_swift_decl_body_start(text, close_paren + 1)
        if body_start is None:
            continue

        body_end = _find_matching_delimiter(text, body_start, '{', '}')
        if body_end == -1:
            continue

        scopes.append((body_start + 1, body_end, local_names))

    return scopes


def _swift_has_member_receiver(text: str, identifier_start: int) -> bool:
    dot_index = identifier_start - 1
    while dot_index >= 0 and text[dot_index].isspace():
        dot_index -= 1

    if dot_index < 0 or text[dot_index] != '.':
        return False

    receiver_index = dot_index - 1
    while receiver_index >= 0 and text[receiver_index].isspace():
        receiver_index -= 1

    while receiver_index >= 0 and text[receiver_index] in ('?', '!'):
        receiver_index -= 1
        while receiver_index >= 0 and text[receiver_index].isspace():
            receiver_index -= 1

    if receiver_index < 0:
        return False

    receiver_char = text[receiver_index]
    return receiver_char.isalnum() or receiver_char == '_' or receiver_char in (')', ']', '}')


def _swift_is_shadowed_local_param(text: str, identifier_start: int, identifier: str, local_param_scopes: list) -> bool:
    if _swift_has_member_receiver(text, identifier_start):
        return False

    for scope_start, scope_end, local_names in local_param_scopes:
        if scope_start <= identifier_start < scope_end and identifier in local_names:
            return True

    return False


def _extract_swift_methods_from_text(text: str) -> tuple:
    direct_names = set()
    swift_signatures = {}

    for match in SWIFT_METHOD_DECL_RE.finditer(text):
        name = match.group(1)
        if name.startswith(METHOD_PREFIX_EXCLUDE):
            continue

        pos = match.start()
        line_index = text[:pos].count('\n')
        ctx_start = max(0, line_index - 5)
        ctx_lines = text.splitlines()[ctx_start:line_index + 1]
        ctx = "\n".join(ctx_lines)
        if not is_safe_to_rename_method(name, ctx):
            continue

        direct_names.add(name)
        open_paren = match.end() - 1
        close_paren = _find_matching_delimiter(text, open_paren, '(', ')')
        if close_paren == -1:
            continue

        params = _parse_swift_decl_parameters(text[open_paren + 1:close_paren])
        if params is None:
            continue

        if any(param["label"] != "_" for param in params):
            signature_key = _build_swift_signature_key(name, params)
            swift_signatures[signature_key] = {
                "kind": "swift_signature",
                "params": _serialize_swift_params(params),
            }

    return direct_names, swift_signatures


def _extract_objc_methods_from_text(text: str) -> tuple:
    direct_names = set()
    objc_selectors = set()

    for match in OBJC_METHOD_DECL_RE.finditer(text):
        declaration = match.group(1).strip()
        selector_parts = re.findall(r'([A-Za-z_][A-Za-z0-9_]*:)', declaration)
        if selector_parts:
            selector_name = ''.join(selector_parts)
        else:
            simple_match = re.match(r'([A-Za-z_][A-Za-z0-9_]*)', declaration)
            if not simple_match:
                continue
            selector_name = simple_match.group(1)

        pos = match.start()
        line_index = text[:pos].count('\n')
        ctx_start = max(0, line_index - 5)
        ctx_lines = text.splitlines()[ctx_start:line_index + 1]
        ctx = "\n".join(ctx_lines)
        if selector_name.startswith(METHOD_PREFIX_EXCLUDE):
            continue
        if not is_safe_to_rename_method(selector_name, ctx):
            continue
        if ':' in selector_name:
            objc_selectors.add(selector_name)
        else:
            direct_names.add(selector_name)

    return direct_names, objc_selectors


def _extract_objc_zero_arg_method_names_from_text(text: str) -> set:
    names = set()
    for match in OBJC_METHOD_DECL_RE.finditer(text):
        declaration = match.group(1).strip()
        if ':' in declaration:
            continue

        simple_match = re.match(r'([A-Za-z_][A-Za-z0-9_]*)', declaration)
        if simple_match:
            names.add(simple_match.group(1))
    return names


def _extract_objc_dot_member_accesses_from_text(text: str) -> set:
    names = set()
    index = 0

    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('"', "'"):
            index = _skip_quoted_text(text, index)
            continue
        if char != '.':
            index += 1
            continue

        prev_index = index - 1
        while prev_index >= 0 and text[prev_index].isspace():
            prev_index -= 1
        if prev_index >= 0 and text[prev_index].isdigit():
            index += 1
            continue

        index += 1
        while index < len(text) and text[index].isspace():
            index += 1

        start = index
        if start >= len(text) or not (text[start].isalpha() or text[start] == '_'):
            continue

        index += 1
        while index < len(text) and (text[index].isalnum() or text[index] == '_'):
            index += 1
        names.add(text[start:index])

    return names


def _should_auto_ignore_objc_direct_method(name: str) -> bool:
    if not name:
        return False
    if ALREADY_OBFUSCATED_RE.match(name):
        return False
    if name in SYMBOL_WHITELIST:
        return False
    if name in RESERVED_IDENTIFIERS:
        return False
    if name.startswith(SYMBOL_PREFIX_WHITELIST):
        return False
    if (
        name in COMMON_SYSTEM_MEMBER_NAMES or
        name in IOS_SYSTEM_MEMBER_NAMES or
        name in THIRD_PARTY_PROTOCOL_METHOD_NAMES or
        name in PROJECT_PROPERTY_MEMBER_NAMES
    ):
        return False
    for rx in METHOD_EXCLUDE_RE:
        if rx.search(name):
            return False
    return True


def _build_auto_detected_method_ignore_block(names: set) -> str:
    lines = [
        AUTO_DETECTED_METHOD_IGNORE_BEGIN,
        "# Auto-generated: Obj-C zero-arg methods that are referenced with dot syntax.",
        "# These names are excluded from direct-method obfuscation to avoid half-rewritten call sites.",
    ]
    lines.extend(sorted(names))
    lines.append(AUTO_DETECTED_METHOD_IGNORE_END)
    return "\n".join(lines)


def _sync_auto_detected_method_ignore_file(detected_names: set) -> bool:
    path = Path(os.getcwd()) / PROJECT_METHOD_IGNORE_FILE_PATH
    if not detected_names and not path.exists():
        return False

    try:
        existing_text = path.read_text(encoding="utf-8") if path.exists() else ""
    except Exception:
        existing_text = ""

    block = _build_auto_detected_method_ignore_block(detected_names)
    begin_marker = AUTO_DETECTED_METHOD_IGNORE_BEGIN
    end_marker = AUTO_DETECTED_METHOD_IGNORE_END
    begin_index = existing_text.find(begin_marker)
    end_index = existing_text.find(end_marker)

    if begin_index != -1 and end_index != -1 and end_index > begin_index:
        end_index += len(end_marker)
        prefix = existing_text[:begin_index].rstrip()
        suffix = existing_text[end_index:].strip()
        parts = []
        if prefix:
            parts.append(prefix)
        parts.append(block)
        if suffix:
            parts.append(suffix)
        new_text = "\n\n".join(parts).rstrip() + "\n"
    else:
        stripped_existing = existing_text.rstrip()
        parts = []
        if stripped_existing:
            parts.append(stripped_existing)
        parts.append(block)
        new_text = "\n\n".join(parts).rstrip() + "\n"

    if new_text == existing_text:
        return False

    atomic_write_text(str(path), new_text, encoding="utf-8")
    return True


def _load_direct_method_aliases_from_map_files() -> dict:
    aliases = {}
    candidate_paths = []

    default_method_map = Path(METHOD_MAP_OUTPUT_PATH)
    if default_method_map.exists():
        candidate_paths.append(default_method_map)

    map_dir = Path("obfuscation_maps")
    if map_dir.exists():
        candidate_paths.extend(sorted(map_dir.glob("method_map*.json")))

    seen_paths = set()
    for candidate_path in candidate_paths:
        resolved_path = str(candidate_path.resolve())
        if resolved_path in seen_paths:
            continue
        seen_paths.add(resolved_path)

        try:
            payload = json.loads(candidate_path.read_text(encoding="utf-8"))
        except Exception:
            continue
        if not isinstance(payload, dict):
            continue

        for original_name, obfuscated_name in payload.items():
            if not isinstance(original_name, str) or not isinstance(obfuscated_name, str):
                continue
            if ':' in original_name:
                continue
            aliases.setdefault(original_name, set()).add(obfuscated_name)

    return aliases


def sync_detected_objc_dot_syntax_method_ignores(scan_dirs: list) -> tuple:
    objc_files = collect_objc_files(scan_dirs)
    declaration_files = prefilter_files_with_rg(objc_files, METHOD_DECLARATION_RG_PATTERN, chunk_size=RG_CHUNK_SIZE)
    dot_access_files = prefilter_files_with_rg(objc_files, OBJC_DOT_SYNTAX_MEMBER_RG_PATTERN, chunk_size=RG_CHUNK_SIZE)

    zero_arg_method_names = set()
    for file_path in declaration_files:
        try:
            text = Path(file_path).read_text(encoding="utf-8", errors="ignore")
        except Exception:
            continue
        zero_arg_method_names.update(_extract_objc_zero_arg_method_names_from_text(text))

    dot_access_names = set()
    for file_path in dot_access_files:
        try:
            text = Path(file_path).read_text(encoding="utf-8", errors="ignore")
        except Exception:
            continue
        dot_access_names.update(_extract_objc_dot_member_accesses_from_text(text))

    detected_names = {
        name for name in zero_arg_method_names & dot_access_names
        if _should_auto_ignore_objc_direct_method(name)
    }

    direct_method_aliases = _load_direct_method_aliases_from_map_files()
    for original_name, obfuscated_names in direct_method_aliases.items():
        if original_name not in dot_access_names:
            continue
        if not _should_auto_ignore_objc_direct_method(original_name):
            continue
        if original_name in zero_arg_method_names or zero_arg_method_names.intersection(obfuscated_names):
            detected_names.add(original_name)

    file_updated = _sync_auto_detected_method_ignore_file(detected_names)
    refresh_project_method_ignore_entries()
    return detected_names, file_updated


def _enumerate_swift_call_shapes(params: list) -> set:
    shapes = set()

    def dfs(index: int, labels: list):
        if index == len(params):
            shapes.add(tuple(labels))
            return

        param = params[index]
        if param.get("has_default", False):
            dfs(index + 1, labels)

        label = param.get("label")
        if isinstance(label, str):
            labels.append(label)
            dfs(index + 1, labels)
            labels.pop()

    dfs(0, [])
    return shapes


def _find_unsafe_swift_signature_bases(signature_mapping: dict) -> set:
    grouped = {}
    for signature_key, meta in signature_mapping.items():
        base_name, _ = _split_swift_signature_key(signature_key)
        if not base_name or not isinstance(meta, dict):
            continue
        params = meta.get("params", [])
        if not isinstance(params, list):
            continue
        grouped.setdefault(base_name, []).append((signature_key, params))

    unsafe_bases = set()
    for base_name, entries in grouped.items():
        seen_shapes = {}
        for signature_key, params in entries:
            for shape in _enumerate_swift_call_shapes(params):
                previous_signature = seen_shapes.get(shape)
                if previous_signature and previous_signature != signature_key:
                    unsafe_bases.add(base_name)
                    break
                seen_shapes[shape] = signature_key
            if base_name in unsafe_bases:
                break
    return unsafe_bases


def _drop_unsafe_generated_swift_signature_entries(method_mapping: dict):
    swift_signature_entries = {
        signature_key: meta
        for signature_key, meta in method_mapping.items()
        if isinstance(meta, dict) and meta.get("kind") == "swift_signature"
    }
    unsafe_bases = _find_unsafe_swift_signature_bases(swift_signature_entries)
    if not unsafe_bases:
        return method_mapping, unsafe_bases, []

    filtered_mapping = {}
    dropped_signatures = []
    for key, value in method_mapping.items():
        if key in swift_signature_entries:
            base_name, _ = _split_swift_signature_key(key)
            if base_name in unsafe_bases:
                dropped_signatures.append(key)
                continue
        filtered_mapping[key] = value
    return filtered_mapping, unsafe_bases, dropped_signatures


def _drop_unsafe_loaded_swift_signature_entries(swift_signature_mapping: dict):
    unsafe_bases = _find_unsafe_swift_signature_bases(swift_signature_mapping)
    if not unsafe_bases:
        return swift_signature_mapping, unsafe_bases, []

    filtered_mapping = {}
    dropped_signatures = []
    for signature_key, meta in swift_signature_mapping.items():
        if meta.get("base_name") in unsafe_bases:
            dropped_signatures.append(signature_key)
            continue
        filtered_mapping[signature_key] = meta
    return filtered_mapping, unsafe_bases, dropped_signatures


def extract_methods_from_file(path: str) -> dict:
    analysis = _get_cached_file_analysis(path, PROJECT_SOURCE_ANALYSIS_KIND, _analyze_project_source_text)
    return {
        "direct_names": set(analysis.get("raw_direct_names", [])),
        "objc_selectors": set(analysis.get("raw_objc_selectors", [])),
        "swift_signatures": dict(analysis.get("raw_swift_signatures", {})),
    }

def extract_all_methods(files: list, salt: str) -> dict:
    direct_methods = set()
    objc_selectors = set()
    for f in files:
        method_data = extract_methods_from_file(f)
        direct_methods.update(method_data["direct_names"])
        objc_selectors.update(method_data["objc_selectors"])

    direct_candidates = [
        name for name in sorted(direct_methods)
        if name and not ALREADY_OBFUSCATED_RE.match(name) and name not in SYMBOL_WHITELIST and not is_system_method(name)
    ]
    selector_candidates = [
        name for name in sorted(objc_selectors)
        if name and not ALREADY_OBFUSCATED_RE.match(name) and name not in SYMBOL_WHITELIST and not is_system_method(name)
    ]

    method_mapping = {}
    method_mapping.update(build_unique_mapping(direct_candidates, salt, prefix=METHOD_OBFUSCATED_PREFIX))
    method_mapping.update(build_unique_mapping(selector_candidates, salt, prefix=METHOD_OBFUSCATED_PREFIX))

    return method_mapping

def is_safe_to_rename(name: str, preceding_lines: str) -> bool:
    """判断一个符号是否可以安全重命名"""
    if ALREADY_OBFUSCATED_RE.match(name):
        return False
    if name in SYMBOL_WHITELIST:
        return False
    if name in RESERVED_IDENTIFIERS:
        return False
    if name.startswith(SYMBOL_PREFIX_WHITELIST):
        return False
    # 如果前几行有 @objc / public / open 等修饰符，跳过
    if UNSAFE_MODIFIERS_RE.search(preceding_lines):
        return False
    return True


def _extract_swift_symbols_from_text(text: str) -> set:
    lines = text.splitlines()
    symbols = set()
    for index, line in enumerate(lines):
        for match in DECL_RE.finditer(line):
            name = match.group(1)
            ctx_start = max(0, index - 5)
            ctx = "\n".join(lines[ctx_start:index + 1])
            if is_safe_to_rename(name, ctx):
                symbols.add(name)
    return symbols

def extract_symbols_from_file(path: str) -> set:
    analysis = _get_cached_file_analysis(path, PROJECT_SOURCE_ANALYSIS_KIND, _analyze_project_source_text)
    return set(analysis.get("swift_symbols", []))

def extract_all_symbols(files: list, salt: str) -> dict:
    """返回 {原始名: 混淆名} 映射"""
    all_symbols = set()
    candidate_files = prefilter_files_with_rg(files, TYPE_DECLARATION_RG_PATTERN)
    for f in candidate_files:
        all_symbols.update(extract_symbols_from_file(f))

    # 之前这里会根据 `SWIFT_SYMBOL_PREFIXES` 仅保留特定前缀的符号，
    # 这会遗漏许多项目中未以特定前缀命名的业务类型。改为不过滤，
    # 直接使用提取到的符号集合，后续通过白名单与修饰符检测保护不应混淆的符号。
    filtered = set(all_symbols)
    return build_unique_mapping(sorted(filtered), salt, prefix=TYPE_OBFUSCATED_PREFIX)

# ── Obj-C 支持 ───────────────────────────────────────────────────────────────

OBJC_INTERFACE_RE = re.compile(r"@interface\s+([A-Za-z_][A-Za-z0-9_]+)")
OBJC_IMPLEMENTATION_RE = re.compile(r"@implementation\s+([A-Za-z_][A-Za-z0-9_]+)")
OBJC_PROTOCOL_RE = re.compile(r"@protocol\s+([A-Za-z_][A-Za-z0-9_]+)")

SELECTOR_STRING_RE = re.compile(r'@"([A-Za-z_][A-Za-z0-9_:@]*)"')
OBJC_SELECTOR_PART_RE = re.compile(r'([A-Za-z_][A-Za-z0-9_]*):')

def extract_objc_symbols_from_file(path: str) -> set:
    analysis = _get_cached_file_analysis(path, PROJECT_SOURCE_ANALYSIS_KIND, _analyze_project_source_text)
    return set(analysis.get("objc_symbols", []))


def _extract_objc_symbols_from_text(text: str) -> set:
    symbols = set()
    for match in OBJC_INTERFACE_RE.finditer(text):
        symbols.add(match.group(1))
    for match in OBJC_IMPLEMENTATION_RE.finditer(text):
        symbols.add(match.group(1))
    for match in OBJC_PROTOCOL_RE.finditer(text):
        symbols.add(match.group(1))
    return symbols

def extract_all_objc_symbols(files: list, salt: str) -> dict:
    all_symbols = set()
    candidate_files = prefilter_files_with_rg(files, TYPE_DECLARATION_RG_PATTERN)
    for f in candidate_files:
        all_symbols.update(extract_objc_symbols_from_file(f))

    # 只保留以指定前缀开头的 Obj-C 符号
    filtered = [n for n in sorted(all_symbols) if any(n.startswith(p) for p in OBJC_SYMBOL_PREFIXES)]
    candidates = []
    for name in filtered:
        if not ALREADY_OBFUSCATED_RE.match(name) and name not in SYMBOL_WHITELIST and not name.startswith(SYMBOL_PREFIX_WHITELIST):
            candidates.append(name)
    return build_unique_mapping(candidates, salt, prefix=TYPE_OBFUSCATED_PREFIX)


def _collect_selector_literals_from_text(text: str) -> set:
    selectors = set()
    for match in SELECTOR_STRING_RE.finditer(text):
        value = match.group(1)
        if ':' in value or re.match(r'^[a-z]', value):
            selectors.add(value)
    return selectors

def collect_selector_literals(files: list) -> set:
    sels = set()
    candidate_files = prefilter_files_with_rg(files, SELECTOR_LITERAL_RG_PATTERN)
    for f in candidate_files:
        analysis = _get_cached_file_analysis(f, PROJECT_SOURCE_ANALYSIS_KIND, _analyze_project_source_text)
        sels.update(analysis.get("selector_literals", []))
    return sels


# ── 替换阶段 ─────────────────────────────────────────────────────────────────

def build_mapping_regex(mapping: dict) -> re.Pattern:
    """构建一次性替换正则，避免 O(符号数 x 文件数) 的重复扫描。"""
    if not mapping:
        return re.compile(r"(?!x)x")
    # 按长度降序可减少共有前缀时的回溯成本
    # Exclude reserved identifiers from replacement regex to avoid accidental replacement
    keys = [k for k in mapping.keys() if k not in RESERVED_IDENTIFIERS]
    keys = sorted(keys, key=len, reverse=True)
    body = "|".join(re.escape(k) for k in keys)
    return re.compile(r"(?<![A-Za-z0-9_])(" + body + r")(?![A-Za-z0-9_])")


def build_aho_automaton(mapping: dict):
    """尝试构建 pyahocorasick 自动机以进行单次线性替换；如不可用则返回 None。"""
    if not mapping:
        return None
    try:
        import ahocorasick
    except Exception:
        return None
    A = ahocorasick.Automaton()
    for key in mapping.keys():
        if key in RESERVED_IDENTIFIERS:
            continue
        # store key as value to identify match
        A.add_word(key, key)
    A.make_automaton()
    return A


def _iter_aho_matches(text: str, aho) -> list:
    """返回满足词边界且不重叠的 aho 匹配结果。"""
    if aho is None or not text:
        return []

    matches = []
    text_length = len(text)
    for end_index, key in aho.iter(text):
        start = end_index - len(key) + 1
        if start > 0 and (text[start - 1].isalnum() or text[start - 1] == '_'):
            continue
        if end_index + 1 < text_length and (text[end_index + 1].isalnum() or text[end_index + 1] == '_'):
            continue
        matches.append((start, end_index, key))

    if not matches:
        return []

    matches.sort(key=lambda item: (item[0], -(item[1] - item[0])))
    chosen = []
    last_end = -1
    for start, end, key in matches:
        if start <= last_end:
            continue
        chosen.append((start, end, key))
        last_end = end
    return chosen


def split_objc_selector(selector: str) -> list:
    return [f"{match.group(1)}:" for match in OBJC_SELECTOR_PART_RE.finditer(selector)]


def _build_swift_alias_from_objc_selector(selector: str, obfuscated_token: str):
    selector_parts = split_objc_selector(selector)
    if not selector_parts:
        return None

    base_name = selector_parts[0][:-1]
    obfuscated_base_name = f"{obfuscated_token}_1"
    signature_params = []
    alias_params = []
    for index, selector_part in enumerate(selector_parts, start=1):
        label = "_" if index == 1 else selector_part[:-1]
        signature_param = {
            "label": label,
            "has_default": False,
            "allows_trailing_closure": False,
        }
        signature_params.append(signature_param)
        alias_param = dict(signature_param)
        alias_param["replacement"] = None if label == "_" else f"{obfuscated_token}_{index}"
        alias_params.append(alias_param)

    return {
        "base_name": base_name,
        "obfuscated_base_name": obfuscated_base_name,
        "signature_key": _build_swift_signature_key(base_name, signature_params),
        "meta": {
            "base_name": base_name,
            "obfuscated": obfuscated_base_name,
            "params": alias_params,
        },
    }


def _record_alias_mapping_entry(bucket: dict, conflicts: set, key: str, value):
    if key in conflicts:
        return

    existing = bucket.get(key)
    if existing is not None and existing != value:
        bucket.pop(key, None)
        conflicts.add(key)
        return

    bucket[key] = value


def load_method_obfuscation_maps(map_path: str) -> tuple:
    method_mapping = json.loads(Path(map_path).read_text(encoding='utf-8'))
    direct_mapping = {}
    objc_selector_mapping = {}
    swift_signature_mapping = {}
    objc_swift_direct_aliases = {}
    objc_swift_signature_aliases = {}
    objc_swift_direct_conflicts = set()
    objc_swift_signature_conflicts = set()

    for original, obfuscated in method_mapping.items():
        # 跳过语言保留标识符（例如 Obj-C/Swift 的 `self`），避免将关键字替换为未声明标识符
        if isinstance(original, str) and original in RESERVED_IDENTIFIERS:
            continue
        if isinstance(obfuscated, dict):
            if obfuscated.get("kind") != "swift_signature":
                continue
            # 原生 Swift 方法只混淆基名，不再混淆参数标签。
            # 这里显式忽略旧 method_map 中遗留的 swift_signature 条目，
            # 避免半混淆源码再次应用时出现“基名已变、标签没跟上”的不一致。
            continue

        if not isinstance(obfuscated, str):
            continue
        if is_system_method(original):
            continue
        selector_parts = split_objc_selector(original)
        if selector_parts:
            # 如果 selector 的某一部分是保留标识符（例如 selector 包含 "self:"），跳过
            parts_ok = True
            for p in selector_parts:
                name = p[:-1]
                if name in RESERVED_IDENTIFIERS:
                    parts_ok = False
                    break
            if not parts_ok:
                continue
            objc_selector_mapping[original] = [
                f"{obfuscated}_{idx}:"
                for idx in range(1, len(selector_parts) + 1)
            ]

            swift_alias = _build_swift_alias_from_objc_selector(original, obfuscated)
            if swift_alias is not None:
                _record_alias_mapping_entry(
                    objc_swift_direct_aliases,
                    objc_swift_direct_conflicts,
                    swift_alias["base_name"],
                    swift_alias["obfuscated_base_name"],
                )
                _record_alias_mapping_entry(
                    objc_swift_signature_aliases,
                    objc_swift_signature_conflicts,
                    swift_alias["signature_key"],
                    swift_alias["meta"],
                )
        else:
            # 直接名称（非 selector）也要避免保留标识符
            if original in RESERVED_IDENTIFIERS:
                continue
            direct_mapping[original] = obfuscated

    for alias_name, alias_obfuscated in objc_swift_direct_aliases.items():
        existing = direct_mapping.get(alias_name)
        if existing is None or existing == alias_obfuscated:
            direct_mapping[alias_name] = alias_obfuscated

    for signature_key, signature_meta in objc_swift_signature_aliases.items():
        existing = swift_signature_mapping.get(signature_key)
        if existing is None or existing == signature_meta:
            swift_signature_mapping[signature_key] = signature_meta

    swift_signature_mapping, unsafe_bases, dropped_signatures = _drop_unsafe_loaded_swift_signature_entries(swift_signature_mapping)
    if dropped_signatures:
        preview = ", ".join(sorted(unsafe_bases)[:5])
        suffix = " ..." if len(unsafe_bases) > 5 else ""
        print(
            f"⚠️  跳过 {len(dropped_signatures)} 个存在重叠调用形态的 Swift 参数标签映射，"
            f"涉及 {len(unsafe_bases)} 个方法基名: {preview}{suffix}"
        )

    return direct_mapping, objc_selector_mapping, swift_signature_mapping


def build_selector_display_mapping(objc_selector_mapping: dict) -> dict:
    return {
        original: "".join(parts)
        for original, parts in objc_selector_mapping.items()
    }


def build_swift_signature_display_mapping(direct_method_mapping: dict, swift_signature_mapping: dict) -> dict:
    display = {}
    for original, meta in swift_signature_mapping.items():
        base_name = meta.get("base_name", "")
        obfuscated_base = direct_method_mapping.get(base_name, base_name)
        label_parts = []
        for param in meta.get("params", []):
            label = param.get("label")
            if label == "_":
                label_parts.append("_:")
                continue
            replacement = param.get("replacement", label)
            label_parts.append(f"{replacement}:")
        display[original] = f"{obfuscated_base}({''.join(label_parts)})"
    return display


def _replace_identifier_spans(text: str, spans: list, replacements: list) -> str:
    out = []
    cursor = 0
    for (start, end), replacement in zip(spans, replacements):
        out.append(text[cursor:start])
        out.append(replacement)
        cursor = end
    out.append(text[cursor:])
    return "".join(out)


def _build_swift_decl_param_edit(param: dict, replacement: str):
    label = param.get("label")
    label_span = param.get("span")
    if not label_span or not replacement:
        return None

    local_name = param.get("local_name")
    local_span = param.get("local_span")
    if local_name is None:
        if replacement == label:
            return None
        return label_span, f"{replacement} {label}"

    if local_span and local_name == replacement and label != replacement:
        return (label_span[0], local_span[1]), replacement

    if replacement == label:
        return None
    return label_span, replacement


def _skip_quoted_text(text: str, start: int) -> int:
    quote = text[start]
    index = start + 1
    while index < len(text):
        if text[index] == '\\':
            index += 2
            continue
        if text[index] == quote:
            return index + 1
        index += 1
    return len(text)


def _rewrite_swift_string_literal(text: str, start: int, rewriter) -> tuple:
    quote = text[start]
    index = start + 1
    chunk_start = index
    chunks = [quote]

    while index < len(text):
        if text.startswith("\\(", index):
            open_paren = index + 1
            close_paren = _find_matching_delimiter(text, open_paren, '(', ')')
            if close_paren == -1:
                break

            chunks.append(text[chunk_start:index + 2])
            chunks.append(rewriter(text[index + 2:close_paren]))
            chunks.append(')')
            index = close_paren + 1
            chunk_start = index
            continue

        if text[index] == '\\':
            index += 2
            continue
        if text[index] == quote:
            chunks.append(text[chunk_start:index + 1])
            return "".join(chunks), index + 1
        index += 1

    chunks.append(text[chunk_start:])
    return "".join(chunks), len(text)


def _skip_line_comment(text: str, start: int) -> int:
    end = text.find("\n", start)
    return len(text) if end == -1 else end


def _skip_block_comment(text: str, start: int) -> int:
    end = text.find("*/", start + 2)
    return len(text) if end == -1 else end + 2


def _find_matching_square_bracket(text: str, start: int) -> int:
    return _find_matching_delimiter(text, start, '[', ']')


def _collect_top_level_selector_parts(text: str) -> list:
    parts = []
    paren_depth = 0
    brace_depth = 0
    bracket_depth = 0
    index = 0

    while index < len(text):
        if text.startswith("//", index):
            index = _skip_line_comment(text, index)
            continue
        if text.startswith("/*", index):
            index = _skip_block_comment(text, index)
            continue

        char = text[index]
        if char in ('"', "'"):
            index = _skip_quoted_text(text, index)
            continue
        if char == '(':
            paren_depth += 1
            index += 1
            continue
        if char == ')' and paren_depth > 0:
            paren_depth -= 1
            index += 1
            continue
        if char == '{':
            brace_depth += 1
            index += 1
            continue
        if char == '}' and brace_depth > 0:
            brace_depth -= 1
            index += 1
            continue
        if char == '[':
            bracket_depth += 1
            index += 1
            continue
        if char == ']' and bracket_depth > 0:
            bracket_depth -= 1
            index += 1
            continue

        if paren_depth == 0 and brace_depth == 0 and bracket_depth == 0 and (char.isalpha() or char == '_'):
            start = index
            index += 1
            while index < len(text) and (text[index].isalnum() or text[index] == '_'):
                index += 1
            if index < len(text) and text[index] == ':':
                parts.append((f"{text[start:index]}:", (start, index)))
                index += 1
                continue
            continue

        index += 1

    return parts


def _rewrite_selector_occurrence(text: str, selector: str, replacement_parts: list, stats: dict) -> str:
    replacement_names = [part[:-1] for part in replacement_parts]
    full_replacement = "".join(replacement_parts)

    def replace_method_decls(src: str) -> str:
        chunks = []
        cursor = 0
        changed = 0

        for match in OBJC_METHOD_DECL_RE.finditer(src):
            declaration = match.group(1)
            label_matches = list(OBJC_SELECTOR_PART_RE.finditer(declaration))
            if not label_matches:
                continue

            full_selector = "".join(f"{item.group(1)}:" for item in label_matches)
            if full_selector != selector or len(label_matches) != len(replacement_names):
                continue

            spans = [item.span(1) for item in label_matches]
            new_declaration = _replace_identifier_spans(declaration, spans, replacement_names)
            if new_declaration == declaration:
                continue

            start, end = match.span(1)
            chunks.append(src[cursor:start])
            chunks.append(new_declaration)
            cursor = end
            changed += 1

        if not changed:
            return src

        chunks.append(src[cursor:])
        stats[selector] = stats.get(selector, 0) + changed
        return "".join(chunks)

    def replace_selector_literals(src: str) -> str:
        pattern = re.compile(rf"(@selector\s*\(\s*){re.escape(selector)}(\s*\))")

        def repl_selector(match: re.Match) -> str:
            stats[selector] = stats.get(selector, 0) + 1
            return f"{match.group(1)}{full_replacement}{match.group(2)}"

        src = pattern.sub(repl_selector, src)
        string_pattern = re.compile(r'@"' + re.escape(selector) + r'"')

        def repl_string(_: re.Match) -> str:
            stats[selector] = stats.get(selector, 0) + 1
            return f'@"{full_replacement}"'

        return string_pattern.sub(repl_string, src)

    def replace_message_sends(src: str) -> str:
        chunks = []
        index = 0
        changed = 0

        while index < len(src):
            if src.startswith("//", index):
                end = _skip_line_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if src.startswith("/*", index):
                end = _skip_block_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue

            char = src[index]
            if char in ('"', "'"):
                end = _skip_quoted_text(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if char != '[':
                chunks.append(char)
                index += 1
                continue

            end = _find_matching_square_bracket(src, index)
            if end == -1:
                chunks.append(src[index:])
                break

            segment = src[index:end + 1]
            inner = replace_message_sends(segment[1:-1])
            selector_parts = _collect_top_level_selector_parts(inner)
            if selector_parts:
                full_selector = "".join(part for part, _ in selector_parts)
                if full_selector == selector and len(selector_parts) == len(replacement_names):
                    spans = [span for _, span in selector_parts]
                    inner = _replace_identifier_spans(inner, spans, replacement_names)
                    changed += 1

            chunks.append(f"[{inner}]")
            index = end + 1

        if changed:
            stats[selector] = stats.get(selector, 0) + changed
        return "".join(chunks)

    result = text
    result = replace_method_decls(result)
    result = replace_message_sends(result)
    result = replace_selector_literals(result)
    return result


def apply_objc_selector_mapping(text: str, objc_selector_mapping: dict, stats: dict) -> str:
    if not objc_selector_mapping:
        return text

    if '@selector' not in text and ':' not in text and '@"' not in text:
        return text

    result = text
    for selector, replacement_parts in sorted(objc_selector_mapping.items(), key=lambda item: -len(item[0])):
        probe = selector.split(':', 1)[0]
        if probe and probe not in result:
            continue
        result = _rewrite_selector_occurrence(result, selector, replacement_parts, stats)
    return result


def _rewrite_objc_direct_method_occurrence(text: str, original_name: str, replacement_name: str, stats: dict) -> str:
    def replace_method_decls(src: str) -> str:
        chunks = []
        cursor = 0
        changed = 0

        for match in OBJC_METHOD_DECL_RE.finditer(src):
            declaration = match.group(1)
            if ':' in declaration:
                continue

            simple_match = re.match(r'\s*([A-Za-z_][A-Za-z0-9_]*)', declaration)
            if not simple_match or simple_match.group(1) != original_name:
                continue

            start, _ = match.span(1)
            name_start = start + simple_match.start(1)
            name_end = start + simple_match.end(1)
            chunks.append(src[cursor:name_start])
            chunks.append(replacement_name)
            cursor = name_end
            changed += 1

        if not changed:
            return src

        chunks.append(src[cursor:])
        stats[original_name] = stats.get(original_name, 0) + changed
        return "".join(chunks)

    def replace_selector_literals(src: str) -> str:
        selector_pattern = re.compile(rf"(@selector\s*\(\s*){re.escape(original_name)}(\s*\))")

        def repl_selector(match: re.Match) -> str:
            stats[original_name] = stats.get(original_name, 0) + 1
            return f"{match.group(1)}{replacement_name}{match.group(2)}"

        src = selector_pattern.sub(repl_selector, src)
        string_pattern = re.compile(r'@"' + re.escape(original_name) + r'"')

        def repl_string(_: re.Match) -> str:
            stats[original_name] = stats.get(original_name, 0) + 1
            return f'@"{replacement_name}"'

        return string_pattern.sub(repl_string, src)

    def replace_message_sends(src: str) -> str:
        chunks = []
        index = 0
        changed = 0

        while index < len(src):
            if src.startswith("//", index):
                end = _skip_line_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if src.startswith("/*", index):
                end = _skip_block_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue

            char = src[index]
            if char in ('"', "'"):
                end = _skip_quoted_text(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if char != '[':
                chunks.append(char)
                index += 1
                continue

            end = _find_matching_square_bracket(src, index)
            if end == -1:
                chunks.append(src[index:])
                break

            segment = src[index:end + 1]
            inner = replace_message_sends(segment[1:-1])
            if not _collect_top_level_selector_parts(inner):
                simple_match = re.match(r'^(?P<receiver>.+\s)(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*$', inner, re.S)
                if simple_match and simple_match.group("name") == original_name:
                    inner = f"{simple_match.group('receiver')}{replacement_name}"
                    changed += 1

            chunks.append(f"[{inner}]")
            index = end + 1

        if changed:
            stats[original_name] = stats.get(original_name, 0) + changed
        return "".join(chunks)

    result = text
    result = replace_method_decls(result)
    result = replace_message_sends(result)
    result = replace_selector_literals(result)
    return result


def apply_objc_direct_method_mapping(text: str, direct_method_mapping: dict, stats: dict) -> str:
    if not direct_method_mapping:
        return text

    result = text
    for original_name, replacement_name in sorted(direct_method_mapping.items(), key=lambda item: -len(item[0])):
        if original_name not in result:
            continue
        result = _rewrite_objc_direct_method_occurrence(result, original_name, replacement_name, stats)
    return result


def _parse_swift_call_arguments(arguments_text: str) -> list:
    arguments = []
    for segment, start, _ in _split_top_level_segments(arguments_text, separator=',', track_angles=False):
        if not segment.strip():
            continue

        colon_index = _find_top_level_char(segment, ':', track_angles=False)
        if colon_index == -1:
            arguments.append({
                "raw_label": None,
                "span": None,
            })
            continue

        prefix = segment[:colon_index]
        match = SWIFT_ARGUMENT_LABEL_RE.match(prefix)
        if not match:
            arguments.append({
                "raw_label": None,
                "span": None,
            })
            continue

        raw_label = match.group("label")
        label_span = None
        if raw_label != "_":
            label_span = (start + match.start("label"), start + match.end("label"))

        arguments.append({
            "raw_label": raw_label,
            "span": label_span,
        })

    return arguments


def _skip_swift_call_whitespace(text: str, index: int) -> int:
    while index < len(text) and text[index].isspace():
        index += 1
    return index


def _find_swift_call_paren(text: str, index: int):
    lookahead = _skip_swift_call_whitespace(text, index)
    if lookahead < len(text) and text[lookahead] in ('?', '!'):
        after_marker = _skip_swift_call_whitespace(text, lookahead + 1)
        if after_marker < len(text) and text[after_marker] == '(':
            return after_marker
    if lookahead < len(text) and text[lookahead] == '(':
        return lookahead
    return None


def _find_swift_trailing_closure_start(text: str, index: int):
    lookahead = _skip_swift_call_whitespace(text, index)
    if lookahead < len(text) and text[lookahead] == '{':
        return lookahead
    return None


def _swift_has_explicit_member_receiver(text: str, identifier_start: int) -> bool:
    dot_index = identifier_start - 1
    while dot_index >= 0 and text[dot_index].isspace():
        dot_index -= 1

    if dot_index < 0 or text[dot_index] != '.':
        return True

    receiver_index = dot_index - 1
    while receiver_index >= 0 and text[receiver_index].isspace():
        receiver_index -= 1

    while receiver_index >= 0 and text[receiver_index] in ('?', '!'):
        receiver_index -= 1
        while receiver_index >= 0 and text[receiver_index].isspace():
            receiver_index -= 1

    if receiver_index < 0:
        return False

    receiver_char = text[receiver_index]
    return receiver_char.isalnum() or receiver_char == '_' or receiver_char in (')', ']', '}')


def _swift_statement_prefix(text: str, identifier_start: int) -> str:
    statement_start = identifier_start
    while statement_start > 0:
        previous = text[statement_start - 1]
        if previous in '\n;{}':
            break
        statement_start -= 1
    return text[statement_start:identifier_start].lstrip()


def _swift_trailing_brace_belongs_to_control_flow(text: str, identifier_start: int) -> bool:
    prefix = _swift_statement_prefix(text, identifier_start)
    return prefix.startswith(("if ", "guard ", "while ", "for ", "switch "))


def _match_swift_call_arguments(signature_params: list, call_arguments: list, has_trailing_closure: bool = False):
    matches = []

    def can_bind_trailing_closure(remaining_params: list) -> bool:
        if not remaining_params:
            return False
        trailing_param = remaining_params[-1]
        if not trailing_param.get("allows_trailing_closure", False):
            return False
        return all(param.get("has_default", False) for param in remaining_params[:-1])

    def dfs(param_index: int, arg_index: int, alignment: list):
        if len(matches) > 1:
            return
        if arg_index == len(call_arguments):
            remaining_params = signature_params[param_index:]
            if has_trailing_closure:
                if can_bind_trailing_closure(remaining_params):
                    matches.append(list(alignment))
            elif all(param.get("has_default", False) for param in remaining_params):
                matches.append(list(alignment))
            return
        if param_index == len(signature_params):
            return

        signature_param = signature_params[param_index]
        if signature_param.get("has_default", False):
            dfs(param_index + 1, arg_index, alignment)

        if len(matches) > 1:
            return

        argument = call_arguments[arg_index]
        expected_label = signature_param.get("label")
        raw_label = argument.get("raw_label")
        is_match = (
            (expected_label == "_" and raw_label is None) or
            (expected_label != "_" and raw_label == expected_label)
        )
        if is_match:
            alignment.append((arg_index, param_index))
            dfs(param_index + 1, arg_index + 1, alignment)
            alignment.pop()

    dfs(0, 0, [])
    if len(matches) != 1:
        return None
    return matches[0]


def _replace_swift_call_argument_labels(arguments_text: str, call_arguments: list, alignment: list, signature_params: list) -> str:
    spans = []
    replacements = []

    for argument_index, param_index in alignment:
        argument = call_arguments[argument_index]
        signature_param = signature_params[param_index]
        span = argument.get("span")
        replacement = signature_param.get("replacement")
        if span and replacement:
            spans.append(span)
            replacements.append(replacement)

    if not spans:
        return arguments_text
    return _replace_identifier_spans(arguments_text, spans, replacements)


def _group_swift_signature_mapping(swift_signature_mapping: dict, direct_method_mapping: dict = None) -> dict:
    grouped = {}
    direct_method_mapping = direct_method_mapping or {}
    for signature_key, meta in swift_signature_mapping.items():
        entry = {
            "signature_key": signature_key,
            "base_name": meta.get("base_name"),
            "params": meta.get("params", []),
        }
        grouped.setdefault(entry["base_name"], []).append(entry)
        obfuscated_base = direct_method_mapping.get(entry["base_name"])
        if obfuscated_base and obfuscated_base != entry["base_name"]:
            grouped.setdefault(obfuscated_base, []).append(entry)
    return grouped


def _replace_swift_method_declarations(text: str, swift_signature_mapping: dict, stats: dict) -> str:
    chunks = []
    cursor = 0

    for match in SWIFT_METHOD_DECL_RE.finditer(text):
        base_name = match.group(1)
        open_paren = match.end() - 1
        close_paren = _find_matching_delimiter(text, open_paren, '(', ')')
        if close_paren == -1:
            continue

        params_text = text[open_paren + 1:close_paren]
        params = _parse_swift_decl_parameters(params_text)
        if params is None:
            continue

        signature_key = _build_swift_signature_key(base_name, params)
        meta = swift_signature_mapping.get(signature_key)
        if not meta:
            continue

        spans = []
        replacements = []
        for index, param in enumerate(params):
            replacement = meta["params"][index].get("replacement") if index < len(meta.get("params", [])) else None
            edit = _build_swift_decl_param_edit(param, replacement)
            if edit:
                span, replacement_text = edit
                spans.append(span)
                replacements.append(replacement_text)

        if not spans:
            continue

        new_params_text = _replace_identifier_spans(params_text, spans, replacements)
        chunks.append(text[cursor:open_paren + 1])
        chunks.append(new_params_text)
        cursor = close_paren
        stats[signature_key] = stats.get(signature_key, 0) + 1

    if not chunks:
        return text

    chunks.append(text[cursor:])
    return "".join(chunks)


def _resolve_swift_call_candidate(candidates: list, call_arguments: list, has_trailing_closure: bool = False):
    matches = []
    for candidate in candidates:
        alignment = _match_swift_call_arguments(candidate.get("params", []), call_arguments, has_trailing_closure=has_trailing_closure)
        if alignment is not None:
            params = candidate.get("params", [])
            trailing_param_count = 1 if has_trailing_closure else 0
            skipped_default_count = max(0, len(params) - len(alignment))
            score = (
                1 if len(params) == len(call_arguments) + trailing_param_count else 0,
                -(skipped_default_count - trailing_param_count),
            )
            matches.append((candidate, alignment, score))

    if not matches:
        return None

    best_score = max(match[2] for match in matches)
    best_matches = [match for match in matches if match[2] == best_score]
    if len(best_matches) != 1:
        return None

    candidate, alignment, _ = best_matches[0]
    return {
        "meta": candidate,
        "alignment": alignment,
    }


def _replace_swift_call_sites(text: str, swift_signature_mapping: dict, stats: dict, direct_method_mapping: dict = None) -> str:
    grouped = _group_swift_signature_mapping(swift_signature_mapping, direct_method_mapping)
    local_param_scopes = _collect_swift_local_param_scopes(text)

    def rewrite(src: str, base_offset: int = 0) -> str:
        chunks = []
        index = 0

        while index < len(src):
            if src.startswith("//", index):
                end = _skip_line_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if src.startswith("/*", index):
                end = _skip_block_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue

            char = src[index]
            if char in ('"', "'"):
                rewritten_literal, end = _rewrite_swift_string_literal(
                    src,
                    index,
                    lambda inner, offset=base_offset + index + 2: rewrite(inner, offset),
                )
                chunks.append(rewritten_literal)
                index = end
                continue

            if not (char.isalpha() or char == '_'):
                chunks.append(char)
                index += 1
                continue

            start = index
            index += 1
            while index < len(src) and (src[index].isalnum() or src[index] == '_'):
                index += 1
            identifier = src[start:index]

            if (
                identifier not in grouped or
                _find_previous_identifier(src, start) == "func" or
                _swift_is_shadowed_local_param(text, base_offset + start, identifier, local_param_scopes)
            ):
                chunks.append(src[start:index])
                continue

            open_paren = _find_swift_call_paren(src, index)
            if open_paren is None:
                chunks.append(src[start:index])
                continue

            close_paren = _find_matching_delimiter(src, open_paren, '(', ')')
            if close_paren == -1:
                chunks.append(src[start:index])
                continue

            inner = rewrite(src[open_paren + 1:close_paren], base_offset + open_paren + 1)
            call_arguments = _parse_swift_call_arguments(inner)
            has_trailing_closure = (
                _find_swift_trailing_closure_start(src, close_paren + 1) is not None and
                not _swift_trailing_brace_belongs_to_control_flow(src, start)
            )
            matched = _resolve_swift_call_candidate(grouped[identifier], call_arguments, has_trailing_closure=has_trailing_closure)
            if matched is not None:
                inner = _replace_swift_call_argument_labels(
                    inner,
                    call_arguments,
                    matched["alignment"],
                    matched["meta"].get("params", []),
                )
                signature_key = matched["meta"]["signature_key"]
                stats[signature_key] = stats.get(signature_key, 0) + 1

            chunks.append(src[start:open_paren + 1])
            chunks.append(inner)
            chunks.append(')')
            index = close_paren + 1

        return "".join(chunks)

    return rewrite(text)


def _replace_swift_direct_method_declarations(text: str, direct_method_mapping: dict, stats: dict) -> str:
    chunks = []
    cursor = 0

    for match in SWIFT_METHOD_DECL_RE.finditer(text):
        base_name = match.group(1)
        replacement = direct_method_mapping.get(base_name)
        if not replacement:
            continue

        chunks.append(text[cursor:match.start(1)])
        chunks.append(replacement)
        cursor = match.end(1)
        stats[base_name] = stats.get(base_name, 0) + 1

    if not chunks:
        return text

    chunks.append(text[cursor:])
    return "".join(chunks)


def _replace_swift_direct_call_sites(text: str, direct_method_mapping: dict, stats: dict) -> str:
    local_param_scopes = _collect_swift_local_param_scopes(text)

    def rewrite(src: str, base_offset: int = 0) -> str:
        chunks = []
        index = 0

        while index < len(src):
            if src.startswith("//", index):
                end = _skip_line_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue
            if src.startswith("/*", index):
                end = _skip_block_comment(src, index)
                chunks.append(src[index:end])
                index = end
                continue

            char = src[index]
            if char in ('"', "'"):
                rewritten_literal, end = _rewrite_swift_string_literal(
                    src,
                    index,
                    lambda inner, offset=base_offset + index + 2: rewrite(inner, offset),
                )
                chunks.append(rewritten_literal)
                index = end
                continue

            if not (char.isalpha() or char == '_'):
                chunks.append(char)
                index += 1
                continue

            start = index
            index += 1
            while index < len(src) and (src[index].isalnum() or src[index] == '_'):
                index += 1
            identifier = src[start:index]

            if (
                identifier not in direct_method_mapping or
                _find_previous_identifier(src, start) == "func" or
                _swift_is_shadowed_local_param(text, base_offset + start, identifier, local_param_scopes)
            ):
                chunks.append(src[start:index])
                continue

            open_paren = _find_swift_call_paren(src, index)
            if open_paren is not None:
                close_paren = _find_matching_delimiter(src, open_paren, '(', ')')
                if close_paren == -1:
                    chunks.append(src[start:index])
                    continue

                inner = rewrite(src[open_paren + 1:close_paren], base_offset + open_paren + 1)
                chunks.append(direct_method_mapping[identifier])
                chunks.append(src[index:open_paren + 1])
                chunks.append(inner)
                chunks.append(')')
                stats[identifier] = stats.get(identifier, 0) + 1
                index = close_paren + 1
                continue

            trailing_closure_start = _find_swift_trailing_closure_start(src, index)
            if (
                trailing_closure_start is not None and
                _swift_has_explicit_member_receiver(src, start) and
                not _swift_trailing_brace_belongs_to_control_flow(src, start)
            ):
                chunks.append(direct_method_mapping[identifier])
                chunks.append(src[index:trailing_closure_start])
                stats[identifier] = stats.get(identifier, 0) + 1
                index = trailing_closure_start
                continue

            chunks.append(src[start:index])

        return "".join(chunks)

    return rewrite(text)


def _replace_swift_direct_selector_references(text: str, direct_method_mapping: dict, stats: dict) -> str:
    selector_ref_re = re.compile(
        r"^(?P<prefix>\s*(?:(?:getter|setter)\s*:\s*)?(?:(?:[A-Za-z_][A-Za-z0-9_]*)\s*\.\s*)*)(?P<base>[A-Za-z_][A-Za-z0-9_]*)\s*$",
        re.S,
    )
    chunks = []
    index = 0

    while index < len(text):
        if text.startswith("//", index):
            end = _skip_line_comment(text, index)
            chunks.append(text[index:end])
            index = end
            continue
        if text.startswith("/*", index):
            end = _skip_block_comment(text, index)
            chunks.append(text[index:end])
            index = end
            continue

        char = text[index]
        if char in ('"', "'"):
            end = _skip_quoted_text(text, index)
            chunks.append(text[index:end])
            index = end
            continue

        if not text.startswith("#selector", index):
            chunks.append(char)
            index += 1
            continue

        start = index
        after_keyword = index + len("#selector")
        while after_keyword < len(text) and text[after_keyword].isspace():
            after_keyword += 1
        if after_keyword >= len(text) or text[after_keyword] != '(':
            chunks.append(text[index:after_keyword])
            index = after_keyword
            continue

        close_paren = _find_matching_delimiter(text, after_keyword, '(', ')')
        if close_paren == -1:
            chunks.append(text[index:])
            break

        inner = text[after_keyword + 1:close_paren]
        new_inner = inner
        match = selector_ref_re.match(inner)
        if match:
            base_name = match.group("base")
            replacement = direct_method_mapping.get(base_name)
            if replacement:
                new_inner = f"{match.group('prefix')}{replacement}"
                stats[base_name] = stats.get(base_name, 0) + 1

        chunks.append(text[start:after_keyword + 1])
        chunks.append(new_inner)
        chunks.append(')')
        index = close_paren + 1

    return "".join(chunks)


def apply_swift_direct_method_mapping(text: str, direct_method_mapping: dict, stats: dict) -> str:
    if not direct_method_mapping:
        return text

    result = text
    result = _replace_swift_direct_method_declarations(result, direct_method_mapping, stats)
    result = _replace_swift_direct_call_sites(result, direct_method_mapping, stats)
    result = _replace_swift_direct_selector_references(result, direct_method_mapping, stats)
    return result


def _replace_swift_selector_references(text: str, swift_signature_mapping: dict, stats: dict) -> str:
    chunks = []
    index = 0
    selector_ref_re = re.compile(
        r"^(?P<prefix>\s*(?:(?:[A-Za-z_][A-Za-z0-9_]*)\s*\.\s*)*)(?P<base>[A-Za-z_][A-Za-z0-9_]*)\((?P<labels>.*)\)\s*$",
        re.S,
    )

    while index < len(text):
        if text.startswith("//", index):
            end = _skip_line_comment(text, index)
            chunks.append(text[index:end])
            index = end
            continue
        if text.startswith("/*", index):
            end = _skip_block_comment(text, index)
            chunks.append(text[index:end])
            index = end
            continue

        char = text[index]
        if char in ('"', "'"):
            end = _skip_quoted_text(text, index)
            chunks.append(text[index:end])
            index = end
            continue

        if not text.startswith("#selector", index):
            chunks.append(char)
            index += 1
            continue

        start = index
        after_keyword = index + len("#selector")
        while after_keyword < len(text) and text[after_keyword].isspace():
            after_keyword += 1
        if after_keyword >= len(text) or text[after_keyword] != '(':
            chunks.append(text[index:after_keyword])
            index = after_keyword
            continue

        close_paren = _find_matching_delimiter(text, after_keyword, '(', ')')
        if close_paren == -1:
            chunks.append(text[index:])
            break

        inner = text[after_keyword + 1:close_paren]
        new_inner = inner
        match = selector_ref_re.match(inner)
        if match:
            base_name = match.group("base")
            labels_text = match.group("labels")
            label_matches = list(re.finditer(r'([A-Za-z_][A-Za-z0-9_]*|_):', labels_text))
            if label_matches:
                signature_key = f"{base_name}({''.join(f'{item.group(1)}:' for item in label_matches)})"
                meta = swift_signature_mapping.get(signature_key)
                if meta and len(label_matches) == len(meta.get("params", [])):
                    spans = []
                    replacements = []
                    for idx, label_match in enumerate(label_matches):
                        replacement = meta["params"][idx].get("replacement")
                        if replacement and label_match.group(1) != "_":
                            spans.append(label_match.span(1))
                            replacements.append(replacement)
                    if spans:
                        replaced_labels = _replace_identifier_spans(labels_text, spans, replacements)
                        new_inner = f"{match.group('prefix')}{base_name}({replaced_labels})"
                        stats[signature_key] = stats.get(signature_key, 0) + 1

        chunks.append(text[start:after_keyword + 1])
        chunks.append(new_inner)
        chunks.append(')')
        index = close_paren + 1

    return "".join(chunks)


def apply_swift_signature_mapping(text: str, swift_signature_mapping: dict, stats: dict, direct_method_mapping: dict = None) -> str:
    if not swift_signature_mapping:
        return text

    result = text
    result = _replace_swift_method_declarations(result, swift_signature_mapping, stats)
    result = _replace_swift_call_sites(result, swift_signature_mapping, stats, direct_method_mapping)
    result = _replace_swift_selector_references(result, swift_signature_mapping, stats)
    return result


def _record_reverse_mapping_entry(bucket: dict, key: str, value, conflicts: dict):
    existing = bucket.get(key)
    if existing is not None and existing != value:
        conflicts.setdefault(key, set()).update({
            json.dumps(existing, ensure_ascii=False, sort_keys=True),
            json.dumps(value, ensure_ascii=False, sort_keys=True),
        })
        bucket.pop(key, None)
        return
    bucket[key] = value


def _build_reverse_swift_signature_entry(original_signature: str, obfuscated_meta: dict):
    if obfuscated_meta.get("kind") != "swift_signature":
        return None

    base_name, _ = _split_swift_signature_key(original_signature)
    obfuscated_token = obfuscated_meta.get("obfuscated")
    if not base_name or not isinstance(obfuscated_token, str):
        return None

    reverse_signature_params = []
    reverse_params = []
    for index, param in enumerate(obfuscated_meta.get("params", []), start=1):
        if not isinstance(param, dict):
            return None
        original_label = param.get("label")
        if not isinstance(original_label, str):
            return None

        current_label = "_" if original_label == "_" else f"{obfuscated_token}_{index}"
        has_default = bool(param.get("has_default", False))
        reverse_signature_params.append({
            "label": current_label,
            "has_default": has_default,
            "allows_trailing_closure": bool(param.get("allows_trailing_closure", False)),
        })
        reverse_params.append({
            "label": current_label,
            "has_default": has_default,
            "allows_trailing_closure": bool(param.get("allows_trailing_closure", False)),
            "replacement": None if original_label == "_" else original_label,
        })

    reverse_signature_key = _build_swift_signature_key(base_name, reverse_signature_params)
    return reverse_signature_key, {
        "base_name": base_name,
        "obfuscated": obfuscated_token,
        "params": reverse_params,
    }

def load_reverse_mappings_from_files(map_files: list) -> tuple:
    reverse = {}
    reverse_objc_selector_mapping = {}
    reverse_swift_signature_mapping = {}
    conflicts = {}
    for map_file in map_files:
        try:
            data = json.loads(Path(map_file).read_text(encoding="utf-8"))
        except Exception as e:
            print(f"⚠️  跳过损坏映射文件 {map_file}: {e}")
            continue
        for original, obfuscated in data.items():
            if isinstance(obfuscated, dict):
                reverse_swift_entry = _build_reverse_swift_signature_entry(original, obfuscated)
                if reverse_swift_entry is None:
                    continue
                reverse_signature_key, reverse_signature_meta = reverse_swift_entry
                _record_reverse_mapping_entry(
                    reverse_swift_signature_mapping,
                    reverse_signature_key,
                    reverse_signature_meta,
                    conflicts,
                )
                continue
            if not isinstance(obfuscated, str):
                continue

            selector_parts = split_objc_selector(original)
            if selector_parts:
                reverse_selector = "".join(
                    f"{obfuscated}_{index}:"
                    for index in range(1, len(selector_parts) + 1)
                )
                _record_reverse_mapping_entry(
                    reverse_objc_selector_mapping,
                    reverse_selector,
                    selector_parts,
                    conflicts,
                )

                swift_alias = _build_swift_alias_from_objc_selector(original, obfuscated)
                if swift_alias is not None:
                    _record_reverse_mapping_entry(
                        reverse,
                        swift_alias["obfuscated_base_name"],
                        swift_alias["base_name"],
                        conflicts,
                    )
                    reverse_signature_params = []
                    reverse_params = []
                    for index, param in enumerate(swift_alias["meta"].get("params", []), start=1):
                        original_label = param.get("label")
                        if not isinstance(original_label, str):
                            continue
                        current_label = "_" if original_label == "_" else f"{obfuscated}_{index}"
                        reverse_signature_params.append({
                            "label": current_label,
                            "has_default": False,
                            "allows_trailing_closure": False,
                        })
                        reverse_params.append({
                            "label": current_label,
                            "has_default": False,
                            "allows_trailing_closure": False,
                            "replacement": None if original_label == "_" else original_label,
                        })
                    reverse_signature_key = _build_swift_signature_key(swift_alias["base_name"], reverse_signature_params)
                    _record_reverse_mapping_entry(
                        reverse_swift_signature_mapping,
                        reverse_signature_key,
                        {
                            "base_name": swift_alias["base_name"],
                            "obfuscated": swift_alias["obfuscated_base_name"],
                            "params": reverse_params,
                        },
                        conflicts,
                    )
                continue

            _record_reverse_mapping_entry(reverse, obfuscated, original, conflicts)
    # 去掉存在歧义的 token，避免错误恢复
    for obfuscated in conflicts:
        reverse.pop(obfuscated, None)
        reverse_objc_selector_mapping.pop(obfuscated, None)
        reverse_swift_signature_mapping.pop(obfuscated, None)
    return reverse, reverse_objc_selector_mapping, reverse_swift_signature_mapping, conflicts

def restore_source_file(path: str, reverse_mapping: dict, reverse_re: re.Pattern, reverse_objc_selector_mapping: dict = None, reverse_swift_signature_mapping: dict = None, reverse_aho=None) -> tuple:
    try:
        original = Path(path).read_text(encoding="utf-8")
    except Exception as e:
        return False, {"error": str(e)}, None, None

    stats = {}
    reverse_objc_selector_mapping = reverse_objc_selector_mapping or {}
    reverse_swift_signature_mapping = reverse_swift_signature_mapping or {}

    if reverse_aho is not None:
        matches = _iter_aho_matches(original, reverse_aho)
        if matches:
            chunks = []
            cursor = 0
            for start, end, key in matches:
                if cursor < start:
                    chunks.append(original[cursor:start])
                chunks.append(reverse_mapping[key])
                stats[key] = stats.get(key, 0) + 1
                cursor = end + 1
            if cursor < len(original):
                chunks.append(original[cursor:])
            result = ''.join(chunks)
        else:
            result = original
    else:
        def repl(match: re.Match) -> str:
            obfuscated = match.group(1)
            stats[obfuscated] = stats.get(obfuscated, 0) + 1
            return reverse_mapping[obfuscated]

        result = reverse_re.sub(repl, original)
    if reverse_objc_selector_mapping and path.endswith((".h", ".m", ".mm", ".pch")):
        result = apply_objc_selector_mapping(result, reverse_objc_selector_mapping, stats)
    if reverse_swift_signature_mapping and path.endswith(".swift"):
        result = apply_swift_signature_mapping(result, reverse_swift_signature_mapping, stats)
    if result == original:
        return False, {}, None, original
    return True, stats, result, original

def transactional_write(planned_changes: dict):
    if not planned_changes:
        return 0

    backup_dir = tempfile.mkdtemp(prefix="obf_apply_backup_")
    changed_files = sorted(planned_changes.keys())
    # Collect any import renames requested by planned changes (old_basename -> new_basename)
    import_re = re.compile(r'#import\s+"([^"]+\.h)"')
    rename_pairs = []
    for path, info in planned_changes.items():
        orig = info.get("original_text", "")
        new = info.get("new_text", "")
        orig_imports = [m.group(1) for m in import_re.finditer(orig)]
        new_imports = [m.group(1) for m in import_re.finditer(new)]
        # pair up imports by position; if basename differs, schedule rename
        for o, n in zip(orig_imports, new_imports):
            if o != n:
                rename_pairs.append({"old": os.path.basename(o), "new": os.path.basename(n)})

    state = {"backup_dir": backup_dir, "files": changed_files, "rename_pairs": rename_pairs}
    save_apply_state(state)

    for path in changed_files:
        rel = path.lstrip("./")
        backup_target = Path(backup_dir) / rel
        backup_target.parent.mkdir(parents=True, exist_ok=True)
        atomic_write_text(str(backup_target), planned_changes[path]["original_text"], encoding="utf-8")

    try:
        for path in changed_files:
            atomic_write_text(path, planned_changes[path]["new_text"], encoding="utf-8")
        # After writing changed files, perform header renames if requested.
        for pair in rename_pairs:
            old_name = pair.get("old")
            new_name = pair.get("new")
            if not old_name or not new_name:
                continue
            # Find candidate files by basename in workspace
            for found in Path('.').rglob(old_name):
                try:
                    # backup original header before renaming
                    rel = str(found).lstrip("./")
                    backup_target = Path(backup_dir) / rel
                    backup_target.parent.mkdir(parents=True, exist_ok=True)
                    shutil.copy2(found, backup_target)

                    new_path = found.with_name(new_name)
                    # if destination exists, back it up too
                    if new_path.exists():
                        rel_new = str(new_path).lstrip("./")
                        backup_target_new = Path(backup_dir) / rel_new
                        backup_target_new.parent.mkdir(parents=True, exist_ok=True)
                        shutil.copy2(new_path, backup_target_new)
                    # perform atomic move
                    Path(new_path.parent).mkdir(parents=True, exist_ok=True)
                    os.replace(str(found), str(new_path))
                except Exception:
                    # If any rename fails, raise to trigger rollback
                    raise

        clear_apply_state()
        shutil.rmtree(backup_dir, ignore_errors=True)
    except Exception as e:
        print(f"❌ 写入过程中异常，开始回滚: {e}")
        for path in changed_files:
            rel = path.lstrip("./")
            backup_source = Path(backup_dir) / rel
            if backup_source.exists():
                shutil.copy2(backup_source, path)
        # Restore any renamed headers from backup if present
        rpairs = state.get("rename_pairs", [])
        for pair in rpairs:
            old = pair.get("old")
            new = pair.get("new")
            if not old or not new:
                continue
            # If new file exists at any path, remove it and restore original from backup
            for new_found in Path('.').rglob(new):
                try:
                    # remove the moved file
                    new_found.unlink()
                except Exception:
                    pass
            # restore original from backup if available
            for backup_file in Path(backup_dir).rglob(old):
                try:
                    dest = Path('.') / backup_file.relative_to(backup_dir)
                    dest.parent.mkdir(parents=True, exist_ok=True)
                    shutil.copy2(backup_file, dest)
                except Exception:
                    pass
        clear_apply_state()
        shutil.rmtree(backup_dir, ignore_errors=True)
        raise

    return len(changed_files)

def direct_write(planned_changes: dict):
    if not planned_changes:
        return 0

    changed_files = sorted(planned_changes.keys())
    for path in changed_files:
        atomic_write_text(path, planned_changes[path]["new_text"], encoding="utf-8")
    return len(changed_files)

def restore_sources_from_maps(scan_dirs: list, map_dir: str):
    restore_started_at = time.perf_counter()
    map_files = sorted(str(p) for p in Path(map_dir).glob("*.json"))
    if not map_files:
        print(f"⚠️  未在 {map_dir} 发现映射文件")
        return

    reverse_mapping, reverse_objc_selector_mapping, reverse_swift_signature_mapping, conflicts = load_reverse_mappings_from_files(map_files)
    print(
        f"🧩 加载映射文件 {len(map_files)} 个，"
        f"可用反向符号 {len(reverse_mapping)} 个，"
        f"Obj-C selector {len(reverse_objc_selector_mapping)} 个，"
        f"Swift 签名 {len(reverse_swift_signature_mapping)} 个"
    )
    if conflicts:
        print(f"⚠️  检测到 {len(conflicts)} 个歧义 token，已跳过，避免错误恢复")

    if not reverse_mapping and not reverse_objc_selector_mapping and not reverse_swift_signature_mapping:
        print("⚠️  没有可用于恢复的反向映射")
        return

    reverse_re = build_mapping_regex(reverse_mapping)
    reverse_aho = build_aho_automaton(reverse_mapping)
    source_files = collect_source_files(scan_dirs)
    print(f"📂 准备恢复源码文件 {len(source_files)} 个")

    planned_changes = {}
    planning_started_at = time.perf_counter()
    for idx, path in enumerate(source_files, start=1):
        changed, stats, new_text, original_text = restore_source_file(
            path,
            reverse_mapping,
            reverse_re,
            reverse_objc_selector_mapping,
            reverse_swift_signature_mapping,
            reverse_aho,
        )
        if changed:
            planned_changes[path] = {
                "stats": stats,
                "new_text": new_text,
                "original_text": original_text,
            }
        if idx % 100 == 0:
            print(f"   ... 恢复扫描进度 {idx}/{len(source_files)}")

    _log_stage_duration("源码还原规划", planning_started_at)

    restored_count = transactional_write(planned_changes)
    print(f"✅ 源码恢复完成，修改了 {restored_count} 个文件")
    _log_stage_duration("源码还原总阶段", restore_started_at)

def _is_protected_objc_line(line: str, line_index: int) -> bool:
    s = line.strip()
    # 保护 #import "xxx.h"，避免类名替换后头文件名失配
    if s.startswith("#import") and '.h"' in s:
        # Protect import lines unless the user explicitly enabled import rewriting.
        return not REWRITE_IMPORTS_ALLOWED
    # 保护文件头注释中的文件名（通常在前 40 行）
    if line_index < 40 and ".h" in s and (s.startswith("//") or s.startswith("/*") or s.startswith("*")):
        return True
    if line_index < 40 and (".m" in s or ".mm" in s) and (s.startswith("//") or s.startswith("/*") or s.startswith("*")):
        return True
    return False

def atomic_write_text(path: str, content: str, encoding: str = "utf-8"):
    """原子写文件，避免中途中断导致半写入文件。"""
    target = Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile("w", delete=False, dir=str(target.parent), encoding=encoding) as tf:
        tf.write(content)
        temp_path = tf.name
    os.replace(temp_path, str(target))


# Simple cache to skip unchanged files between runs
CACHE_PATH = ".obfuscate_cache.json"

def load_cache():
    data = load_json_file(CACHE_PATH, {})
    return data if isinstance(data, dict) else {}

def save_cache(cache_data: dict):
    try:
        save_json_file(CACHE_PATH, cache_data)
    except Exception:
        pass


def _format_elapsed(seconds: float) -> str:
    if seconds < 60:
        return f"{seconds:.2f}s"
    minutes, seconds = divmod(seconds, 60)
    if minutes < 60:
        return f"{int(minutes)}m {seconds:.2f}s"
    hours, minutes = divmod(int(minutes), 60)
    return f"{hours}h {minutes}m {seconds:.2f}s"


def _log_stage_duration(label: str, started_at: float):
    suffix = "" if label.endswith("耗时") else "耗时"
    print(f"⏱️  {label}{suffix}: {_format_elapsed(time.perf_counter() - started_at)}")


# Globals used by multiprocessing workers (initialized in Pool initializer)
_GLOBAL_WORKER_MAPPING = None
_GLOBAL_WORKER_MAPPING_RE = None
_GLOBAL_WORKER_AHO = None
_GLOBAL_WORKER_SELECTOR_MAPPING = None
_GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING = None
_GLOBAL_WORKER_DIRECT_METHOD_MAPPING = None

def _pool_init(mapping_json_str: str, selector_mapping_json_str: str, swift_signature_mapping_json_str: str, direct_method_mapping_json_str: str):
    global _GLOBAL_WORKER_MAPPING, _GLOBAL_WORKER_MAPPING_RE, _GLOBAL_WORKER_AHO, _GLOBAL_WORKER_SELECTOR_MAPPING, _GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING, _GLOBAL_WORKER_DIRECT_METHOD_MAPPING
    try:
        _GLOBAL_WORKER_MAPPING = json.loads(mapping_json_str)
        _GLOBAL_WORKER_SELECTOR_MAPPING = json.loads(selector_mapping_json_str)
        _GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING = json.loads(swift_signature_mapping_json_str)
        _GLOBAL_WORKER_DIRECT_METHOD_MAPPING = json.loads(direct_method_mapping_json_str)
        _GLOBAL_WORKER_AHO = build_aho_automaton(_GLOBAL_WORKER_MAPPING)
        _GLOBAL_WORKER_MAPPING_RE = build_mapping_regex(_GLOBAL_WORKER_MAPPING)
    except Exception:
        _GLOBAL_WORKER_MAPPING = None
        _GLOBAL_WORKER_AHO = None
        _GLOBAL_WORKER_MAPPING_RE = None
        _GLOBAL_WORKER_SELECTOR_MAPPING = None
        _GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING = None
        _GLOBAL_WORKER_DIRECT_METHOD_MAPPING = None

def _pool_plan_worker(path: str):
    """Worker used in multiprocessing Pool to plan file changes using global mapping/aho."""
    global _GLOBAL_WORKER_MAPPING, _GLOBAL_WORKER_MAPPING_RE, _GLOBAL_WORKER_AHO, _GLOBAL_WORKER_SELECTOR_MAPPING, _GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING, _GLOBAL_WORKER_DIRECT_METHOD_MAPPING
    if _GLOBAL_WORKER_MAPPING is None and not _GLOBAL_WORKER_SELECTOR_MAPPING and not _GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING and not _GLOBAL_WORKER_DIRECT_METHOD_MAPPING:
        return path, False, {}, None, None
    is_objc_file = path.endswith((".h", ".m", ".mm", ".pch"))
    # call apply_mapping_to_file with globals
    changed, stats, new_text, original_text = apply_mapping_to_file(
        path,
        _GLOBAL_WORKER_MAPPING,
        _GLOBAL_WORKER_MAPPING_RE,
        objc_selector_mapping=_GLOBAL_WORKER_SELECTOR_MAPPING,
        swift_signature_mapping=_GLOBAL_WORKER_SWIFT_SIGNATURE_MAPPING,
        direct_method_mapping=_GLOBAL_WORKER_DIRECT_METHOD_MAPPING,
        protect_objc_headers=is_objc_file,
        mapping_aho=_GLOBAL_WORKER_AHO,
    )
    return path, changed, stats, new_text, original_text

def save_apply_state(state: dict):
    Path(APPLY_STATE_PATH).write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")

def clear_apply_state():
    p = Path(APPLY_STATE_PATH)
    if p.exists():
        p.unlink()

def restore_from_apply_state_if_needed():
    """如果上次 apply 中断，优先恢复，避免出现部分文件被混淆。"""
    p = Path(APPLY_STATE_PATH)
    if not p.exists():
        return
    try:
        state = json.loads(p.read_text(encoding="utf-8"))
    except Exception as e:
        print(f"⚠️  发现损坏的 apply 状态文件，已忽略: {e}")
        return

    backup_dir = state.get("backup_dir", "")
    files = state.get("files", [])
    rename_pairs = state.get("rename_pairs", [])
    if not backup_dir or not files:
        clear_apply_state()
        return

    print("🧯 检测到上次混淆未完成，正在自动回滚文件...")
    restored = 0
    for file_path in files:
        rel = file_path.lstrip("./")
        src = Path(backup_dir) / rel
        dst = Path(file_path)
        if src.exists():
            dst.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(src, dst)
            restored += 1

    print(f"✅ 已回滚 {restored}/{len(files)} 个文件")
    # Attempt to restore any renamed headers recorded in state
    for pair in rename_pairs:
        old_name = pair.get("old")
        new_name = pair.get("new")
        if not old_name or not new_name:
            continue
        # If new files exist, remove them and restore original from backup copies if present
        for new_found in Path('.').rglob(new_name):
            try:
                new_found.unlink()
            except Exception:
                pass
        for backup_file in Path(backup_dir).rglob(old_name):
            try:
                dest = Path('.') / backup_file.relative_to(backup_dir)
                dest.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(backup_file, dest)
            except Exception:
                pass
    try:
        shutil.rmtree(backup_dir, ignore_errors=True)
    finally:
        clear_apply_state()

def apply_mapping_to_file(path: str, mapping: dict, mapping_re: re.Pattern, objc_selector_mapping: dict = None, swift_signature_mapping: dict = None, direct_method_mapping: dict = None, protect_objc_headers: bool = False, mapping_aho=None) -> tuple:
    """
    对单个文件执行符号替换。
    返回 (changed: bool, stats: dict, new_text: str|None, original_text: str|None)。
    使用词边界匹配，避免部分替换。
    """
    try:
        original = Path(path).read_text(encoding="utf-8")
    except Exception as e:
        return False, {"error": str(e)}, None, None

    stats = {}
    objc_selector_mapping = objc_selector_mapping or {}
    swift_signature_mapping = swift_signature_mapping or {}
    direct_method_mapping = direct_method_mapping or {}

    result = original
    if objc_selector_mapping and path.endswith((".h", ".m", ".mm", ".pch")):
        result = apply_objc_selector_mapping(result, objc_selector_mapping, stats)
    if swift_signature_mapping and path.endswith(".swift"):
        result = apply_swift_signature_mapping(result, swift_signature_mapping, stats, direct_method_mapping)
    if direct_method_mapping:
        if path.endswith((".h", ".m", ".mm", ".pch")):
            result = apply_objc_direct_method_mapping(result, direct_method_mapping, stats)
        elif path.endswith(".swift"):
            result = apply_swift_direct_method_mapping(result, direct_method_mapping, stats)

    # Try to use Aho-Corasick automaton if available for single-pass replacement
    aho = mapping_aho
    if aho is None:
        try:
            # build_aho_automaton may be expensive; caller can prebuild and pass, but fallback here
            aho = build_aho_automaton(mapping)
        except Exception:
            aho = None

    def do_regex_replace(text: str):
        def repl(match: re.Match) -> str:
            orig = match.group(1)
            stats[orig] = stats.get(orig, 0) + 1
            return mapping[orig]
        return mapping_re.sub(repl, text)

    if aho is None:
        # fallback to previous regex-based replacement
        if protect_objc_headers:
            out_lines = []
            for i, line in enumerate(result.splitlines(keepends=True)):
                if _is_protected_objc_line(line, i):
                    out_lines.append(line)
                else:
                    out_lines.append(do_regex_replace(line))
            result = "".join(out_lines)
        else:
            result = do_regex_replace(result)
        if result == original:
            return False, {}, None, original
        return True, stats, result, original

    # With aho: perform line-wise replacement when protect_objc_headers True to preserve header guards
    def replace_with_aho_in_text(text: str):
        matches = _iter_aho_matches(text, aho)
        if not matches:
            return text

        # build new text
        out = []
        pos = 0
        for s, e, k in matches:
            if pos < s:
                out.append(text[pos:s])
            out.append(mapping[k])
            stats[k] = stats.get(k, 0) + 1
            pos = e + 1
        if pos < len(text):
            out.append(text[pos:])
        return ''.join(out)

    if protect_objc_headers:
        out_lines = []
        for i, line in enumerate(result.splitlines(keepends=True)):
            if _is_protected_objc_line(line, i):
                out_lines.append(line)
            else:
                out_lines.append(replace_with_aho_in_text(line))
        result = ''.join(out_lines)
    else:
        result = replace_with_aho_in_text(result)

    if result == original:
        return False, {}, None, original

    return True, stats, result, original

def count_mapping_occurrences_in_file(path: str, mapping_re: re.Pattern, mapping_aho=None) -> dict:
    try:
        text = Path(path).read_text(encoding="utf-8")
    except Exception:
        return {}

    counts = {}
    if mapping_aho is not None:
        for _, _, key in _iter_aho_matches(text, mapping_aho):
            counts[key] = counts.get(key, 0) + 1
        return counts

    for match in mapping_re.finditer(text):
        key = match.group(1)
        counts[key] = counts.get(key, 0) + 1
    return counts

def count_mapping_occurrences(files: list, mapping_re: re.Pattern, workers: int = 1, mapping_aho=None) -> dict:
    totals = {}

    if workers <= 1 or len(files) < 20:
        for path in files:
            file_counts = count_mapping_occurrences_in_file(path, mapping_re, mapping_aho)
            for key, value in file_counts.items():
                totals[key] = totals.get(key, 0) + value
        return totals

    with ThreadPoolExecutor(max_workers=workers) as executor:
        future_map = {
            executor.submit(count_mapping_occurrences_in_file, path, mapping_re, mapping_aho): path
            for path in files
        }
        for future in as_completed(future_map):
            file_counts = future.result()
            for key, value in file_counts.items():
                totals[key] = totals.get(key, 0) + value

    return totals

def plan_file_change(path: str, mapping: dict, mapping_re: re.Pattern, objc_selector_mapping: dict = None, swift_signature_mapping: dict = None, mapping_aho=None, method_direct_mapping: dict = None) -> tuple:
    # Optional verbose per-file logging for diagnosing slow files during planning.
    if os.environ.get("RD_OBF_VERBOSE", "0") == "1":
        try:
            print(f"[obf-plan] Processing: {path}")
        except Exception:
            pass
    is_objc_file = path.endswith((".h", ".m", ".mm", ".pch"))
    local_mapping = mapping
    local_mapping_re = mapping_re
    local_mapping_aho = mapping_aho
    local_objc_selector_mapping = objc_selector_mapping
    local_swift_signature_mapping = swift_signature_mapping
    local_direct_method_mapping = method_direct_mapping or {}

    if should_skip_method_replacements(path):
        local_objc_selector_mapping = {}
        local_swift_signature_mapping = {}
        local_direct_method_mapping = {}

    changed, stats, new_text, original_text = apply_mapping_to_file(
        path,
        local_mapping,
        local_mapping_re,
        objc_selector_mapping=local_objc_selector_mapping,
        swift_signature_mapping=local_swift_signature_mapping,
        direct_method_mapping=local_direct_method_mapping,
        protect_objc_headers=is_objc_file,
        mapping_aho=local_mapping_aho,
    )
    return path, changed, stats, new_text, original_text

# ── Deobfuscate（Crash 还原）────────────────────────────────────────────────

def deobfuscate_crash(crash_path: str, map_path: str):
    with open(map_path, encoding="utf-8") as f:
        mapping = json.load(f)

    # 反转映射
    reverse = {v: k for k, v in mapping.items()}

    crash_text = Path(crash_path).read_text(encoding="utf-8")
    for obf, orig in sorted(reverse.items(), key=lambda x: -len(x[0])):
        pattern = r"(?<![A-Za-z0-9_])" + re.escape(obf) + r"(?![A-Za-z0-9_])"
        crash_text = re.sub(pattern, orig, crash_text)

    out_path = crash_path + ".deobfuscated.txt"
    Path(out_path).write_text(crash_text, encoding="utf-8")
    print(f"✅ 已还原 crash 符号 → {out_path}")


def apply_archive_mode_defaults(args):
    if not args.scan_dir:
        args.scan_dir = DEFAULT_SCAN_DIRS

    if not args.archive_mode:
        if args.map_output is None:
            args.map_output = MAP_OUTPUT_PATH
        if args.map_methods is None:
            args.map_methods = METHOD_MAP_OUTPUT_PATH
        return

    target_name = args.target_name or os.environ.get("TARGET_NAME") or "app"
    timestamp = args.timestamp or os.environ.get("OBF_TIMESTAMP") or time.strftime("%Y%m%d_%H%M%S")
    map_dir = Path(args.map_dir or "obfuscation_maps")
    map_dir.mkdir(parents=True, exist_ok=True)

    args.apply = True
    args.enable_methods = True
    if args.whitelist_json is None:
        default_whitelist = Path("must_keep_summary.json")
        if default_whitelist.exists():
            args.whitelist_json = str(default_whitelist)
    if args.map_output is None:
        args.map_output = str(map_dir / f"{target_name}_{timestamp}.json")
    if args.map_methods is None:
        args.map_methods = str(map_dir / f"method_map_{target_name}_{timestamp}.json")

    print(f"📦 Archive 模式: target={target_name}")
    print(f"   类型映射: {args.map_output}")
    print(f"   方法映射: {args.map_methods}")


def resolve_effective_scan_dirs(scan_dirs: list) -> list:
    # 规则和替换都必须按整个项目扫描，避免 3.0 子目录运行时漏掉其他模块、Pods、Factorys 中的定义与引用。
    return list(DEFAULT_SCAN_DIRS)

# ── 主流程 ────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser(description="Swift 符号混淆工具")
    parser.add_argument("--scan-dir", nargs="+", default=None,
                        help="兼容保留的扫描目录参数；实际混淆规则统一按整个项目扫描（默认: .）")
    parser.add_argument("--apply", action="store_true",
                        help="实际写入文件（不加此参数为 dry-run 预览）")
    parser.add_argument("--archive-mode", action="store_true",
                        help="用于 Archive/打包阶段：自动应用混淆、生成类型和方法映射到 obfuscation_maps，并尽量使用仓库默认配置。")
    parser.add_argument("--target-name", default=None,
                        help="Archive 模式下的目标名；默认读取 TARGET_NAME 环境变量。")
    parser.add_argument("--timestamp", default=None,
                        help="Archive 模式下的时间戳；默认读取 OBF_TIMESTAMP 或当前时间。")
    parser.add_argument("--map-dir", default=None,
                        help="Archive 模式下映射文件输出目录（默认: obfuscation_maps）。")
    parser.add_argument("--generate-patch-dir", metavar="PATCH_DIR", default=None,
                        help="生成补丁到指定目录（不直接修改源码，便于审阅）")
    parser.add_argument("--map-output", default=None,
                        help=f"映射表输出路径（默认: {MAP_OUTPUT_PATH})")
    parser.add_argument("--deobfuscate", metavar="CRASH_LOG",
                        help="还原 crash 日志中的符号，需配合 --map-output 指向已有映射表")
    parser.add_argument("--map-input", default=MAP_OUTPUT_PATH,
                        help="反混淆时使用的映射表（默认同 --map-output）")
    parser.add_argument("--whitelist-json", metavar="JSON_FILE", default=None,
                        help="从 must_keep_summary.json 等文件读取额外白名单（'critical'/'high' severity 符号自动加入白名单）")
    parser.add_argument("--salt", default=None,
                        help="自定义混淆盐值（默认自动随机生成；用于保证每次打包映射不同）")
    parser.add_argument("--enable-methods", dest="enable_methods", action="store_true",
                        help="启用方法级别混淆（dry-run 仅生成方法映射）。")
    parser.add_argument("--map-methods", dest="map_methods", default=None,
                        help="方法映射输出路径（dry-run）：默认 tmp_method_map.json")
    parser.add_argument("--fast-scan", dest="fast_scan", action="store_true",
                        help="启用快速扫描：优先使用 ripgrep(rg) 或 grep 批量匹配映射键，显著加速大仓库统计。")
    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS,
                        help=f"文件级并行工作线程数（默认: {DEFAULT_WORKERS}）")
    objc_group = parser.add_mutually_exclusive_group()
    objc_group.add_argument("--enable-objc-symbols", dest="enable_objc_symbols", action="store_true",
                            help="启用 Obj-C 符号混淆（默认开启）。")
    objc_group.add_argument("--disable-objc-symbols", dest="enable_objc_symbols", action="store_false",
                            help="关闭 Obj-C 符号混淆，仅混淆 Swift 符号。")
    parser.set_defaults(enable_objc_symbols=True)
    parser.add_argument("--restore-source-from-map-dir", metavar="MAP_DIR", default=None,
                        help="根据目录下全部映射文件反向恢复源码，例如 obfuscation_maps")
    parser.add_argument("--rewrite-imports", action="store_true",
                        help="(危险) 允许替换 `#import \"X.h\"` 行，并尝试重命名对应头文件以匹配混淆后的名称。")
    parser.add_argument("--verbose-changes", action="store_true",
                        help="输出每个变更文件及符号命中明细；Archive 模式默认只输出摘要以减少耗时。")
    args = parser.parse_args()
    total_started_at = time.perf_counter()

    # 任何操作前先检查并恢复上次中断的 apply
    restore_from_apply_state_if_needed()

    apply_archive_mode_defaults(args)

    # Enable risky import rewriting if requested
    global REWRITE_IMPORTS_ALLOWED
    if getattr(args, 'rewrite_imports', False):
        REWRITE_IMPORTS_ALLOWED = True

    if args.restore_source_from_map_dir:
        restore_sources_from_maps(args.scan_dir, args.restore_source_from_map_dir)
        _log_stage_duration("本次执行总耗时", total_started_at)
        return

    # ── 反混淆模式
    if args.deobfuscate:
        deobfuscate_crash(args.deobfuscate, args.map_input)
        _log_stage_duration("本次执行总耗时", total_started_at)
        return

    effective_scan_dirs = resolve_effective_scan_dirs(args.scan_dir)

    # 每次执行默认随机盐值，确保映射每次都不同；可用 --salt 固定以复现
    run_salt = args.salt or f"run_{secrets.token_hex(8)}"
    print(f"🎲 本次混淆盐值: {run_salt}")

    # ── 加载外部白名单（打包时传入 must_keep_summary.json）
    if args.whitelist_json:
        try:
            wl_data = json.loads(Path(args.whitelist_json).read_text(encoding="utf-8"))
            added = 0
            for entry in wl_data:
                sev = entry.get("severity", "low")
                sym = entry.get("symbol", "")
                if sym and sev in ("critical", "high"):
                    SYMBOL_WHITELIST.add(sym)
                    added += 1
            print(f"🛡️  从 {args.whitelist_json} 加载 {added} 个白名单符号（critical/high）")
        except Exception as e:
            print(f"⚠️  加载白名单文件失败: {e}")

    # ── 扫描
    if args.scan_dir != effective_scan_dirs:
        print(f"📂 请求扫描目录: {args.scan_dir}")
        print(f"📂 实际扫描目录: {effective_scan_dirs}（规则统一按整个项目执行）")
    else:
        print(f"📂 扫描目录: {effective_scan_dirs}")
    ensure_ios_system_symbols_loaded()
    ensure_third_party_protocol_methods_loaded(effective_scan_dirs)
    swift_files = collect_swift_files(effective_scan_dirs)
    objc_files = collect_objc_files(effective_scan_dirs)
    method_candidate_files = collect_method_candidate_files(effective_scan_dirs) if args.enable_methods else []
    print(f"   找到 {len(swift_files)} 个 Swift 文件，{len(objc_files)} 个 Obj-C 文件（已排除 .build/Pods/Tests 等）")
    if args.enable_methods:
        print(f"   方法候选文件 {len(method_candidate_files)} 个（rg 预筛后）")

    # ── 提取符号
    print("🔍 提取资源字符串以建立白名单（storyboard/xib）...")
    resource_strings = collect_resource_strings(effective_scan_dirs)
    for s in resource_strings:
        SYMBOL_WHITELIST.add(s)

    print("🔍 探测 Obj-C 中的选择器字面量并加入白名单...")
    selector_literals = collect_selector_literals(objc_files)
    for s in selector_literals:
        SYMBOL_WHITELIST.add(s)

    print("🔍 汇总项目属性成员白名单（支持缓存增量复用）...")
    ensure_project_property_members_loaded(effective_scan_dirs)

    print(f"🔍 动态探测 Obj-C 点语法 getter，并同步到 {PROJECT_METHOD_IGNORE_FILE_PATH}...")
    detected_dot_syntax_methods, ignore_file_updated = sync_detected_objc_dot_syntax_method_ignores(effective_scan_dirs)
    print(
        f"   自动忽略 {len(detected_dot_syntax_methods)} 个 Obj-C 零参方法"
        + ("，已更新项目忽略列表" if ignore_file_updated else "")
    )

    print("🔍 提取 canonical symbol 表（按构建生成映射）...")
    canonical_tables = build_canonical_symbol_tables(
        swift_files,
        objc_files,
        method_candidate_files,
        enable_objc_symbols=args.enable_objc_symbols,
        prefilter_files=lambda files, pattern: prefilter_files_with_rg(files, pattern, chunk_size=RG_CHUNK_SIZE),
        type_pattern=TYPE_DECLARATION_RG_PATTERN,
        method_pattern=METHOD_DECLARATION_RG_PATTERN,
        extract_swift_symbols=extract_symbols_from_file,
        extract_objc_symbols=extract_objc_symbols_from_file,
        extract_methods=extract_methods_from_file,
        objc_symbol_prefixes=OBJC_SYMBOL_PREFIXES,
        already_obfuscated_re=ALREADY_OBFUSCATED_RE,
        symbol_whitelist=SYMBOL_WHITELIST,
        symbol_prefix_whitelist=SYMBOL_PREFIX_WHITELIST,
        is_system_method=is_system_method,
        split_swift_signature_key=_split_swift_signature_key,
    )
    save_extraction_cache()
    print(f"🧾 canonical digest: {canonical_tables['digest'][:12]}")

    mapping_swift, mapping_objc = build_type_mappings_from_canonical_table(
        canonical_tables,
        run_salt,
        enable_objc_symbols=args.enable_objc_symbols,
        build_unique_mapping=build_unique_mapping,
        type_prefix=TYPE_OBFUSCATED_PREFIX,
    )
    if not args.enable_objc_symbols:
        print("⚠️  已显式关闭 Obj-C 符号混淆，本次仅混淆 Swift 符号")
    # 合并映射（优先保留 Swift 映射同名 -> 确保一致）
    mapping = {}
    mapping.update(mapping_objc)
    mapping.update(mapping_swift)

    # 方法映射（dry-run 输出）
    if args.enable_methods:
        print("🔍 按本次构建盐值生成方法映射...")
        mapping_methods = build_method_mapping_from_canonical_table(
            canonical_tables,
            run_salt,
            build_unique_mapping=build_unique_mapping,
            method_prefix=METHOD_OBFUSCATED_PREFIX,
        )
        # 移除本地生成的原生 Swift signature 条目，保留 Obj-C selector / 直接方法条目。
        mapping_methods = {
            k: v for k, v in mapping_methods.items()
            if not (isinstance(v, dict) and v.get('kind') == 'swift_signature')
        }
        mapping_methods, unsafe_bases, dropped_signatures = _drop_unsafe_generated_swift_signature_entries(mapping_methods)
        if dropped_signatures:
            preview = ", ".join(sorted(unsafe_bases)[:5])
            suffix = " ..." if len(unsafe_bases) > 5 else ""
            print(
                f"⚠️  跳过 {len(dropped_signatures)} 个存在重叠调用形态的 Swift 参数标签映射，"
                f"涉及 {len(unsafe_bases)} 个方法基名: {preview}{suffix}"
            )
        with open(args.map_methods, "w", encoding="utf-8") as mf:
            json.dump(mapping_methods, mf, ensure_ascii=False, indent=2)
        print(f"💾 方法映射已保存: {args.map_methods} （dry-run）")

    print(f"   共发现 {len(mapping)} 个可混淆类型名（包含 Swift + Obj-C ）")

    if not mapping:
        print("⚠️  没有找到可混淆的符号，请检查扫描目录和过滤规则。")
        _log_stage_duration("本次执行总耗时", total_started_at)
        sys.exit(0)

    # ── 预览前 30 条
    print("\n── 混淆预览（前 30 条）──────────────────────────────────────")
    for i, (orig, obf) in enumerate(sorted(mapping.items())):
        if i >= 30:
            print(f"   ... 还有 {len(mapping) - 30} 条")
            break
        print(f"   {orig:50s} → {obf}")

    # ── 保存映射表
    with open(args.map_output, "w", encoding="utf-8") as f:
        json.dump(mapping, f, ensure_ascii=False, indent=2)
    print(f"\n💾 映射表已保存: {args.map_output}  （请妥善保管，用于 crash 还原）")

    if not args.apply:
        print("\n⚠️  Dry-run 模式，未修改任何文件。加 --apply 参数执行实际替换。")
        _log_stage_duration("本次执行总耗时", total_started_at)
        return

    # 如果启用了方法级别混淆并且存在方法映射文件，把方法映射合并进 mapping
    method_direct_mapping = {}
    objc_selector_mapping = {}
    swift_signature_mapping = {}
    selector_display_mapping = {}
    swift_signature_display_mapping = {}
    if args.enable_methods and args.map_methods and os.path.exists(args.map_methods):
        try:
            method_direct_mapping, objc_selector_mapping, swift_signature_mapping = load_method_obfuscation_maps(args.map_methods)
            selector_display_mapping = build_selector_display_mapping(objc_selector_mapping)
            swift_signature_display_mapping = build_swift_signature_display_mapping(method_direct_mapping, swift_signature_mapping)
        except Exception as e:
            print(f"⚠️  加载方法映射失败: {e}")

    # 统计映射键在源码中的命中次数，生成未命中报告供审查
    count_stage_started_at = time.perf_counter()
    try:
        source_files_for_search = collect_apply_target_files(effective_scan_dirs, args.enable_objc_symbols)
        occurrences = {}
        keys = list(mapping.keys())
        mapping_re = build_mapping_regex(mapping)
        mapping_aho = build_aho_automaton(mapping)

        def _fast_count_with_rg(keys_list, scan_dirs):
            import subprocess
            from tempfile import NamedTemporaryFile
            counts = {k: 0 for k in keys_list}
            keysfile = None
            try:
                with NamedTemporaryFile('w', delete=False, encoding='utf-8') as tf:
                    for k in keys_list:
                        tf.write(k + "\n")
                    keysfile = tf.name
                rg = shutil.which('rg')
                if rg:
                    # -n: show line number, -o: only matching, -F: fixed strings, -f: patterns file
                    cmd = [rg, '-n', '-o', '-F', '-f', keysfile, '--no-messages', '-S'] + list(scan_dirs)
                    out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, encoding='utf-8')
                    for ln in out.splitlines():
                        # format: path:line:matched_text
                        parts = ln.split(':', 2)
                        if len(parts) == 3:
                            matched = parts[2]
                            if matched in counts:
                                counts[matched] += 1
                    return counts
                # fallback to grep if rg not available
                grep = shutil.which('grep')
                if grep:
                    cmd = [grep, '-R', '-n', '-o', '-F', '-f', keysfile] + list(scan_dirs)
                    out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, encoding='utf-8')
                    for ln in out.splitlines():
                        # grep format: path:line:matched_text
                        parts = ln.split(':', 2)
                        if len(parts) == 3:
                            matched = parts[2]
                            if matched in counts:
                                counts[matched] += 1
                    return counts
            except subprocess.CalledProcessError:
                # no matches -> return zero counts
                return counts
            except Exception:
                return counts
            finally:
                if keysfile:
                    try:
                        os.unlink(keysfile)
                    except Exception:
                        pass

        if args.fast_scan:
            print("⚡ 使用快速扫描（rg/grep）统计映射键命中...")
            occurrences = _fast_count_with_rg(keys, effective_scan_dirs)
        else:
            print(f"⚡ 使用单次扫描聚合统计映射键命中（workers={args.workers}）...")
            occurrences = count_mapping_occurrences(source_files_for_search, mapping_re, workers=args.workers, mapping_aho=mapping_aho)
            for key in keys:
                occurrences.setdefault(key, 0)
        unmapped = [k for k, v in occurrences.items() if v == 0]
        mapped = [k for k, v in occurrences.items() if v > 0]
        report = {
            'total_keys': len(occurrences),
            'mapped': len(mapped),
            'unmapped': len(unmapped),
            'unmapped_list': unmapped[:1000]
        }
        Path('unmapped_mappings.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
        print(f"\n🔎 未命中报告已写入: unmapped_mappings.json（{len(unmapped)} 未命中，共 {len(occurrences)} 键）")
        if unmapped:
            print("前 200 个未命中示例:")
            for i, k in enumerate(unmapped[:200], start=1):
                print(f"  {i:3d}. {k}")
    except Exception as e:
        print(f"⚠️  生成未命中报告出错: {e}")
    finally:
        _log_stage_duration("混淆统计", count_stage_started_at)

    # ── 生成替换计划（不一定立即写入）
    print("\n✏️  生成替换计划（未必直接写入）...")
    planning_stage_started_at = time.perf_counter()
    total_changed = 0
    all_targets = collect_apply_target_files(effective_scan_dirs, args.enable_objc_symbols)
    mapping_re = build_mapping_regex(mapping)
    mapping_aho = build_aho_automaton(mapping)
    display_mapping = dict(mapping)
    display_mapping.update(method_direct_mapping)
    display_mapping.update(selector_display_mapping)
    display_mapping.update(swift_signature_display_mapping)
    planned_changes = {}
    # build mapping hash for cache invalidation
    mapping_hash = hashlib.sha256(
        json.dumps({
            'mapping': mapping,
            'direct_method_mapping': method_direct_mapping,
            'objc_selector_mapping': objc_selector_mapping,
            'swift_signature_mapping': swift_signature_mapping,
        }, sort_keys=True).encode()
    ).hexdigest()
    cache = load_cache()
    cache_files = cache.get('files', {}) if isinstance(cache.get('files', {}), dict) else {}

    # determine which files need processing: changed mtime or mapping changed
    files_to_process = []
    for p in all_targets:
        try:
            mtime = os.path.getmtime(p)
        except Exception:
            mtime = None
        prev = cache_files.get(p)
        if cache.get('mapping_hash') != mapping_hash or prev != mtime:
            files_to_process.append(p)

    print(f"🔁 总目标文件 {len(all_targets)}，需处理 {len(files_to_process)}（基于缓存）")

    if args.workers > 1 and len(files_to_process) >= 20:
        # Avoid returning full file contents over multiprocessing pipes in archive mode.
        # Use threads and flush per-file patches to disk when --generate-patch-dir is used
        # to reduce memory pressure and allow inspecting progress live.
        write_patches_live = bool(args.generate_patch_dir)
        patch_dir = Path(args.generate_patch_dir) if write_patches_live else None
        if write_patches_live:
            patch_dir.mkdir(parents=True, exist_ok=True)
            manifest = {}

        with ThreadPoolExecutor(max_workers=args.workers) as executor:
            future_map = {
                executor.submit(
                    plan_file_change,
                    path,
                    mapping,
                    mapping_re,
                    objc_selector_mapping,
                    swift_signature_mapping,
                    mapping_aho,
                    method_direct_mapping,
                ): path
                for path in files_to_process
            }
            for idx, future in enumerate(as_completed(future_map), start=1):
                path = future_map[future]
                try:
                    path, changed, stats, new_text, original_text = future.result()
                except Exception as e:
                    print(f"⚠️  并行规划失败，文件: {path}，错误: {e}")
                    raise
                if changed:
                    if write_patches_live:
                        rel = Path(path).relative_to(Path('.'))
                        out_orig = patch_dir / (str(rel) + '.orig')
                        out_new = patch_dir / (str(rel) + '.new')
                        out_orig.parent.mkdir(parents=True, exist_ok=True)
                        try:
                            out_orig.write_text(original_text, encoding='utf-8')
                            out_new.write_text(new_text, encoding='utf-8')
                        except Exception:
                            # best-effort write
                            pass
                        manifest[str(rel)] = {'stats': stats}
                    else:
                        planned_changes[path] = {
                            'stats': stats,
                            'new_text': new_text,
                        }
                        if not args.archive_mode or args.generate_patch_dir:
                            planned_changes[path]['original_text'] = original_text
                    total_changed += 1
                if idx % 50 == 0:
                    print(f"   ... 进度 {idx}/{len(files_to_process)}")
        if write_patches_live:
            # finalize manifest
            try:
                manifest_path = patch_dir / 'manifest.json'
                manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding='utf-8')
                print(f"✅ 补丁已生成到: {patch_dir} （包含 .orig/.new 文件及 manifest.json），未修改源码。")
            except Exception as e:
                print(f"⚠️ 无法写入补丁 manifest: {e}")
            _log_stage_duration("替换规划", planning_stage_started_at)
            _log_stage_duration("本次执行总耗时", total_started_at)
            return
    else:
        for idx, path in enumerate(files_to_process, start=1):
            path, changed, stats, new_text, original_text = plan_file_change(path, mapping, mapping_re, objc_selector_mapping, swift_signature_mapping, mapping_aho, method_direct_mapping)
            if changed:
                planned_changes[path] = {
                    'stats': stats,
                    'new_text': new_text,
                }
                if not args.archive_mode or args.generate_patch_dir:
                    planned_changes[path]['original_text'] = original_text
                total_changed += 1
            if idx % 50 == 0:
                print(f"   ... 进度 {idx}/{len(files_to_process)}")

    # update cache for processed files
    for p in files_to_process:
        try:
            cache_files[p] = os.path.getmtime(p)
        except Exception:
            cache_files[p] = None
    cache_out = {'mapping_hash': mapping_hash, 'files': cache_files}
    save_cache(cache_out)
    _log_stage_duration("替换规划", planning_stage_started_at)

    if total_changed == 0:
        print(f"\n✅ 预览完成：没有检测到要修改的文件（0/{len(all_targets)})。")
        print(f"   映射表: {args.map_output}")
        print("   若需实际应用，请使用 --apply")
        _log_stage_duration("本次执行总耗时", total_started_at)
        return

    # 如果指定了补丁目录，则把 planned_changes 写到该目录用于审阅（不修改源码）
    if args.generate_patch_dir:
        patch_dir = Path(args.generate_patch_dir)
        patch_dir.mkdir(parents=True, exist_ok=True)
        manifest = {}
        for path, info in planned_changes.items():
            rel = Path(path).relative_to(Path('.'))
            out_orig = patch_dir / (str(rel) + '.orig')
            out_new = patch_dir / (str(rel) + '.new')
            out_orig.parent.mkdir(parents=True, exist_ok=True)
            out_orig.write_text(info['original_text'], encoding='utf-8')
            out_new.write_text(info['new_text'], encoding='utf-8')
            manifest[str(rel)] = {'stats': info['stats']}
        manifest_path = patch_dir / 'manifest.json'
        manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding='utf-8')
        print(f"✅ 补丁已生成到: {patch_dir} （包含 .orig/.new 文件及 manifest.json），未修改源码。")
        _log_stage_duration("本次执行总耗时", total_started_at)
        return

    write_stage_started_at = time.perf_counter()
    changed_files = sorted(planned_changes.keys())
    if args.archive_mode:
        direct_write(planned_changes)
    else:
        transactional_write(planned_changes)
    _log_stage_duration("源码写入", write_stage_started_at)

    if args.verbose_changes:
        for path in changed_files:
            print(f"   ✔ {path}")
            for sym, cnt in planned_changes[path]["stats"].items():
                target = display_mapping.get(sym, mapping.get(sym, sym))
                print(f"       {sym} → {target}  ×{cnt}")
    else:
        print(f"   已省略 {len(changed_files)} 个变更文件明细；如需查看可加 --verbose-changes")

    print(f"\n✅ 完成！修改了 {total_changed}/{len(all_targets)} 个文件。")
    print(f"   映射表: {args.map_output}")
    print("   恢复 crash 符号: python3 AutoPacking/obfuscation/obfuscate_symbols.py --deobfuscate your.crash")
    _log_stage_duration("本次执行总耗时", total_started_at)


if __name__ == "__main__":
    try:
        main()
    except Exception:
        import traceback
        tb = traceback.format_exc()
        sys.stderr.write("FATAL: 未捕获异常，详细信息写入 obfuscate_error.log\n")
        try:
            Path('obfuscate_error.log').write_text(tb, encoding='utf-8')
        except Exception:
            pass
        sys.stderr.write(tb)
        sys.exit(2)