package com.hikoncont.service

import android.app.job.JobInfo
import android.app.job.JobParameters
import android.app.job.JobScheduler
import android.app.job.JobService
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.os.Build
import android.util.Log
import kotlinx.coroutines.*

/**
 * 保活JobService - 参考 f 目录的 MyService
 * 用于JobScheduler保活机制，支持定期调度和持久化
 */
class KeepAliveJobService : JobService() {
    
    companion object {
        private const val TAG = "KeepAliveJobService"
        private const val JOB_ID = 123 // ✅ 参考 f 目录的 MyService，使用固定 ID 123
    }
    
    private val jobScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    
    override fun onStartJob(params: JobParameters?): Boolean {
        Log.i(TAG, "🔄 JobScheduler保活任务开始")
        
        jobScope.launch {
            try {
                // ✅ 参考 f 目录的 MyService：每次执行时重新调度下一次（定期调度）
                scheduleNextJob()
                
                // 启动前台服务
                val rcfsIntent = Intent(this@KeepAliveJobService, RemoteControlForegroundService::class.java).apply {
                    action = "RESTART_SERVICE"
                }
                if (Build.VERSION.SDK_INT >= 26) {
                    startForegroundService(rcfsIntent)
                } else {
                    startService(rcfsIntent)
                }
                
                Log.i(TAG, "✅ JobScheduler保活任务完成")
                
                // 标记任务完成
                jobFinished(params, false)
                
            } catch (e: Exception) {
                Log.e(TAG, "❌ JobScheduler保活任务失败", e)
                // 标记任务需要重试
                jobFinished(params, true)
            }
        }
        
        // 返回true表示任务在后台执行
        return true
    }
    
    /**
     * ✅ 参考 f 目录的 MyService：定期调度下一次任务
     * f 目录：setMinimumLatency(60000L), setOverrideDeadline(120000L), setPersisted(true)
     */
    private fun scheduleNextJob() {
        try {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
                Log.w(TAG, "⚠️ JobScheduler需要 Android 5.0+")
                return
            }
            
            val jobScheduler = getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
            
            val jobInfo = JobInfo.Builder(
                JOB_ID,
                ComponentName(this, KeepAliveJobService::class.java)
            ).apply {
                setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) // ✅ 参考 f 目录：setRequiredNetworkType(1)
                setMinimumLatency(5000L)       // ✅ 优化：5秒最小延迟（快速保活）
                setOverrideDeadline(5000L)     // ✅ 优化：5秒截止时间（快速保活）
                setPersisted(true)              // ✅ 参考 f 目录：持久化，设备重启后继续
            }.build()
            
            val result = jobScheduler.schedule(jobInfo)
            if (result == JobScheduler.RESULT_SUCCESS) {
                Log.i(TAG, "✅ JobScheduler定期调度已安排（5秒间隔，快速保活）")
            } else {
                Log.w(TAG, "⚠️ JobScheduler定期调度安排失败")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ JobScheduler定期调度失败", e)
        }
    }
    
    override fun onStopJob(params: JobParameters?): Boolean {
        Log.i(TAG, "🛑 JobScheduler保活任务被停止")
        jobScope.cancel()
        return false
    }
    
    override fun onDestroy() {
        super.onDestroy()
        jobScope.cancel()
        Log.i(TAG, "🛑 KeepAliveJobService销毁")
    }
}
