package top.r3944realms.ltdmanager.module

import kotlinx.coroutines.*
import kotlinx.serialization.Serializable
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import top.r3944realms.ltdmanager.blessingskin.request.invitecode.GenerateInvitationCodeRequest
import top.r3944realms.ltdmanager.blessingskin.response.ResponseResult
import top.r3944realms.ltdmanager.blessingskin.response.invitecode.InvitationCodeGenerationResponse
import top.r3944realms.ltdmanager.core.mail.mail
import top.r3944realms.ltdmanager.napcat.NapCatClient
import top.r3944realms.ltdmanager.napcat.data.ID
import top.r3944realms.ltdmanager.napcat.data.MessageElement
import top.r3944realms.ltdmanager.napcat.data.MessageType
import top.r3944realms.ltdmanager.napcat.event.message.GetFriendMsgHistoryEvent
import top.r3944realms.ltdmanager.napcat.request.other.SendGroupMsgRequest
import top.r3944realms.ltdmanager.utils.HtmlTemplateUtil
import top.r3944realms.ltdmanager.utils.LoggerUtil
import java.io.File
import java.sql.Timestamp
import java.util.*
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock


/*
    1. 订阅消息模块 (触发关键词, 注意过滤自己的消息，避免重复触发) [Done]
    2. 根据QQ号去查询机器人数据库中的视图表的id (此操作耗时，应设置针对指定用户的持久化冷却)
    3. id存在 [错误处理: id不存在提醒用户为无法查询到你的id，请联系管理员检查状态]
        i. effective 和 is_used 均为 1，
            则回复提醒你已经使用了你的邀请码，切勿重复发送

        ii. effective 为 1 且 is_used 为 0
            则查询token_id对应的token记录然后构造发送邮件
            提醒用户邮件已发送

        iii. effective 为 0
            则先通过API创建Token 获取来的响应 [错误处理: 当获取的json消息解析中success为false，则回复用户message中的错误信息]
            用Token去邀请码数据库中查询token_id,将其记录在机器人数据库对应白名单id映射token_id表中 [存在则更新，不存在则插入],
            然后按ii.执行

 */
/*
api格式 https://skins.r3944realms.top/api/invitation-codes/generate?token=XXXX&amount=1
成功消息：
{
    "success": true,
    "message": "邀请码生成成功",
    "data": [
        {
            "code": "XXXXXXX",
            "generated_at": "2025-08-29T09:36:36.910623Z",
            "expires_at": "2025-09-05T09:36:36.910506Z"
        }
    ]
}
失败消息：
{
    "success": false,
    "message": "无效的 API Token"
}
*/

