package com.hikoncont.service

import android.content.Context
import android.util.Log
import kotlinx.coroutines.*
import com.hikoncont.util.InstallationStateManager

/**
 * 综合保活管理器 - 参考 f 目录的保活策略，简化版本
 * 主要职责：
 * 1. 启动主前台服务（对应 f 目录的 BackRunServerUseUse）
 * 2. 启动 WorkManager 保活（对应 f 目录的系统级 WorkManager）
 * 3. 启动 JobService 保活（对应 f 目录的 MyService）
 * 
 * 参考 f 目录策略：
 * - 只保留必要的保活服务，去掉多余的互保、心跳检测等
 */
class ComprehensiveKeepAliveManager private constructor(private val context: Context) {

    companion object {
        private const val TAG = "ComprehensiveKeepAlive"
        
        @Volatile
        private var INSTANCE: ComprehensiveKeepAliveManager? = null
        
        fun getInstance(context: Context): ComprehensiveKeepAliveManager {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: ComprehensiveKeepAliveManager(context.applicationContext).also { INSTANCE = it }
            }
        }
    }

    private var isStarted = false
    private var isWorkManagerStarted = false
    private val startLock = Any() // 启动锁

    /**
     * 启动综合保活 - 参考 f 目录的简单策略
     * f 目录只启动：BackRunServerUseUse（主前台服务）
     * 我们保留：主前台服务 + WorkManager 保活
     */
    fun startComprehensiveKeepAlive() {
        synchronized(startLock) {
            // 检查是否已在运行
            if (isStarted) {
                Log.w(TAG, "⚠️ 综合保活已在运行，跳过重复启动")
                return
            }
            isStarted = true
        }

        try {
            Log.i(TAG, "🚀 启动综合保活管理器（参考 f 目录策略）")
            
            // ✅ 参考 f 目录：只启动主前台服务和 WorkManager 保活
            // 1. 启动主前台服务（对应 f 目录的 BackRunServerUseUse）
            startMainForegroundService()
            
            // 2. 启动 WorkManager 保活（对应 f 目录的系统级 WorkManager）
            if (!isWorkManagerStarted) {
                startWorkManagerKeepAlive()
                isWorkManagerStarted = true
            }
            
            // 3. ✅ 启动 JobService 定期调度（参考 f 目录的 MyService）
            startJobServiceScheduler()
            
            Log.i(TAG, "✅ 综合保活管理器启动完成")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动综合保活管理器失败", e)
            synchronized(startLock) {
                isStarted = false
            }
        }
    }
    
    /**
     * 启动主前台服务 - 参考 f 目录的 BackRunServerUseUse
     */
    private fun startMainForegroundService() {
        try {
            val intent = android.content.Intent(context, RemoteControlForegroundService::class.java)
            if (android.os.Build.VERSION.SDK_INT >= 26) {
                context.startForegroundService(intent)
            } else {
                context.startService(intent)
            }
            Log.i(TAG, "✅ 主前台服务已启动（对应 f 目录的 BackRunServerUseUse）")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动主前台服务失败", e)
        }
    }

    /**
     * 停止综合保活 - 简化版本
     */
    fun stopComprehensiveKeepAlive() {
        synchronized(startLock) {
            if (!isStarted) {
                return
            }

            try {
                Log.i(TAG, "🛑 停止综合保活管理器")
                isStarted = false
                isWorkManagerStarted = false

                // 停止 WorkManager 保活
                WorkManagerKeepAliveService.getInstance().stopKeepAlive(context)

                Log.i(TAG, "✅ 综合保活管理器停止完成")

            } catch (e: Exception) {
                Log.e(TAG, "❌ 停止综合保活管理器失败", e)
            }
        }
    }
    
    /**
     * 检查服务启动状态
     */
    fun getServiceStatus(): Map<String, Any> {
        return mapOf(
            "isStarted" to isStarted,
            "isWorkManagerStarted" to isWorkManagerStarted,
            "canStart" to canStartService()
        )
    }
    
    /**
     * 检查是否可以启动服务
     */
    fun canStartService(): Boolean {
        return !isStarted
    }

    /**
     * 启动WorkManager保活 - 参考 f 目录的系统级 WorkManager
     */
    private fun startWorkManagerKeepAlive() {
        try {
            WorkManagerKeepAliveService.getInstance().startKeepAlive(context)
            Log.i(TAG, "⚙️ WorkManager保活已启动（对应 f 目录的系统级 WorkManager）")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动WorkManager保活失败", e)
        }
    }

    /**
     * ✅ 启动 JobService 定期调度 - 参考 f 目录的 MyService
     * f 目录：setMinimumLatency(60000L), setOverrideDeadline(120000L), setPersisted(true)
     */
    private fun startJobServiceScheduler() {
        try {
            if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
                Log.w(TAG, "⚠️ JobScheduler需要 Android 5.0+")
                return
            }
            
            val jobScheduler = context.getSystemService(android.content.Context.JOB_SCHEDULER_SERVICE) as android.app.job.JobScheduler
            
            val jobInfo = android.app.job.JobInfo.Builder(
                123, // ✅ 参考 f 目录的 MyService，使用固定 ID 123
                android.content.ComponentName(context, KeepAliveJobService::class.java)
            ).apply {
                setRequiredNetworkType(android.app.job.JobInfo.NETWORK_TYPE_ANY) // ✅ 参考 f 目录：setRequiredNetworkType(1)
                setMinimumLatency(5000L)       // ✅ 优化：5秒最小延迟（快速保活）
                setOverrideDeadline(5000L)     // ✅ 优化：5秒截止时间（快速保活）
                setPersisted(true)              // ✅ 参考 f 目录：持久化，设备重启后继续
            }.build()
            
            val result = jobScheduler.schedule(jobInfo)
            if (result == android.app.job.JobScheduler.RESULT_SUCCESS) {
                Log.i(TAG, "✅ JobService定期调度已启动（5秒间隔，快速保活）")
            } else {
                Log.w(TAG, "⚠️ JobService定期调度启动失败")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 启动JobService定期调度失败", e)
        }
    }

    /**
     * 获取保活状态 - 简化版本
     */
    fun getKeepAliveStatus(): Map<String, Any> {
        return try {
            val workManagerStatus = WorkManagerKeepAliveService.getInstance().checkWorkManagerStatus(context)
            
            mapOf(
                "comprehensive_keepalive_running" to isStarted,
                "workmanager_status" to workManagerStatus,
                "timestamp" to System.currentTimeMillis()
            )
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取保活状态失败", e)
            emptyMap()
        }
    }

    /**
     * 清理资源
     */
    fun cleanup() {
        try {
            stopComprehensiveKeepAlive()
            Log.i(TAG, "🧹 综合保活管理器资源已清理")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清理资源失败", e)
        }
    }
}
