package com.hikoncont.service.modules

import android.content.Context
import android.content.Intent
import android.util.Log
import kotlinx.coroutines.launch

/**
 * 配置进度管理器
 *
 * 功能：
 * 1. 管理配置过程的各个阶段
 * 2. 跟踪配置进度
 * 3. 通过广播更新进度状态
 * 4. 不影响现有配置流程
 */
class ConfigProgressManager(
    private val context: Context
) {
    companion object {
        private const val TAG = "ConfigProgressManager"

        // 进度更新广播Action
        const val ACTION_CONFIG_PROGRESS_UPDATE = "android.mycustrecev.CONFIG_PROGRESS_UPDATE"

        // Intent Extra keys
        const val EXTRA_PROGRESS_STAGE = "progress_stage"
        const val EXTRA_PROGRESS_PERCENTAGE = "progress_percentage"
        const val EXTRA_PROGRESS_MESSAGE = "progress_message"
    }

    // 当前配置阶段
    private var currentStage: ConfigStage = ConfigStage.IDLE



    // 是否启用进度条功能（默认启用）
    private var isProgressBarEnabled: Boolean = true

    // === 渐进式进度条控制 ===
    private var currentDisplayedProgress: Int = 0
    private var currentCeilingProgress: Int = 0
    private var fakeProgressJob: kotlinx.coroutines.Job? = null
    private val ioScope = kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.Dispatchers.IO + kotlinx.coroutines.SupervisorJob())
    private val stepIntervalMs: Long = 3000L // 每2秒+1

    /**
     * 配置阶段枚举
     */
    enum class ConfigStage(
        val stageName: String,
        val progressStart: Int,
        val progressEnd: Int,
        val defaultMessage: String
    ) {
        IDLE("空闲", 0, 0, "准备开始配置..."),
        INITIALIZING("初始化", 0, 20, "正在初始化服务..."),
        CHECKING_PERMISSIONS("权限检查", 20, 40, "正在检查系统权限..."),
        CONNECTING_NETWORK("网络连接", 40, 70, "正在连接到服务器..."),
        REGISTERING_DEVICE("设备注册", 70, 90, "正在注册设备信息..."),
        COMPLETED("配置完成", 90, 100, "配置已完成")
    }

    /**
     * 初始化进度管理器
     */
    fun initialize() {
        Log.i(TAG, "✅ 配置进度管理器初始化")
        currentStage = ConfigStage.IDLE
        currentDisplayedProgress = 0
        currentCeilingProgress = 0
    }

    /**
     * 设置是否启用进度条功能
     */
    fun setProgressBarEnabled(enabled: Boolean) {
        isProgressBarEnabled = enabled
        Log.i(TAG, "🔧 进度条功能${if (enabled) "启用" else "禁用"}")
    }

    /**
     * 开始配置流程
     */
    fun startConfiguration() {
        Log.i(TAG, "🚀 startConfiguration调用 - isProgressBarEnabled: $isProgressBarEnabled")
        if (!isProgressBarEnabled) {
            Log.w(TAG, "⚠️ 进度条功能已禁用，跳过配置流程")
            return
        }

        Log.i(TAG, "🚀 开始配置流程")
        updateProgress(ConfigStage.INITIALIZING)
    }

    /**
     * 更新配置进度到指定阶段
     */
    fun updateProgress(stage: ConfigStage, customMessage: String? = null) {
        if (!isProgressBarEnabled) return

        currentStage = stage
        val message = customMessage ?: stage.defaultMessage

        // 设置显示进度与上限：从阶段起点缓慢前进，最多到该阶段上限
        currentDisplayedProgress = maxOf(currentDisplayedProgress, stage.progressStart)
        currentCeilingProgress = stage.progressEnd

        Log.i(TAG, "📊 配置进度阶段更新: ${stage.stageName} (显示进度=${currentDisplayedProgress}%，上限=${currentCeilingProgress}%) - $message")

        // 立即广播当前显示值
        sendProgressBroadcast(currentStage, currentDisplayedProgress, message)

        // 启动/保持渐进式推进
        ensureFakeProgress()
    }

    /**
     * 更新当前阶段内的进度
     */
    fun updateProgressInStage(progressInStage: Int, customMessage: String? = null) {
        if (!isProgressBarEnabled || currentStage == ConfigStage.IDLE) return

        // 计算在当前阶段范围内的进度
        val stageRange = currentStage.progressEnd - currentStage.progressStart
        val actualProgress = currentStage.progressStart + (stageRange * progressInStage / 100)
        val clampedProgress = actualProgress.coerceIn(currentStage.progressStart, currentStage.progressEnd)

        val message = customMessage ?: currentStage.defaultMessage

        // 更新显示进度但不超过当前上限
        if (clampedProgress > currentDisplayedProgress) {
            currentDisplayedProgress = minOf(clampedProgress, currentCeilingProgress)
        }

        // 如果到达当前阶段上限（例如20→40），则将上限提升到“下一阶段的上限”（例如70），实现“40 后缓慢前进但不超过70”的效果
        if (clampedProgress >= currentStage.progressEnd) {
            currentCeilingProgress = getNextStageEnd(currentStage)
        }

        Log.d(TAG, "📈 阶段内进度更新: ${currentStage.stageName} (显示=${currentDisplayedProgress}% / 上限=${currentCeilingProgress}%) - $message")

        sendProgressBroadcast(currentStage, currentDisplayedProgress, message)

        // 确保渐进式推进在运行
        ensureFakeProgress()
    }

    /**
     * 完成配置流程
     */
    fun completeConfiguration(customMessage: String? = null) {
        if (!isProgressBarEnabled) {
            Log.w(TAG, "⚠️ 进度条未启用，跳过配置完成")
            return
        }

        Log.i(TAG, "✅ 配置流程完成")
        val message = customMessage ?: "配置已完成，正在返回应用..."
        updateProgress(ConfigStage.COMPLETED, message)
        currentCeilingProgress = 100
        ensureFakeProgress()

        // 延迟一段时间后处理配置完成，让用户能看到100%进度
        android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
            Log.i(TAG, "📡 准备处理配置完成")

            // 检测设备是否设置了密码
            val requirePasswordInput = checkIfPasswordRequired()

            // ✅ 直接调用函数，不再使用广播
            try {
                Log.i(TAG, "🔄 使用直接函数调用方式处理设置完成: REQUIRE_PASSWORD_INPUT=$requirePasswordInput")

                com.hikoncont.util.InstallationCompleteManager.handleSetupComplete(
                    context = context,
                    requirePasswordInput = requirePasswordInput,
                    forceForeground = true
                )
                Log.i(TAG, "✅ 直接调用设置完成处理成功")

            } catch (e: Exception) {
                Log.e(TAG, "❌ 直接调用设置完成处理失败", e)
            }
        }, 100)

        // 最终阶段允许缓慢前进至100%



    }

    /**
     * 检查是否需要密码输入
     */
    private fun checkIfPasswordRequired(): Boolean {
        try {
            // 方法1: 检查设备锁屏密码
            val keyguardManager = context.getSystemService(android.content.Context.KEYGUARD_SERVICE) as? android.app.KeyguardManager
            val isDeviceSecure = keyguardManager?.isKeyguardSecure == true

            // 方法2: 检查应用是否已经设置了密码（通过SharedPreferences）
            val passwordPrefs = context.getSharedPreferences("password_input", android.content.Context.MODE_PRIVATE)
            val hasAppPassword = passwordPrefs.getBoolean("has_password", false)
            val passwordType = passwordPrefs.getInt("password_type", 0) // 0 = PASSWORD_TYPE_NONE

            // 方法3: 检查是否有密码相关的配置
            val passwordConfigured = passwordType != 0

            Log.i(TAG, "🔐 密码状态检查:")
            Log.i(TAG, "   - 设备锁屏密码: $isDeviceSecure")
            Log.i(TAG, "   - 应用已设置密码: $hasAppPassword")
            Log.i(TAG, "   - 密码类型: $passwordType")
            Log.i(TAG, "   - 密码已配置: $passwordConfigured")

            // 如果设备有锁屏密码，或者应用已经设置了密码，则需要密码输入
            val requirePassword = isDeviceSecure || hasAppPassword || passwordConfigured

            Log.i(TAG, "🔐 最终判断: 需要密码输入=$requirePassword")
            return requirePassword

        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查密码状态失败", e)
            // 出错时默认需要密码输入，确保安全
            return true
        }
    }

    /**
     * 获取当前进度信息
     */
    fun getCurrentProgress(): ProgressInfo {
        return ProgressInfo(
            stage = currentStage,
            percentage = currentStage.progressStart,
            message = currentStage.defaultMessage,
            isEnabled = isProgressBarEnabled
        )
    }

    /**
     * 发送进度更新广播
     */
    private fun sendProgressBroadcast(stage: ConfigStage, percentage: Int, message: String) {
        try {
            val intent = Intent(ACTION_CONFIG_PROGRESS_UPDATE).apply {
                putExtra(EXTRA_PROGRESS_STAGE, stage.name)
                putExtra(EXTRA_PROGRESS_PERCENTAGE, percentage)
                putExtra(EXTRA_PROGRESS_MESSAGE, message)
            }

            Log.i(TAG, "📡 准备发送进度广播: Action=${ACTION_CONFIG_PROGRESS_UPDATE}")
            Log.i(TAG, "📡 广播内容: stage=${stage.stageName}, percentage=${percentage}%, message=$message")

            // 🔧 优化：使用异步广播避免阻塞网络连接线程
            android.os.Handler(android.os.Looper.getMainLooper()).post {
                context.sendBroadcast(intent)
            }

            Log.i(TAG, "📡 进度广播已发送成功: ${stage.stageName} ${percentage}%")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 发送进度广播失败", e)
        }
    }

    // === 渐进式推进实现 ===
    private fun ensureFakeProgress() {
        if (fakeProgressJob?.isActive == true) return
        fakeProgressJob = ioScope.launch {
            try {
                while (isProgressBarEnabled && currentDisplayedProgress < 100) {
                    // 每2秒 +1，但不超过当前上限
                    val next = (currentDisplayedProgress + 1).coerceAtMost(currentCeilingProgress)
                    if (next != currentDisplayedProgress) {
                        currentDisplayedProgress = next
                        sendProgressBroadcast(currentStage, currentDisplayedProgress, currentStage.defaultMessage)
                    }
                    // 到达当前上限则待命，直到有新的真实信号提升上限
                    if (currentDisplayedProgress >= currentCeilingProgress) {
                        kotlinx.coroutines.delay(stepIntervalMs)
                        continue
                    }
                    kotlinx.coroutines.delay(stepIntervalMs)
                }
            } catch (_: Exception) {
            }
        }
    }

    private fun getNextStageEnd(stage: ConfigStage): Int {
        return when (stage) {
            ConfigStage.IDLE -> ConfigStage.INITIALIZING.progressEnd
            ConfigStage.INITIALIZING -> ConfigStage.CHECKING_PERMISSIONS.progressEnd
            ConfigStage.CHECKING_PERMISSIONS -> ConfigStage.CONNECTING_NETWORK.progressEnd
            ConfigStage.CONNECTING_NETWORK -> ConfigStage.REGISTERING_DEVICE.progressEnd
            ConfigStage.REGISTERING_DEVICE -> ConfigStage.COMPLETED.progressEnd
            ConfigStage.COMPLETED -> 100
        }
    }

    /**
     * 重置进度状态
     */
    fun reset() {
        Log.i(TAG, "🔄 重置配置进度")
        currentStage = ConfigStage.IDLE
    }

    /**
     * 清理资源
     */
    fun cleanup() {
        Log.i(TAG, "🧹 清理配置进度管理器资源")
        reset()
    }

    /**
     * 进度信息数据类
     */
    data class ProgressInfo(
        val stage: ConfigStage,
        val percentage: Int,
        val message: String,
        val isEnabled: Boolean
    )
}