class InvitationCodesModule(
    private val groupMessagePollingModule: GroupMessagePollingModule,
    private val mailModule: MailModule,
    private val apiToken: String,
    private val selfId: Long,
    private val cooldownMillis: Long = 120_000,
    private val keywords: Set<String> = setOf("申请邀请码")
) : BaseModule(), PersistentState<InvitationCodesModule.LastTriggerMapState> {

    override val name: String = "InvitationCodesModule"
    private var scope: CoroutineScope? = null

    // 持久化文件（带锁 + 备份）
    private val stateFile = File("invitation_codes_quarry_state.json")
    private val stateBackupFile = File("invitation_codes_quarry_state.json.bak")
    private val fileLock = ReentrantLock()

    private var lastTriggerMapState = loadState()
    override fun getStateFile(): File = stateFile
    override fun getState(): LastTriggerMapState = lastTriggerMapState
    override fun onLoad() {
        LoggerUtil.logger.info("[$name] 模块已装载，目标群组: ${groupMessagePollingModule.targetGroupId}")
        LoggerUtil.logger.info("[$name] 上次触发状态: lastTriggerMap=${lastTriggerMapState.map}")
        LoggerUtil.logger.info("[$name] 关键词列表: $keywords")

        scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
        scope!!.launch {
            LoggerUtil.logger.info("[$name] 轮询协程启动")
            groupMessagePollingModule.messagesFlow.collect { messages ->
                if (loaded) handleMessages(messages)
            }
        }

        // 定时落盘（防止异常退出丢状态）
        scope!!.launch {
            while (isActive) {
                delay(60_000) // 每分钟保存一次
                saveState(lastTriggerMapState)
            }
        }
    }

    override suspend fun onUnload() {
        LoggerUtil.logger.info("[$name] 模块卸载，保存状态...")
        saveState(lastTriggerMapState)
        LoggerUtil.logger.info("[$name] 模块卸载，取消协程...")
        scope?.cancel()
        LoggerUtil.logger.info("[$name] 模块已卸载完成")
    }

    // =========================
    // 消息处理主流程
    // =========================
    private suspend fun handleMessages(messages: List<GetFriendMsgHistoryEvent.SpecificMsg>) {
        val triggerMsgs = filterTriggerMessages(messages)
        if (triggerMsgs.isEmpty()) return

        try {
            val hadValidCodeButNotUsed = mutableListOf<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>()
            val needNewCode = mutableListOf<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>()

            getIdAndSelectSituation(triggerMsgs, hadValidCodeButNotUsed, needNewCode)
            createAndSearchInvitationCodeIdsThenUpdateDate(needNewCode)
            hadVaildCodeButNotUseListHandler(hadValidCodeButNotUsed + needNewCode)
        } catch (e: Exception) {
            sendFailedMessage(napCatClient, text = "系统错误，请联系管理员: $e")
        } finally {
            saveState(lastTriggerMapState)
        }
    }

    /** 过滤出符合条件的触发消息 */
    private fun filterTriggerMessages(messages: List<GetFriendMsgHistoryEvent.SpecificMsg>)
            : List<GetFriendMsgHistoryEvent.SpecificMsg> {

        val filtered = messages.asSequence()
            .filter { msg ->
                msg.userId != selfId &&
                        (msg.time > lastTriggerMapState.getLastTriggerTime(msg.userId) ||
                                (msg.time == lastTriggerMapState.getLastTriggerTime(msg.userId)
                                        && msg.realId > lastTriggerMapState.getLastTriggerRealId(msg.userId))) &&
                        msg.message.any { seg ->
                            seg.type == MessageType.Text &&
                                    seg.data.text?.let { text -> keywords.any { keyword -> text == keyword } } == true
                        }
            }
            .groupBy { it.userId }
            .mapNotNull { (_, msgs) -> msgs.maxByOrNull { it.time } }
            .filter { runBlocking { filterCoolDownMessage(it) } }
            .toList()

        if (filtered.isNotEmpty()) {
            LoggerUtil.logger.info("[$name] 待处理消息队列: $filtered")
        }
        return filtered
    }

    private suspend fun getIdAndSelectSituation(msgs: List<GetFriendMsgHistoryEvent.SpecificMsg>,
                                                hadVaildCodeButNotUseList : MutableList<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>,
                                                needNewCodeList: MutableList<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>) {
        if (msgs.isEmpty()) return

        val qqIds = msgs.map { it.userId }
        val placeholders = java.lang.String.join(",", Collections.nCopies(qqIds.size, "?"))
        // 修正SQL语句的表名引用
        val sql = """
        SELECT q.player_id, q.effective, q.is_used, q.qq 
        FROM ltd_manager_bot.qualified_user_info q 
        WHERE q.qq IN ($placeholders)
        """.trimIndent()
        try {
            getConnection().use { conn ->
                conn.prepareStatement(sql).use { pstmt ->
                    // 设置所有参数
                    for (i in qqIds.indices) {
                        pstmt.setLong(i + 1, qqIds[i])
                    }

                    pstmt.executeQuery().use { rs ->
                        // 创建结果映射表
                        val resultMap = mutableMapOf<Long, Triple<Long?, Boolean?, Boolean?>>()

                        while (rs.next()) {
                            val qq = rs.getLong("qq")
                            val playerId = rs.getLong("player_id")
                            // 处理可能的null值
                            val playerIdValue = if (rs.wasNull()) null else playerId
                            val effective = rs.getBoolean("effective")
                            val isUsed = rs.getBoolean("is_used")

                            resultMap[qq] = Triple(playerIdValue, effective, isUsed)
                        }

                        // 分类处理每个消息
                        for (msg in msgs) {
                            val result = resultMap[msg.userId]

                            when {
                                result == null -> {
                                    // 数据库中没有记录, 属于是异常
                                    LoggerUtil.logger.error("[$name] 无法查询该QQ号为:${msg.userId}的白名单ID，可能该用户非白名单成员")
                                    sendFailedMessage(napCatClient, msg.userId, msg.realId, msg.time, "无法查询到你的白名单应用id，请联系管理员检查状态，对应QQ号：${msg.userId}")
                                }
                                result.first != null && result.second == true && result.third == true -> {
                                    // 有player_id且已使用
                                    LoggerUtil.logger.info("[$name] 该QQ号为:${msg.userId}的白名单ID是${result.first}，已使用对应激活码")
                                    sendMessage(napCatClient, msg.userId, msg.realId, msg.time, "你已经使用了你的邀请码，切勿重复发送")
                                }
                                result.first != null && result.second == true && result.third == false -> {
                                    // 有player_id、有效且未使用
                                    LoggerUtil.logger.info("[$name] 该QQ号为:${msg.userId}的白名单ID是${result.first}，已有对应激活码但未使用")
                                    hadVaildCodeButNotUseList.add(result.first!! to msg)
                                }
                                result.first != null && result.second == false -> {
                                    // 没有player_id但有效，需要新code或处理
                                    needNewCodeList.add(result.first!! to msg)
                                }
                                else -> {
                                    //其它情况，异常，不应该出现
                                    sendFailedMessage(napCatClient, msg.userId, msg.realId, msg.time, "非法状态，请联系管理员：$result")
                                }
                            }
                        }
                    }
                }
            }
        } catch (e: Exception) {
            // 更好的错误处理
            LoggerUtil.logger.error("[$name] 批量查询用户资格信息失败: ${e.message}", e)
            sendFailedMessage(napCatClient, text = "批量查询用户资格信息失败，请联系管理员: ${e.message}")
        }
    }
    private suspend fun hadVaildCodeButNotUseListHandler(list: List<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>) {
        if (list.isEmpty()) return

        val whiteListIds = list.map { it.first }
        val placeholders = java.lang.String.join(",", Collections.nCopies(whiteListIds.size, "?"))

        val sql = """
                SELECT q.player_id, q.player_name, q.token, q.expires_at
                FROM ltd_manager_bot.qualified_user_info q 
                WHERE q.player_id IN ($placeholders)
                """.trimIndent()

        try {
            getConnection().use { conn ->
                conn.prepareStatement(sql).use { pstmt ->
                    for (i in whiteListIds.indices) {
                        pstmt.setLong(i + 1, whiteListIds[i])
                    }
                    pstmt.executeQuery().use { rs ->
                        val resultMap = mutableMapOf<Long, Triple<String?, String?, Timestamp?>>()
                        while (rs.next()) {
                            val playerId = rs.getLong("player_id")
                            val playerName = rs.getString("player_name")
                            val token = rs.getString("token")
                            val tokenValue = if (rs.wasNull()) null else token
                            val expiresAt = rs.getTimestamp("expires_at")
                            val expiresAtValue = if (rs.wasNull()) null else expiresAt

                            resultMap[playerId] = Triple(playerName, tokenValue, expiresAtValue)
                        }

                        // 直接遍历原始列表，不需要额外的映射
                        for ((playerId, specificMsg) in list) {
                            val mailRequestArgument = resultMap[playerId]

                            if (mailRequestArgument?.second != null && mailRequestArgument.third != null) {
                                mailModule.enqueue(mail {
                                    to += specificMsg.userId.toString() + "@qq.com" // 直接使用 specificMsg
                                    // 根据需要配置邮件内容
                                    subject = "LTD邀请码邮件"
                                    isHtml = true
                                    body = HtmlTemplateUtil.tokenMailHtmlTemplate(
                                        mailRequestArgument.first!!,
                                        mailRequestArgument.second!!,
                                        mailRequestArgument.third!!,
                                        7,2025
                                    )
                                })
                                sendMessage(napCatClient, specificMsg.userId, specificMsg.realId, specificMsg.time,"已发送邮件注意，查收QQ邮箱")
                            } else if (mailRequestArgument?.second != null) {
                                mailModule.enqueue(mail {
                                    to += specificMsg.userId.toString() + "@qq.com" // 直接使用 specificMsg
                                    // 根据需要配置邮件内容
                                    subject = "LTD邀请码邮件"
                                    isHtml = true
                                    body = HtmlTemplateUtil.tokenMailHtmlTemplate(
                                        mailRequestArgument.first!!,
                                        mailRequestArgument.second!!,
                                        timeYear = 2025
                                    )
                                })
                                sendMessage(napCatClient, specificMsg.userId, specificMsg.realId, specificMsg.time,"已发送邮件注意，查收QQ邮箱")
                            } else {
                                LoggerUtil.logger.error("[$name] 异常情况，code为 空值")
                                sendFailedMessage(napCatClient, specificMsg.userId, specificMsg.realId, specificMsg.time, "系统内部异常，请联系管理员")
                            }
                        }
                    }
                }
            }
        } catch (e: Exception) {
            LoggerUtil.logger.error("[$name] 查询已获取邀请码但未使用或未过期用户，Code信息失败: ${e.message}", e)
            sendFailedMessage(napCatClient, text = "查询已获取邀请码但未使用或未过期用户，Code信息失败: ${e.message}")
        }
    }

    private suspend fun sendMessage(
        client: NapCatClient,
        qq: Long,
        realId: Long,
        time: Long,
        text: String = "正常消息"
    ) {
        LoggerUtil.logger.info("[$name] 发送消息: realId=$realId, text=$text")

        val request = SendGroupMsgRequest(
            MessageElement.reply(ID.long(realId), text),
            ID.long(groupMessagePollingModule.targetGroupId)
        )
        client.sendUnit(request)
        LoggerUtil.logger.info("[$name] 已发送 消息")

        // 更新触发的最大 realId
        lastTriggerMapState = lastTriggerMapState.updateLastTrigger(qq, realId, time)
    }
    private suspend fun sendFailedMessage(
        client: NapCatClient,
        qq: Long? = null,
        realId: Long? = null,
        time: Long? = null,
        text: String = "失败消息"
    ) {
        LoggerUtil.logger.info("[$name] 发送失败消息: realId=$realId, text=$text")
        if (realId != null && qq != null && time != null) {
            val request = SendGroupMsgRequest(
                MessageElement.reply(ID.long(realId), text),
                ID.long(groupMessagePollingModule.targetGroupId)
            )
            client.sendUnit(request)
            LoggerUtil.logger.info("[$name] 已发送 失败消息")

            // 更新触发的最大 realId
             lastTriggerMapState = lastTriggerMapState.updateLastTrigger(qq, realId, time)
        } else {
            val request = SendGroupMsgRequest(
                listOf(MessageElement.text(text)),
                ID.long(groupMessagePollingModule.targetGroupId)
            )
            client.sendUnit(request)
            LoggerUtil.logger.info("[$name] 已发送 失败消息[无指定对象]")
        }
    }

    // =========================
    // 冷却逻辑
    // =========================
    private suspend fun filterCoolDownMessage(msg: GetFriendMsgHistoryEvent.SpecificMsg): Boolean {
        val triggerDetail = lastTriggerMapState.map[msg.userId]
        val lastTriggerTime = triggerDetail?.time ?: -1L
        val lastCooldownRealId = triggerDetail?.lastCooldownRealId ?: -1L
        val nowSec = System.currentTimeMillis() / 1000  // 转成秒

        if (lastTriggerTime == -1L || nowSec - lastTriggerTime >= cooldownMillis / 1000) {
            // 正常触发
            return true
        }

        // 冷却中，如果本消息未发送过冷却提示
        if (msg.realId != lastCooldownRealId) {
            val remaining = ((cooldownMillis / 1000) - (nowSec - lastTriggerTime)).coerceAtLeast(1)
            val msgText = "⏳ 申请邀请码过于频繁，请稍后再试（剩余 $remaining 秒）"
            sendCooldownMessage(napCatClient, msg.userId, msg.realId, msgText)

            // 记录这条消息已发送过冷却提示
            lastTriggerMapState = lastTriggerMapState.updateLastCooldownRealId(msg.userId, msg.realId)
        }

        return false
    }

    private suspend fun sendCooldownMessage(client: NapCatClient, qq: Long, realId: Long, msg: String) {
        val request = SendGroupMsgRequest(
            MessageElement.reply(ID.long(realId), msg),
            ID.long(groupMessagePollingModule.targetGroupId)
        )
        client.sendUnit(request)
        lastTriggerMapState = lastTriggerMapState.updateLastTrigger(qq, realId, -1)
    }
    private suspend fun createAndSearchInvitationCodeIdsThenUpdateDate(
        needNewTokenIdAndMsgPairs: List<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>,
    ) {
        if (needNewTokenIdAndMsgPairs.isEmpty()) return

        try {
            // 1. 创建邀请码
            val invitationCodes = createInvitationCodes(needNewTokenIdAndMsgPairs.size)

            // 2. 验证数量匹配
            validateCodeCountMatch(invitationCodes, needNewTokenIdAndMsgPairs)

            // 3. 获取邀请码ID
            val codeToIdMap = getInvitationCodeIds(invitationCodes!!.map { it.code })

            // 4. 更新或插入关联关系
            updateInvitationCodeAscription(needNewTokenIdAndMsgPairs.map { it.first }, codeToIdMap.values.toList())

        } catch (e: Exception) {
            handleCreationError(e)
        }
    }

    /**
     * 1. 创建邀请码
     */
    private suspend fun createInvitationCodes(amount: Int): List<InvitationCodeGenerationResponse.InvitationCode>? {
        return try {
            val response = blessingSkinClient.submitRequest(
                GenerateInvitationCodeRequest(amount = amount, token = apiToken)
            )

            when (response) {
                is ResponseResult.Success -> {
                    if (response.response.success) {
                        response.response.data
                    } else {
                        LoggerUtil.logger.warn("[$name] API返回失败: ${response.response.message}")
                        null
                    }
                }
                is ResponseResult.Failure -> {
                    LoggerUtil.logger.warn("[$name] 创建邀请码失败: ${response.failure.failedResult}")
                    null
                }
            }
        } catch (e: Exception) {
            LoggerUtil.logger.error("[$name] 创建邀请码异常", e)
            null
        }
    }

    /**
     * 2. 验证数量匹配
     */
    private fun validateCodeCountMatch(
        invitationCodes: List<InvitationCodeGenerationResponse.InvitationCode>?,
        needNewTokenIdAndMsgPairs: List<Pair<Long, GetFriendMsgHistoryEvent.SpecificMsg>>
    ) {
        if (invitationCodes == null) {
            throw InvitationCodeException.ApiFailureException("获取邀请码请求失败")
        }

        if (invitationCodes.size != needNewTokenIdAndMsgPairs.size) {
            throw InvitationCodeException.QuantityMismatchException(
                expectedCount = needNewTokenIdAndMsgPairs.size,
                actualCount = invitationCodes.size
            )
        }
    }

    /**
     * 3. 获取邀请码ID
     */
    private fun getInvitationCodeIds(invitationCodes: List<String>): Map<String, Long> {
        if (invitationCodes.isEmpty()) return emptyMap()

        val placeholders = invitationCodes.joinToString(",") { "?" }
        val sql = """
        SELECT i.id, i.code
        FROM blessingskin.invitation_codes i 
        WHERE i.code IN ($placeholders)
    """.trimIndent()

        return getConnection().use { conn ->
            conn.prepareStatement(sql).use { pstmt ->
                // 设置参数
                invitationCodes.forEachIndexed { index, code ->
                    pstmt.setString(index + 1, code)
                }

                val resultMap = mutableMapOf<String, Long>()
                pstmt.executeQuery().use { rs ->
                    while (rs.next()) {
                        val id = rs.getLong("id")
                        val code = rs.getString("code")
                        resultMap[code] = id
                    }
                }
                resultMap
            }
        }
    }

    /**
     * 4. 更新或插入关联关系
     */
    private fun updateInvitationCodeAscription(playerIds: List<Long>, codeIds: List<Long>) {
        if (playerIds.size != codeIds.size) {
            throw IllegalStateException("playerIds和codeIds数量不匹配: ${playerIds.size} vs ${codeIds.size}")
        }

        if (playerIds.isEmpty()) return

        val placeholders = playerIds.joinToString(",") { "(?, ?)" }
        val sql = """
        INSERT INTO ltd_manager_bot.invitation_code_ascription (id, token_id)
        VALUES $placeholders
        ON DUPLICATE KEY UPDATE token_id = VALUES(token_id)
    """.trimIndent()

        getConnection().use { conn ->
            conn.prepareStatement(sql).use { pstmt ->
                var paramIndex = 1
                for (i in playerIds.indices) {
                    pstmt.setLong(paramIndex++, playerIds[i])
                    pstmt.setLong(paramIndex++, codeIds[i])
                }

                val affectedRows = pstmt.executeUpdate()
                LoggerUtil.logger.debug("[$name] 更新了 $affectedRows 条关联记录")
            }
        }
    }

    /**
     * 5. 错误处理
     */
    private suspend fun handleCreationError(e: Exception) {
        when (e) {
            is InvitationCodeException -> {
                LoggerUtil.logger.error("[$name] ${e.message}")
                if (e is InvitationCodeException.QuantityMismatchException) {
                    // 数量不匹配的特殊处理
                    handleQuantityMismatch(e.expectedCount, e.actualCount)
                } else {
                    sendFailedMessage(napCatClient, text = "邀请码创建失败，请联系管理员")
                }
            }
            else -> {
                LoggerUtil.logger.error("[$name] 捕获异常", e)
                sendFailedMessage(napCatClient, text = "系统内部问题，请联系管理员")
            }
        }
    }

    /**
     * 数量不匹配的特殊处理
     */
    private suspend fun handleQuantityMismatch(expectedCount: Int, actualCount: Int) {
        LoggerUtil.logger.error(
            "[$name] 数量不一致BUG，期望: $expectedCount, 实际: $actualCount"
        )
        sendFailedMessage(napCatClient, text = "系统内部BUG，请联系管理员")
        // TODO: 清理已创建的邀请码
        cleanupCreatedInvitationCodes(actualCount)
    }

    /**
     * 清理已创建的邀请码（TODO实现）
     */
    private fun cleanupCreatedInvitationCodes(createdCount: Int) {
        // 实现清理逻辑，删除多余的邀请码
        LoggerUtil.logger.warn("[$name] 需要清理 $createdCount 个邀请码")
    }


    // =========================
    // 状态持久化
    // =========================
    @Serializable
    data class LastTriggerMapState(
        val map: Map<Long, TriggerDetail> = emptyMap()
    ) {
        fun getLastTriggerTime(qq: Long): Long = map[qq]?.time ?: -1
        fun getLastTriggerRealId(qq: Long): Long = map[qq]?.realId ?: -1

        fun updateLastTrigger(qq: Long, realId: Long, time: Long = -1): LastTriggerMapState {
            val old = map[qq]
            val newTime = if (time != -1L) time else old?.time ?: -1
            val newMap = map.toMutableMap().apply {
                put(qq, TriggerDetail(realId, newTime))
            }
            return copy(map = newMap)
        }
        fun updateLastCooldownRealId(qq: Long, realId: Long): LastTriggerMapState {
            val old = map[qq]
            val newMap = map.toMutableMap().apply {
                put(qq, TriggerDetail(
                    realId = old?.realId ?: -1,
                    time = old?.time ?: -1,
                    lastCooldownRealId = realId
                ))
            }
            return copy(map = newMap)
        }
    }

    @Serializable
    data class TriggerDetail(val realId : Long, val time: Long, val lastCooldownRealId: Long = -1L )

    override fun loadState(): LastTriggerMapState {
        return try {
            if (!stateFile.exists()) {
                LoggerUtil.logger.info("[$name] 状态文件不存在，使用默认值")
                return LastTriggerMapState()
            }
            val content = stateFile.readText()
            val state = Json.decodeFromString<LastTriggerMapState>(content)
            LoggerUtil.logger.info("[$name] 成功加载状态: ${state.map}, 文件路径=${stateFile.absolutePath}")
            state
        } catch (e: Exception) {
            LoggerUtil.logger.warn("[$name] 读取状态失败，尝试从备份恢复", e)
            try {
                if (stateBackupFile.exists()) {
                    val backup = stateBackupFile.readText()
                    val state = Json.decodeFromString<LastTriggerMapState>(backup)
                    LoggerUtil.logger.info("[$name] 成功从备份恢复状态: ${state.map}")
                    state
                } else {
                    LastTriggerMapState()
                }
            } catch (e2: Exception) {
                LoggerUtil.logger.error("[$name] 备份也损坏，使用默认值", e2)
                LastTriggerMapState()
            }
        }
    }

    override fun saveState(state: LastTriggerMapState) {
        fileLock.withLock {
            try {
                val json = Json.encodeToString(state)
                // 先写备份
                if (stateFile.exists()) stateFile.copyTo(stateBackupFile, overwrite = true)
                // 写入新文件
                stateFile.writeText(json)
                LoggerUtil.logger.info("[$name] 已保存状态: ${state.map}, 文件路径=${stateFile.absolutePath}")
            } catch (e: Exception) {
                LoggerUtil.logger.error("[$name] 保存状态失败", e)
            }
        }
    }

}