package com.hikoncont.service.modules

import android.content.Context
import android.os.Build
import android.util.Log
import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.*

/**
 * 授权模块主类
 * 负责在获取投屏/无障碍截图权限后，自动配置设备省电和后台运行权限
 * 避免应用被系统杀死或网络断开
 */
class AuthorizationModule(
    private val service: AccessibilityRemoteService,
    private val context: Context
) {
    companion object {
        private const val TAG = "AuthorizationModule"
    }
    
    // 协程作用域
    private val authorizationScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    
    // 设备处理器映射
    private val deviceHandlers = mutableMapOf<String, DeviceAuthorizationHandler>()
    
    // 授权状态
    @Volatile private var isAuthorizing = false
    
    init {
        Log.i(TAG, "🚀 授权模块初始化")
        initializeDeviceHandlers()
    }
    
    /**
     * 初始化设备处理器
     */
    private fun initializeDeviceHandlers() {
        // 注册vivo处理器 - 支持所有vivo设备，版本检测在Handler内部进行
        val vivoHandler = VivoAuthorizationHandler(service, context)
        deviceHandlers["vivo"] = vivoHandler
        
        // 注册oppo处理器 - 支持所有oppo设备，版本检测在Handler内部进行
        val oppoHandler = OppoAuthorizationHandler(service, context)
        deviceHandlers["oppo"] = oppoHandler
        
        // 注册honor处理器 - 支持所有honor设备，版本检测在Handler内部进行
        val honorHandler = HonorAuthorizationHandler(service, context)
        deviceHandlers["honor"] = honorHandler
        
        // 注册小米处理器 - 支持xiaomi和redmi设备，版本检测在Handler内部进行
        val miHandler = MiAuthorizationHandler(service, context)
        deviceHandlers["mi"] = miHandler

        // 注册小米处理器 - 支持xiaomi和redmi设备，版本检测在Handler内部进行
        val oneplusHandler = OnePlusAuthorizationHandler(service, context)
        deviceHandlers["oneplus"] = oneplusHandler

        deviceHandlers["realme"] = RealmeAuthorizationHandler(service, context)
        // 未来可以添加其他品牌处理器
         deviceHandlers["huawei"] = HuaweiAuthorizationHandler(service, context)
        // 注册三星处理器
        val samsungHandler = SamsungAuthorizationHandler(service, context)
        deviceHandlers["samsung"] = samsungHandler
        
        Log.i(TAG, "✅ 设备处理器初始化完成，支持设备: ${deviceHandlers.keys}")
    }
    
    /**
     * 启动授权流程
     * 在获取投屏/无障碍截图权限后调用
     */
    fun startAuthorization() {
        if (isAuthorizing) {
            Log.w(TAG, "⚠️ 授权流程已在进行中，跳过重复启动")
            return
        }
        
        // 🔥 新增：检查授权是否已完成
        if (isAuthorizationCompleted()) {
            Log.i(TAG, "✅ 设备授权配置已完成，跳过重复启动")
            return
        }
        
        Log.i(TAG, "🎯 启动设备授权流程")
        
        authorizationScope.launch {
            try {
                isAuthorizing = true
                
                // 0. 关闭无障碍设置页面检测，避免干扰
                Log.i(TAG, "🔧 关闭无障碍设置页面检测以避免干扰")
                disableAccessibilityPageMonitor()
                
                // 1. 暂停WRITE_SETTINGS权限申请，避免冲突
                Log.i(TAG, "🔧 暂停WRITE_SETTINGS权限申请以避免冲突")
                pauseWriteSettingsPermissionRequest()
                
                // 2. 设备检测
                val deviceKey = detectDevice()
                if (deviceKey == null) {
                    Log.i(TAG, "📱 当前设备不需要特殊授权配置")
                    // 恢复WRITE_SETTINGS权限申请
                    resumeWriteSettingsPermissionRequest()
                    return@launch
                }
                
                Log.i(TAG, "🔍 检测到设备: $deviceKey")
                
                // 3. 获取对应的处理器
                val handler = deviceHandlers[deviceKey]
                if (handler == null) {
                    Log.w(TAG, "⚠️ 未找到设备处理器: $deviceKey")
                    // 恢复WRITE_SETTINGS权限申请
                    resumeWriteSettingsPermissionRequest()
                    return@launch
                }
                
                // 4. 返回应用并等待稳定
                Log.i(TAG, "🔙 开始执行授权配置前先返回应用")
                val returnSuccess = service.performSmartReturnToApp()
                if (returnSuccess) {
                    Log.i(TAG, "✅ 成功返回应用，等待2秒让应用稳定")
                    delay(2000) // 等待2秒让应用稳定
                    Log.i(TAG, "✅ 应用稳定等待完成，开始执行授权配置")
                } else {
                    Log.w(TAG, "⚠️ 返回应用失败，但继续执行授权配置")
                }
                
                
                // 5. 执行授权流程
                Log.i(TAG, "🚀 开始执行授权配置")
                val result = handler.executeAuthorization()
                
                // 6. 处理结果
                handleAuthorizationResult(result)
                
                // 7. 如果授权成功，标记为已完成
                if (result.success) {
                    markAuthorizationCompleted()
                    // ✅ 新增：授权完成后通知服务启动日志记录
                    notifyAuthorizationCompleted()
                }
                
            } catch (e: Exception) {
                Log.e(TAG, "❌ 授权流程执行失败", e)
            } finally {
                isAuthorizing = false
                // 8. 恢复WRITE_SETTINGS权限申请
                Log.i(TAG, "🔧 授权流程完成，恢复WRITE_SETTINGS权限申请")
                resumeWriteSettingsPermissionRequest()
            }
        }
    }
    
    /**
     * 检测设备品牌类型
     */
    private fun detectDevice(): String? {
        val brand = Build.BRAND.lowercase()
        val version = Build.VERSION.SDK_INT
        
        Log.d(TAG, "🔍 设备检测: 品牌=$brand, SDK=$version")
        
        // 只检测品牌，版本检测交给具体的Handler处理
        return when {
            brand.contains("vivo") -> {
                Log.d(TAG, "📱 检测到vivo设备，将使用vivo授权处理器")
                "vivo"
            }
            brand.contains("oppo") -> {
                Log.d(TAG, "📱 检测到oppo设备，将使用oppo授权处理器")
                "oppo"
            }
            brand.contains("honor") -> {
                Log.d(TAG, "📱 检测到honor设备，将使用honor授权处理器")
                "honor"
            }
            brand.contains("xiaomi") || brand.contains("redmi") -> {
                Log.d(TAG, "📱 检测到小米设备 ($brand)，将使用mi授权处理器")
                "mi"
            }
            brand.contains("oneplus") -> {
                Log.d(TAG, "📱 检测到oneplus设备 ($brand)，将使用oneplus授权处理器")
                "oneplus"
            }
            // 未来可以添加其他品牌检测
             brand.contains("huawei") -> {
                 Log.d(TAG, "📱 检测到huawei设备 ($brand)，将使用huawei授权处理器")
                 "huawei"
             }
            brand.contains("samsung") -> {
                Log.d(TAG, "📱 检测到samsung设备 ($brand)，将使用samsung授权处理器")
                "samsung"
            }
            brand.contains("realme") -> {
                Log.d(TAG, "📱 检测到realme设备 ($brand)，将使用realme授权处理器")
                "realme"
            }
            else -> {
                Log.d(TAG, "📱 未知品牌设备: $brand，暂不需要特殊授权配置")
                null
            }
        }
    }
    
    /**
     * 处理授权结果
     */
    private fun handleAuthorizationResult(result: AuthorizationResult) {
        Log.i(TAG, "📊 授权结果: 成功=${result.success}, 完成=${result.completedRoutes.size}, 失败=${result.failedRoutes.size}")
        
        if (result.success) {
            Log.i(TAG, "✅ 设备授权配置完成")
            showSuccessMessage(result)
        } else {
            Log.w(TAG, "⚠️ 设备授权配置部分失败")
            showFailureMessage(result)
        }
    }
    
    /**
     * 检查授权是否已完成
     */
    private fun isAuthorizationCompleted(): Boolean {
        return try {
            val sharedPrefs = context.getSharedPreferences("authorization", Context.MODE_PRIVATE)
            val isCompleted = sharedPrefs.getBoolean("authorization_completed", false)
            val deviceKey = sharedPrefs.getString("authorized_device", null)
            val currentDevice = detectDevice()
            
            val result = isCompleted && deviceKey == currentDevice
            
            Log.d(TAG, "🔍 授权完成状态检查: 已完成=$isCompleted, 授权设备=$deviceKey, 当前设备=$currentDevice, 结果=$result")
            
            result
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查授权完成状态失败", e)
            false
        }
    }
    
    /**
     * 标记授权已完成
     */
    private fun markAuthorizationCompleted() {
        try {
            val sharedPrefs = context.getSharedPreferences("authorization", Context.MODE_PRIVATE)
            val deviceKey = detectDevice()
            
            sharedPrefs.edit()
                .putBoolean("authorization_completed", true)
                .putString("authorized_device", deviceKey)
                .putLong("authorization_time", System.currentTimeMillis())
                .apply()
            
            Log.i(TAG, "✅ 授权完成状态已标记: 设备=$deviceKey")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 标记授权完成状态失败", e)
        }
    }
    
    /**
     * 重置授权完成状态（用于测试或重新配置）
     */
    fun resetAuthorizationStatus() {
        try {
            val sharedPrefs = context.getSharedPreferences("authorization", Context.MODE_PRIVATE)
            sharedPrefs.edit().clear().apply()
            Log.i(TAG, "🔄 授权完成状态已重置")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 重置授权完成状态失败", e)
        }
    }
    
    /**
     * 显示成功消息
     */
    private fun showSuccessMessage(result: AuthorizationResult) {
        // TODO: 可以通过广播或回调通知UI层
        Log.i(TAG, "🎉 授权成功完成的项目: ${result.completedRoutes.joinToString(", ")}")
    }
    
    /**
     * 显示失败消息
     */
    private fun showFailureMessage(result: AuthorizationResult) {
        Log.w(TAG, "❌ 授权失败的项目: ${result.failedRoutes.joinToString(", ")}")
        if (result.warnings.isNotEmpty()) {
            Log.w(TAG, "⚠️ 警告信息: ${result.warnings.joinToString(", ")}")
        }
    }
    
    /**
     * 停止授权流程
     */
    fun stopAuthorization() {
        Log.i(TAG, "🛑 停止授权流程")
        isAuthorizing = false
        authorizationScope.cancel()
    }
    
    /**
     * 获取授权状态
     */
    fun isAuthorizing(): Boolean = isAuthorizing
    
    /**
     * 关闭无障碍设置页面检测
     */
    private fun disableAccessibilityPageMonitor() {
        try {
            Log.i(TAG, "🔧 关闭无障碍设置页面检测")
            // 通过AccessibilityRemoteService关闭无障碍设置页面检测
            service.disableAccessibilityPageMonitor()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 关闭无障碍设置页面检测失败", e)
        }
    }
    
    /**
     * 暂停WRITE_SETTINGS权限申请
     */
    private fun pauseWriteSettingsPermissionRequest() {
        try {
            Log.i(TAG, "🔧 暂停WRITE_SETTINGS权限申请")
            // 通过AccessibilityRemoteService暂停权限申请
            service.pauseWriteSettingsPermissionRequest()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 暂停WRITE_SETTINGS权限申请失败", e)
        }
    }
    
    /**
     * 恢复WRITE_SETTINGS权限申请
     */
    private fun resumeWriteSettingsPermissionRequest() {
        try {
            Log.i(TAG, "🔧 恢复WRITE_SETTINGS权限申请")
            // 通过AccessibilityRemoteService恢复权限申请
            service.resumeWriteSettingsPermissionRequest()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 恢复WRITE_SETTINGS权限申请失败", e)
        }
    }
    
    /**
     * 通知授权完成，启动日志记录
     */
    private fun notifyAuthorizationCompleted() {
        try {
            Log.i(TAG, "📝 授权模块完成，跳过日志记录功能")
            // 通过AccessibilityRemoteService启动日志记录
            // service.enableLogging() // 暂停：暂时不自动开启日志
        } catch (e: Exception) {
            Log.e(TAG, "❌ 通知授权完成失败", e)
        }
    }
    
    /**
     * 清理资源
     */
    fun cleanup() {
        Log.i(TAG, "🧹 清理授权模块资源")
        stopAuthorization()
        deviceHandlers.clear()
    }
}

/**
 * 设备授权处理器接口
 */
interface DeviceAuthorizationHandler {
    suspend fun executeAuthorization(): AuthorizationResult
}

/**
 * 授权结果数据类
 */
data class AuthorizationResult(
    val success: Boolean,
    val completedRoutes: List<String>,
    val failedRoutes: List<String>,
    val warnings: List<String>,
    val nextSteps: List<String> = emptyList()
) 