package com.hikoncont.service.modules

import android.content.Context
import android.content.Intent
import android.provider.Settings
import android.util.Log
import android.accessibilityservice.AccessibilityServiceInfo
import android.view.accessibility.AccessibilityManager
import kotlinx.coroutines.delay
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

/**
 * Vivo无障碍服务故障恢复处理器
 * 专门处理Vivo设备上无障碍服务故障后的恢复逻辑
 */
class VivoAccessibilityRecovery(private val context: Context) {

    companion object {
        private const val TAG = "VivoAccessibilityRecovery"
        private const val MAX_RECOVERY_ATTEMPTS = 3
        private const val RECOVERY_DELAY = 2000L
        private const val VIVO_BRAND = "vivo"
        private const val VIVO_MANUFACTURER = "vivo"
    }

    /**
     * 检查是否为Vivo设备
     */
    private fun isVivoDevice(): Boolean {
        val brand = android.os.Build.BRAND?.lowercase() ?: ""
        val manufacturer = android.os.Build.MANUFACTURER?.lowercase() ?: ""
        return brand.contains(VIVO_BRAND) || manufacturer.contains(VIVO_MANUFACTURER)
    }

    /**
     * 检查无障碍服务状态
     */
    fun checkAccessibilityServiceStatus(): AccessibilityServiceStatus {
        return try {
            val accessibilityManager = context.getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager
            val enabledServices = accessibilityManager.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK)
            val serviceId = "com.hikoncont/com.hikoncont.service.AccessibilityRemoteService"
            
            val isEnabled = enabledServices.any { it.id == serviceId }
            val isRunning = com.hikoncont.service.AccessibilityRemoteService.getInstance() != null
            
            Log.d(TAG, "🔍 无障碍服务状态检查: enabled=$isEnabled, running=$isRunning")
            
            AccessibilityServiceStatus(
                isEnabled = isEnabled,
                isRunning = isRunning,
                enabledServices = enabledServices.map { it.id }
            )
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查无障碍服务状态失败", e)
            AccessibilityServiceStatus()
        }
    }

    /**
     * Vivo特定的无障碍服务恢复策略
     */
    suspend fun recoverAccessibilityService(): Boolean {
        if (!isVivoDevice()) {
            Log.d(TAG, "📱 非Vivo设备，跳过Vivo特定恢复策略")
            return false
        }

        Log.i(TAG, "🔄 开始Vivo无障碍服务恢复")
        
        val status = checkAccessibilityServiceStatus()
        
        return when {
            !status.isEnabled -> {
                Log.w(TAG, "⚠️ 无障碍服务未启用，引导用户手动启用")
                guideUserToEnableAccessibility()
            }
            status.isEnabled && !status.isRunning -> {
                // ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
                Log.d(TAG, "📱 无障碍服务已启用但未运行，系统会自动管理无障碍服务生命周期")
                false
            }
            else -> {
                Log.i(TAG, "✅ 无障碍服务状态正常")
                true
            }
        }
    }

    /**
     * 引导用户手动启用无障碍服务
     */
    private suspend fun guideUserToEnableAccessibility(): Boolean {
        return try {
            Log.i(TAG, "📱 引导用户到无障碍设置页面")
            
            // 打开无障碍设置页面
            val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS).apply {
                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
            }
            context.startActivity(intent)
            
            // 等待用户操作
            delay(3000L)
            
            // 检查是否已启用
            val newStatus = checkAccessibilityServiceStatus()
            if (newStatus.isEnabled) {
                Log.i(TAG, "✅ 用户已启用无障碍服务")
                true
            } else {
                Log.w(TAG, "⚠️ 用户未启用无障碍服务")
                false
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 引导用户启用无障碍服务失败", e)
            false
        }
    }

    /**
     * Vivo特定的恢复策略
     */
    private suspend fun performVivoSpecificRecovery(): Boolean {
        return try {
            Log.i(TAG, "🔄 执行Vivo特定恢复策略")
            
            // ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
            Log.d(TAG, "📱 无障碍服务由系统自动管理，无需手动重启")
            
            // 只检查服务状态，不执行重启操作
            val status = checkAccessibilityServiceStatus()
            if (status.isRunning) {
                Log.i(TAG, "✅ 无障碍服务运行正常")
                return true
            } else {
                Log.w(TAG, "⚠️ 无障碍服务未运行，系统会自动管理")
                return false
            }
            
            Log.w(TAG, "❌ 所有Vivo恢复策略都失败")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ Vivo特定恢复失败", e)
            false
        }
    }

    // ✅ 参考 f 目录：已移除重启无障碍服务的功能，系统会自动管理无障碍服务生命周期

    /**
     * 清除无障碍服务缓存
     */


    /**
     * 重新启用无障碍服务
     */
    private suspend fun reenableAccessibilityService(): Boolean {
        return try {
            Log.d(TAG, "🔄 尝试重新启用无障碍服务")
            
            // 先禁用再启用
            val disableIntent = Intent("android.mycustrecev.ACCESSIBILITY_SERVICE_DISABLE")
            context.sendBroadcast(disableIntent)
            
            delay(1000L)
            
            val enableIntent = Intent("android.mycustrecev.ACCESSIBILITY_SERVICE_ENABLE")
            context.sendBroadcast(enableIntent)
            
            delay(2000L)
            
            // 检查是否启用成功
            val status = checkAccessibilityServiceStatus()
            status.isEnabled && status.isRunning
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重新启用无障碍服务失败", e)
            false
        }
    }

    /**
     * 防止APP闪退的降级处理
     */
    fun preventAppCrash(): Boolean {
        return try {
            Log.i(TAG, "🛡️ 启动APP闪退防护")
            
            // 检查无障碍服务状态
            val status = checkAccessibilityServiceStatus()
            
            if (!status.isEnabled) {
                Log.w(TAG, "⚠️ 无障碍服务未启用，启动降级模式")
                startDegradedMode()
                return true
            }
            
            if (status.isEnabled && !status.isRunning) {
                Log.w(TAG, "⚠️ 无障碍服务故障，启动恢复模式")
                startRecoveryMode()
                return true
            }
            
            Log.i(TAG, "✅ 无障碍服务正常，无需防护")
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ APP闪退防护失败", e)
            false
        }
    }

    /**
     * 启动降级模式
     */
    private fun startDegradedMode() {
        try {
            Log.i(TAG, "📱 启动降级模式：禁用部分功能，保持APP稳定")
            
            // 禁用保活服务
            val disableKeepAliveIntent = Intent("android.mycustrecev.DISABLE_KEEPALIVE")
            context.sendBroadcast(disableKeepAliveIntent)
            
            // 启动基础服务
            val basicServiceIntent = Intent(context, com.hikoncont.service.RemoteControlForegroundService::class.java)
            context.startForegroundService(basicServiceIntent)
            
            Log.i(TAG, "✅ 降级模式已启动")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动降级模式失败", e)
        }
    }

    /**
     * 启动恢复模式
     */
    private fun startRecoveryMode() {
        try {
            Log.i(TAG, "🔄 启动恢复模式：尝试恢复无障碍服务")
            
            // 启动恢复协程
            CoroutineScope(Dispatchers.IO).launch {
                var attempts = 0
                while (attempts < MAX_RECOVERY_ATTEMPTS) {
                    attempts++
                    Log.d(TAG, "🔄 恢复尝试 $attempts/$MAX_RECOVERY_ATTEMPTS")
                    
                    if (recoverAccessibilityService()) {
                        Log.i(TAG, "✅ 无障碍服务恢复成功")
                        break
                    }
                    
                    delay(RECOVERY_DELAY)
                }
                
                if (attempts >= MAX_RECOVERY_ATTEMPTS) {
                    Log.w(TAG, "⚠️ 恢复失败，启动降级模式")
                    startDegradedMode()
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动恢复模式失败", e)
        }
    }

    /**
     * 无障碍服务状态数据类
     */
    data class AccessibilityServiceStatus(
        val isEnabled: Boolean = false,
        val isRunning: Boolean = false,
        val enabledServices: List<String> = emptyList()
    ) {
        override fun toString(): String {
            return "AccessibilityServiceStatus(isEnabled=$isEnabled, isRunning=$isRunning, enabledServices=$enabledServices)"
        }
    }
}
