Mofox-Core/src/chat/message_receive/chat_stream.py

import asyncio
import copy
import hashlib
import time
from typing import TYPE_CHECKING

from maim_message import GroupInfo, UserInfo
from rich.traceback import install
from sqlalchemy import select
from sqlalchemy.dialects.mysql import insert as mysql_insert
from sqlalchemy.dialects.sqlite import insert as sqlite_insert

from src.common.database.sqlalchemy_database_api import get_db_session
from src.common.database.sqlalchemy_models import ChatStreams  # 新增导入
from src.common.logger import get_logger
from src.config.config import global_config  # 新增导入

# 避免循环导入，使用TYPE_CHECKING进行类型提示
if TYPE_CHECKING:
    from .message import MessageRecv


install(extra_lines=3)


logger = get_logger("chat_stream")


class ChatStream:
    """聊天流对象，存储一个完整的聊天上下文"""

    def __init__(
        self,
        stream_id: str,
        platform: str,
        user_info: UserInfo,
        group_info: GroupInfo | None = None,
        data: dict | None = None,
    ):
        self.stream_id = stream_id
        self.platform = platform
        self.user_info = user_info
        self.group_info = group_info
        self.create_time = data.get("create_time", time.time()) if data else time.time()
        self.last_active_time = data.get("last_active_time", self.create_time) if data else self.create_time
        self.sleep_pressure = data.get("sleep_pressure", 0.0) if data else 0.0
        self.saved = False

        # 使用StreamContext替代ChatMessageContext
        from src.common.data_models.message_manager_data_model import StreamContext
        from src.plugin_system.base.component_types import ChatMode, ChatType

        # 创建StreamContext
        self.stream_context: StreamContext = StreamContext(
            stream_id=stream_id, chat_type=ChatType.GROUP if group_info else ChatType.PRIVATE, chat_mode=ChatMode.NORMAL
        )

        # 创建单流上下文管理器
        from src.chat.message_manager.context_manager import SingleStreamContextManager

        self.context_manager: SingleStreamContextManager = SingleStreamContextManager(
            stream_id=stream_id, context=self.stream_context
        )

        # 基础参数
        self.base_interest_energy = 0.5  # 默认基础兴趣度
        self._focus_energy = 0.5  # 内部存储的focus_energy值
        self.no_reply_consecutive = 0

    def __deepcopy__(self, memo):
        """自定义深拷贝方法，避免复制不可序列化的 asyncio.Task 对象"""
        import copy

        # 创建新的实例
        new_stream = ChatStream(
            stream_id=self.stream_id,
            platform=self.platform,
            user_info=copy.deepcopy(self.user_info, memo),
            group_info=copy.deepcopy(self.group_info, memo),
        )

        # 复制基本属性
        new_stream.create_time = self.create_time
        new_stream.last_active_time = self.last_active_time
        new_stream.sleep_pressure = self.sleep_pressure
        new_stream.saved = self.saved
        new_stream.base_interest_energy = self.base_interest_energy
        new_stream._focus_energy = self._focus_energy
        new_stream.no_reply_consecutive = self.no_reply_consecutive

        # 复制 stream_context，但跳过 processing_task
        new_stream.stream_context = copy.deepcopy(self.stream_context, memo)
        if hasattr(new_stream.stream_context, "processing_task"):
            new_stream.stream_context.processing_task = None

        # 复制 context_manager
        new_stream.context_manager = copy.deepcopy(self.context_manager, memo)

        return new_stream

    def to_dict(self) -> dict:
        """转换为字典格式"""
        return {
            "stream_id": self.stream_id,
            "platform": self.platform,
            "user_info": self.user_info.to_dict() if self.user_info else None,
            "group_info": self.group_info.to_dict() if self.group_info else None,
            "create_time": self.create_time,
            "last_active_time": self.last_active_time,
            "sleep_pressure": self.sleep_pressure,
            "focus_energy": self.focus_energy,
            # 基础兴趣度
            "base_interest_energy": self.base_interest_energy,
            # stream_context基本信息
            "stream_context_chat_type": self.stream_context.chat_type.value,
            "stream_context_chat_mode": self.stream_context.chat_mode.value,
            # 统计信息
            "interruption_count": self.stream_context.interruption_count,
        }

    @classmethod
    def from_dict(cls, data: dict) -> "ChatStream":
        """从字典创建实例"""
        user_info = UserInfo.from_dict(data.get("user_info", {})) if data.get("user_info") else None
        group_info = GroupInfo.from_dict(data.get("group_info", {})) if data.get("group_info") else None

        instance = cls(
            stream_id=data["stream_id"],
            platform=data["platform"],
            user_info=user_info,  # type: ignore
            group_info=group_info,
            data=data,
        )

        # 恢复stream_context信息
        if "stream_context_chat_type" in data:
            from src.plugin_system.base.component_types import ChatMode, ChatType

            instance.stream_context.chat_type = ChatType(data["stream_context_chat_type"])
        if "stream_context_chat_mode" in data:
            from src.plugin_system.base.component_types import ChatMode, ChatType

            instance.stream_context.chat_mode = ChatMode(data["stream_context_chat_mode"])

        # 恢复interruption_count信息
        if "interruption_count" in data:
            instance.stream_context.interruption_count = data["interruption_count"]

        # 确保 context_manager 已初始化
        if not hasattr(instance, "context_manager"):
            from src.chat.message_manager.context_manager import SingleStreamContextManager

            instance.context_manager = SingleStreamContextManager(
                stream_id=instance.stream_id, context=instance.stream_context
            )

        return instance

    def update_active_time(self):
        """更新最后活跃时间"""
        self.last_active_time = time.time()
        self.saved = False

    async def set_context(self, message: "MessageRecv"):
        """设置聊天消息上下文"""
        # 将MessageRecv转换为DatabaseMessages并设置到stream_context
        import json

        from src.common.data_models.database_data_model import DatabaseMessages

        # 安全获取message_info中的数据
        message_info = getattr(message, "message_info", {})
        user_info = getattr(message_info, "user_info", {})
        group_info = getattr(message_info, "group_info", {})

        # 提取reply_to信息（从message_segment中查找reply类型的段）
        reply_to = None
        if hasattr(message, "message_segment") and message.message_segment:
            reply_to = self._extract_reply_from_segment(message.message_segment)

        # 完整的数据转移逻辑
        db_message = DatabaseMessages(
            # 基础消息信息
            message_id=getattr(message, "message_id", ""),
            time=getattr(message, "time", time.time()),
            chat_id=self._generate_chat_id(message_info),
            reply_to=reply_to,
            # 兴趣度相关
            interest_value=getattr(message, "interest_value", 0.0),
            # 关键词
            key_words=json.dumps(getattr(message, "key_words", []), ensure_ascii=False)
            if getattr(message, "key_words", None)
            else None,
            key_words_lite=json.dumps(getattr(message, "key_words_lite", []), ensure_ascii=False)
            if getattr(message, "key_words_lite", None)
            else None,
            # 消息状态标记
            is_mentioned=getattr(message, "is_mentioned", None),
            is_at=getattr(message, "is_at", False),
            is_emoji=getattr(message, "is_emoji", False),
            is_picid=getattr(message, "is_picid", False),
            is_voice=getattr(message, "is_voice", False),
            is_video=getattr(message, "is_video", False),
            is_command=getattr(message, "is_command", False),
            is_notify=getattr(message, "is_notify", False),
            is_public_notice=getattr(message, "is_public_notice", False),
            notice_type=getattr(message, "notice_type", None),
            # 消息内容
            processed_plain_text=getattr(message, "processed_plain_text", ""),
            display_message=getattr(message, "processed_plain_text", ""),  # 默认使用processed_plain_text
            # 优先级信息
            priority_mode=getattr(message, "priority_mode", None),
            priority_info=json.dumps(getattr(message, "priority_info", None))
            if getattr(message, "priority_info", None)
            else None,
            # 额外配置
            additional_config=getattr(message_info, "additional_config", None),
            # 用户信息
            user_id=str(getattr(user_info, "user_id", "")),
            user_nickname=getattr(user_info, "user_nickname", ""),
            user_cardname=getattr(user_info, "user_cardname", None),
            user_platform=getattr(user_info, "platform", ""),
            # 群组信息
            chat_info_group_id=getattr(group_info, "group_id", None),
            chat_info_group_name=getattr(group_info, "group_name", None),
            chat_info_group_platform=getattr(group_info, "platform", None),
            # 聊天流信息
            chat_info_user_id=str(getattr(user_info, "user_id", "")),
            chat_info_user_nickname=getattr(user_info, "user_nickname", ""),
            chat_info_user_cardname=getattr(user_info, "user_cardname", None),
            chat_info_user_platform=getattr(user_info, "platform", ""),
            chat_info_stream_id=self.stream_id,
            chat_info_platform=self.platform,
            chat_info_create_time=self.create_time,
            chat_info_last_active_time=self.last_active_time,
            # 新增兴趣度系统字段 - 添加安全处理
            actions=self._safe_get_actions(message),
            should_reply=getattr(message, "should_reply", False),
            should_act=getattr(message, "should_act", False),
        )

        self.stream_context.set_current_message(db_message)
        self.stream_context.priority_mode = getattr(message, "priority_mode", None)
        self.stream_context.priority_info = getattr(message, "priority_info", None)

        # 调试日志：记录数据转移情况
        logger.debug(
            f"消息数据转移完成 - message_id: {db_message.message_id}, "
            f"chat_id: {db_message.chat_id}, "
            f"is_mentioned: {db_message.is_mentioned}, "
            f"is_emoji: {db_message.is_emoji}, "
            f"is_picid: {db_message.is_picid}, "
            f"interest_value: {db_message.interest_value}"
        )

    def _safe_get_actions(self, message: "MessageRecv") -> list | None:
        """安全获取消息的actions字段"""
        try:
            actions = getattr(message, "actions", None)
            if actions is None:
                return None

            # 如果是字符串，尝试解析为JSON
            if isinstance(actions, str):
                try:
                    import json

                    actions = json.loads(actions)
                except json.JSONDecodeError:
                    logger.warning(f"无法解析actions JSON字符串: {actions}")
                    return None

            # 确保返回列表类型
            if isinstance(actions, list):
                # 过滤掉空值和非字符串元素
                filtered_actions = [action for action in actions if action is not None and isinstance(action, str)]
                return filtered_actions if filtered_actions else None
            else:
                logger.warning(f"actions字段类型不支持: {type(actions)}")
                return None

        except Exception as e:
            logger.warning(f"获取actions字段失败: {e}")
            return None

    async def _calculate_message_interest(self, db_message):
        """计算消息兴趣值并更新消息对象"""
        try:
            from src.chat.interest_system.interest_manager import get_interest_manager

            interest_manager = get_interest_manager()

            if interest_manager.has_calculator():
                # 使用兴趣值计算组件计算
                result = await interest_manager.calculate_interest(db_message)

                if result.success:
                    # 更新消息对象的兴趣值相关字段
                    db_message.interest_value = result.interest_value
                    db_message.should_reply = result.should_reply
                    db_message.should_act = result.should_act

                    logger.debug(
                        f"消息 {db_message.message_id} 兴趣值已更新: {result.interest_value:.3f}, "
                        f"should_reply: {result.should_reply}, should_act: {result.should_act}"
                    )
                else:
                    logger.warning(f"消息 {db_message.message_id} 兴趣值计算失败: {result.error_message}")
                    # 使用默认值
                    db_message.interest_value = 0.3
                    db_message.should_reply = False
                    db_message.should_act = False
            else:
                # 没有兴趣值计算组件，抛出异常
                raise RuntimeError("没有可用的兴趣值计算组件")

        except Exception as e:
            logger.error(f"计算消息兴趣值失败: {e}", exc_info=True)
            # 异常情况下使用默认值
            if hasattr(db_message, "interest_value"):
                db_message.interest_value = 0.3
            if hasattr(db_message, "should_reply"):
                db_message.should_reply = False
            if hasattr(db_message, "should_act"):
                db_message.should_act = False

    def _extract_reply_from_segment(self, segment) -> str | None:
        """从消息段中提取reply_to信息"""
        try:
            if hasattr(segment, "type") and segment.type == "seglist":
                # 递归搜索seglist中的reply段
                if hasattr(segment, "data") and segment.data:
                    for seg in segment.data:
                        reply_id = self._extract_reply_from_segment(seg)
                        if reply_id:
                            return reply_id
            elif hasattr(segment, "type") and segment.type == "reply":
                # 找到reply段，返回message_id
                return str(segment.data) if segment.data else None
        except Exception as e:
            logger.warning(f"提取reply_to信息失败: {e}")
        return None

    def _generate_chat_id(self, message_info) -> str:
        """生成chat_id，基于群组或用户信息"""
        try:
            group_info = getattr(message_info, "group_info", None)
            user_info = getattr(message_info, "user_info", None)

            if group_info and hasattr(group_info, "group_id") and group_info.group_id:
                # 群聊：使用群组ID
                return f"{self.platform}_{group_info.group_id}"
            elif user_info and hasattr(user_info, "user_id") and user_info.user_id:
                # 私聊：使用用户ID
                return f"{self.platform}_{user_info.user_id}_private"
            else:
                # 默认：使用stream_id
                return self.stream_id
        except Exception as e:
            logger.warning(f"生成chat_id失败: {e}")
            return self.stream_id

    @property
    def focus_energy(self) -> float:
        """获取缓存的focus_energy值"""
        if hasattr(self, "_focus_energy"):
            return self._focus_energy
        else:
            return 0.5

    async def calculate_focus_energy(self) -> float:
        """异步计算focus_energy"""
        try:
            # 使用单流上下文管理器获取消息
            all_messages = self.context_manager.get_messages(limit=global_config.chat.max_context_size)

            # 获取用户ID
            user_id = None
            if self.user_info and hasattr(self.user_info, "user_id"):
                user_id = str(self.user_info.user_id)

            # 使用能量管理器计算
            from src.chat.energy_system import energy_manager

            energy = await energy_manager.calculate_focus_energy(
                stream_id=self.stream_id, messages=all_messages, user_id=user_id
            )

            # 更新内部存储
            self._focus_energy = energy

            logger.debug(f"聊天流 {self.stream_id} 能量: {energy:.3f}")
            return energy

        except Exception as e:
            logger.error(f"获取focus_energy失败: {e}", exc_info=True)
            # 返回缓存的值或默认值
            if hasattr(self, "_focus_energy"):
                return self._focus_energy
            else:
                return 0.5

    @focus_energy.setter
    def focus_energy(self, value: float):
        """设置focus_energy值（主要用于初始化或特殊场景）"""
        self._focus_energy = max(0.0, min(1.0, value))

    async def _get_user_relationship_score(self) -> float:
        """获取用户关系分"""
        # 使用统一的评分API
        try:
            from src.plugin_system.apis.scoring_api import scoring_api

            if self.user_info and hasattr(self.user_info, "user_id"):
                user_id = str(self.user_info.user_id)
                relationship_score = await scoring_api.get_user_relationship_score(user_id)
                logger.debug(f"ChatStream {self.stream_id}: 用户关系分 = {relationship_score:.3f}")
                return relationship_score

        except Exception as e:
            logger.warning(f"ChatStream {self.stream_id}: 关系分计算失败: {e}")

        # 默认基础分
        return 0.3


class ChatManager:
    """聊天管理器，管理所有聊天流"""

    _instance = None
    _initialized = False

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if not self._initialized:
            self.streams: dict[str, ChatStream] = {}  # stream_id -> ChatStream
            self.last_messages: dict[str, "MessageRecv"] = {}  # stream_id -> last_message
            # try:
            # async with get_db_session() as session:
            #     db.connect(reuse_if_open=True)
            #     # 确保 ChatStreams 表存在
            #     session.execute(text("CREATE TABLE IF NOT EXISTS chat_streams (stream_id TEXT PRIMARY KEY, platform TEXT, create_time REAL, last_active_time REAL, user_platform TEXT, user_id TEXT, user_nickname TEXT, user_cardname TEXT, group_platform TEXT, group_id TEXT, group_name TEXT)"))
            #     await session.commit()
            # except Exception as e:
            #     logger.error(f"数据库连接或 ChatStreams 表创建失败: {e}")

            self._initialized = True
            # 在事件循环中启动初始化
            # asyncio.create_task(self._initialize())
            # # 启动自动保存任务
            # asyncio.create_task(self._auto_save_task())

    async def _initialize(self):
        """异步初始化"""
        try:
            await self.load_all_streams()
            logger.info(f"聊天管理器已启动，已加载 {len(self.streams)} 个聊天流")
        except Exception as e:
            logger.error(f"聊天管理器启动失败: {e!s}")

    async def _auto_save_task(self):
        """定期自动保存所有聊天流"""
        while True:
            await asyncio.sleep(300)  # 每5分钟保存一次
            try:
                await self._save_all_streams()
                logger.info("聊天流自动保存完成")
            except Exception as e:
                logger.error(f"聊天流自动保存失败: {e!s}")

    def register_message(self, message: "MessageRecv"):
        """注册消息到聊天流"""
        stream_id = self._generate_stream_id(
            message.message_info.platform,  # type: ignore
            message.message_info.user_info,
            message.message_info.group_info,
        )
        self.last_messages[stream_id] = message
        # logger.debug(f"注册消息到聊天流: {stream_id}")

    @staticmethod
    def _generate_stream_id(platform: str, user_info: UserInfo | None, group_info: GroupInfo | None = None) -> str:
        """生成聊天流唯一ID"""
        if not user_info and not group_info:
            raise ValueError("用户信息或群组信息必须提供")

        if group_info:
            # 组合关键信息
            components = [platform, str(group_info.group_id)]
        else:
            components = [platform, str(user_info.user_id), "private"]  # type: ignore

        # 使用SHA-256生成唯一ID
        key = "_".join(components)
        return hashlib.sha256(key.encode()).hexdigest()

    @staticmethod
    def get_stream_id(platform: str, id: str, is_group: bool = True) -> str:
        """获取聊天流ID"""
        components = [platform, id] if is_group else [platform, id, "private"]
        key = "_".join(components)
        return hashlib.sha256(key.encode()).hexdigest()

    async def get_or_create_stream(
        self, platform: str, user_info: UserInfo, group_info: GroupInfo | None = None
    ) -> ChatStream:
        """获取或创建聊天流 - 优化版本使用缓存管理器

        Args:
            platform: 平台标识
            user_info: 用户信息
            group_info: 群组信息（可选）

        Returns:
            ChatStream: 聊天流对象
        """
        # 生成stream_id
        try:
            stream_id = self._generate_stream_id(platform, user_info, group_info)

            # 优先使用缓存管理器（优化版本）
            try:
                from src.chat.message_manager.stream_cache_manager import get_stream_cache_manager

                cache_manager = get_stream_cache_manager()

                if cache_manager.is_running:
                    optimized_stream = await cache_manager.get_or_create_stream(
                        stream_id=stream_id, platform=platform, user_info=user_info, group_info=group_info
                    )

                    # 设置消息上下文
                    from .message import MessageRecv

                    if stream_id in self.last_messages and isinstance(self.last_messages[stream_id], MessageRecv):
                        optimized_stream.set_context(self.last_messages[stream_id])

                    # 转换为原始ChatStream以保持兼容性
                    original_stream = self._convert_to_original_stream(optimized_stream)

                    return original_stream

            except Exception as e:
                logger.debug(f"缓存管理器获取流失败，使用原始方法: {e}")

            # 回退到原始方法
            # 检查内存中是否存在
            if stream_id in self.streams:
                stream = self.streams[stream_id]

                # 更新用户信息和群组信息
                stream.update_active_time()
                stream = copy.deepcopy(stream)  # 返回副本以避免外部修改影响缓存
                if user_info and user_info.platform and user_info.user_id:
                    stream.user_info = user_info
                if group_info:
                    stream.group_info = group_info
                from .message import MessageRecv  # 延迟导入，避免循环引用

                if stream_id in self.last_messages and isinstance(self.last_messages[stream_id], MessageRecv):
                    await stream.set_context(self.last_messages[stream_id])
                else:
                    logger.error(f"聊天流 {stream_id} 不在最后消息列表中，可能是新创建的")
                return stream

            # 检查数据库中是否存在
            async def _db_find_stream_async(s_id: str):
                async with get_db_session() as session:
                    return (
                        (await session.execute(select(ChatStreams).where(ChatStreams.stream_id == s_id)))
                        .scalars()
                        .first()
                    )

            model_instance = await _db_find_stream_async(stream_id)

            if model_instance:
                # 从 SQLAlchemy 模型转换回 ChatStream.from_dict 期望的格式
                user_info_data = {
                    "platform": model_instance.user_platform,
                    "user_id": model_instance.user_id,
                    "user_nickname": model_instance.user_nickname,
                    "user_cardname": model_instance.user_cardname or "",
                }
                group_info_data = None
                if model_instance and getattr(model_instance, "group_id", None):
                    group_info_data = {
                        "platform": model_instance.group_platform,
                        "group_id": model_instance.group_id,
                        "group_name": model_instance.group_name,
                    }

                data_for_from_dict = {
                    "stream_id": model_instance.stream_id,
                    "platform": model_instance.platform,
                    "user_info": user_info_data,
                    "group_info": group_info_data,
                    "create_time": model_instance.create_time,
                    "last_active_time": model_instance.last_active_time,
                    "energy_value": model_instance.energy_value,
                    "sleep_pressure": model_instance.sleep_pressure,
                }
                stream = ChatStream.from_dict(data_for_from_dict)
                # 更新用户信息和群组信息
                stream.user_info = user_info
                if group_info:
                    stream.group_info = group_info
                stream.update_active_time()
            else:
                # 创建新的聊天流
                stream = ChatStream(
                    stream_id=stream_id,
                    platform=platform,
                    user_info=user_info,
                    group_info=group_info,
                )
        except Exception as e:
            logger.error(f"获取或创建聊天流失败: {e}", exc_info=True)
            raise e

        stream = copy.deepcopy(stream)
        from .message import MessageRecv  # 延迟导入，避免循环引用

        if stream_id in self.last_messages and isinstance(self.last_messages[stream_id], MessageRecv):
            await stream.set_context(self.last_messages[stream_id])
        else:
            logger.error(f"聊天流 {stream_id} 不在最后消息列表中，可能是新创建的")

        # 确保 ChatStream 有自己的 context_manager
        if not hasattr(stream, "context_manager"):
            # 创建新的单流上下文管理器
            from src.chat.message_manager.context_manager import SingleStreamContextManager

            stream.context_manager = SingleStreamContextManager(stream_id=stream_id, context=stream.stream_context)

        # 保存到内存和数据库
        self.streams[stream_id] = stream
        await self._save_stream(stream)
        return stream

    async def get_stream(self, stream_id: str) -> ChatStream | None:
        """通过stream_id获取聊天流"""
        stream = self.streams.get(stream_id)
        if not stream:
            return None
        if stream_id in self.last_messages:
            await stream.set_context(self.last_messages[stream_id])
        return stream

    def get_stream_by_info(
        self, platform: str, user_info: UserInfo, group_info: GroupInfo | None = None
    ) -> ChatStream | None:
        """通过信息获取聊天流"""
        stream_id = self._generate_stream_id(platform, user_info, group_info)
        return self.streams.get(stream_id)

    async def get_stream_name(self, stream_id: str) -> str | None:
        """根据 stream_id 获取聊天流名称"""
        stream = await self.get_stream(stream_id)
        if not stream:
            return None

        if stream.group_info and stream.group_info.group_name:
            return stream.group_info.group_name
        elif stream.user_info and stream.user_info.user_nickname:
            return f"{stream.user_info.user_nickname}的私聊"
        else:
            return None

    @staticmethod
    def _prepare_stream_data(stream_data_dict: dict) -> dict:
        """准备聊天流保存数据"""
        user_info_d = stream_data_dict.get("user_info")
        group_info_d = stream_data_dict.get("group_info")

        return {
            "platform": stream_data_dict["platform"],
            "create_time": stream_data_dict["create_time"],
            "last_active_time": stream_data_dict["last_active_time"],
            "user_platform": user_info_d["platform"] if user_info_d else "",
            "user_id": user_info_d["user_id"] if user_info_d else "",
            "user_nickname": user_info_d["user_nickname"] if user_info_d else "",
            "user_cardname": user_info_d.get("user_cardname", "") if user_info_d else None,
            "group_platform": group_info_d["platform"] if group_info_d else "",
            "group_id": group_info_d["group_id"] if group_info_d else "",
            "group_name": group_info_d["group_name"] if group_info_d else "",
            "energy_value": stream_data_dict.get("energy_value", 5.0),
            "sleep_pressure": stream_data_dict.get("sleep_pressure", 0.0),
            "focus_energy": stream_data_dict.get("focus_energy", 0.5),
            # 新增动态兴趣度系统字段
            "base_interest_energy": stream_data_dict.get("base_interest_energy", 0.5),
            "message_interest_total": stream_data_dict.get("message_interest_total", 0.0),
            "message_count": stream_data_dict.get("message_count", 0),
            "action_count": stream_data_dict.get("action_count", 0),
            "reply_count": stream_data_dict.get("reply_count", 0),
            "last_interaction_time": stream_data_dict.get("last_interaction_time", time.time()),
            "consecutive_no_reply": stream_data_dict.get("consecutive_no_reply", 0),
            "interruption_count": stream_data_dict.get("interruption_count", 0),
        }

    @staticmethod
    async def _save_stream(stream: ChatStream):
        """保存聊天流到数据库 - 优化版本使用异步批量写入"""
        if stream.saved:
            return
        stream_data_dict = stream.to_dict()

        # 优先使用新的批量写入器
        try:
            from src.chat.message_manager.batch_database_writer import get_batch_writer

            batch_writer = get_batch_writer()
            if batch_writer.is_running:
                success = await batch_writer.schedule_stream_update(
                    stream_id=stream_data_dict["stream_id"],
                    update_data=ChatManager._prepare_stream_data(stream_data_dict),
                    priority=1,  # 流更新的优先级
                )
                if success:
                    stream.saved = True
                    logger.debug(f"聊天流 {stream.stream_id} 通过批量写入器调度成功")
                    return
                else:
                    logger.warning(f"批量写入器队列已满，使用原始方法: {stream.stream_id}")
            else:
                logger.debug(f"批量写入器未运行，使用原始方法: {stream.stream_id}")

        except Exception as e:
            logger.debug(f"批量写入器保存聊天流失败，使用原始方法: {e}")

        # 尝试使用数据库批量调度器（回退方案1）
        try:
            from src.common.database.db_batch_scheduler import batch_update, get_batch_session

            async with get_batch_session():
                # 使用批量更新
                result = await batch_update(
                    model_class=ChatStreams,
                    conditions={"stream_id": stream_data_dict["stream_id"]},
                    data=ChatManager._prepare_stream_data(stream_data_dict),
                )
                if result and result > 0:
                    stream.saved = True
                    logger.debug(f"聊天流 {stream.stream_id} 通过批量调度器保存成功")
                    return
        except (ImportError, Exception) as e:
            logger.debug(f"批量调度器保存聊天流失败，使用原始方法: {e}")

        # 回退到原始方法（最终方案）
        async def _db_save_stream_async(s_data_dict: dict):
            async with get_db_session() as session:
                user_info_d = s_data_dict.get("user_info")
                group_info_d = s_data_dict.get("group_info")
                fields_to_save = {
                    "platform": s_data_dict["platform"],
                    "create_time": s_data_dict["create_time"],
                    "last_active_time": s_data_dict["last_active_time"],
                    "user_platform": user_info_d["platform"] if user_info_d else "",
                    "user_id": user_info_d["user_id"] if user_info_d else "",
                    "user_nickname": user_info_d["user_nickname"] if user_info_d else "",
                    "user_cardname": user_info_d.get("user_cardname", "") if user_info_d else None,
                    "group_platform": group_info_d["platform"] if group_info_d else "",
                    "group_id": group_info_d["group_id"] if group_info_d else "",
                    "group_name": group_info_d["group_name"] if group_info_d else "",
                    "energy_value": s_data_dict.get("energy_value", 5.0),
                    "sleep_pressure": s_data_dict.get("sleep_pressure", 0.0),
                    "focus_energy": s_data_dict.get("focus_energy", 0.5),
                    # 新增动态兴趣度系统字段
                    "base_interest_energy": s_data_dict.get("base_interest_energy", 0.5),
                    "message_interest_total": s_data_dict.get("message_interest_total", 0.0),
                    "message_count": s_data_dict.get("message_count", 0),
                    "action_count": s_data_dict.get("action_count", 0),
                    "reply_count": s_data_dict.get("reply_count", 0),
                    "last_interaction_time": s_data_dict.get("last_interaction_time", time.time()),
                    "consecutive_no_reply": s_data_dict.get("consecutive_no_reply", 0),
                    "interruption_count": s_data_dict.get("interruption_count", 0),
                }
                if global_config.database.database_type == "sqlite":
                    stmt = sqlite_insert(ChatStreams).values(stream_id=s_data_dict["stream_id"], **fields_to_save)
                    stmt = stmt.on_conflict_do_update(index_elements=["stream_id"], set_=fields_to_save)
                elif global_config.database.database_type == "mysql":
                    stmt = mysql_insert(ChatStreams).values(stream_id=s_data_dict["stream_id"], **fields_to_save)
                    stmt = stmt.on_duplicate_key_update(
                        **{key: value for key, value in fields_to_save.items() if key != "stream_id"}
                    )
                else:
                    stmt = sqlite_insert(ChatStreams).values(stream_id=s_data_dict["stream_id"], **fields_to_save)
                    stmt = stmt.on_conflict_do_update(index_elements=["stream_id"], set_=fields_to_save)
                await session.execute(stmt)
                await session.commit()

        try:
            await _db_save_stream_async(stream_data_dict)
            stream.saved = True
        except Exception as e:
            logger.error(f"保存聊天流 {stream.stream_id} 到数据库失败 (SQLAlchemy): {e}", exc_info=True)

    async def _save_all_streams(self):
        """保存所有聊天流"""
        for stream in self.streams.values():
            await self._save_stream(stream)

    async def load_all_streams(self):
        """从数据库加载所有聊天流"""
        logger.info("正在从数据库加载所有聊天流")

        async def _db_load_all_streams_async():
            loaded_streams_data = []
            async with get_db_session() as session:
                result = await session.execute(select(ChatStreams))
                for model_instance in result.scalars().all():
                    user_info_data = {
                        "platform": model_instance.user_platform,
                        "user_id": model_instance.user_id,
                        "user_nickname": model_instance.user_nickname,
                        "user_cardname": model_instance.user_cardname or "",
                    }
                    group_info_data = None
                    if model_instance and getattr(model_instance, "group_id", None):
                        group_info_data = {
                            "platform": model_instance.group_platform,
                            "group_id": model_instance.group_id,
                            "group_name": model_instance.group_name,
                        }
                    data_for_from_dict = {
                        "stream_id": model_instance.stream_id,
                        "platform": model_instance.platform,
                        "user_info": user_info_data,
                        "group_info": group_info_data,
                        "create_time": model_instance.create_time,
                        "last_active_time": model_instance.last_active_time,
                        "energy_value": model_instance.energy_value,
                        "sleep_pressure": model_instance.sleep_pressure,
                        "focus_energy": getattr(model_instance, "focus_energy", 0.5),
                        # 新增动态兴趣度系统字段 - 使用getattr提供默认值
                        "base_interest_energy": getattr(model_instance, "base_interest_energy", 0.5),
                        "message_interest_total": getattr(model_instance, "message_interest_total", 0.0),
                        "message_count": getattr(model_instance, "message_count", 0),
                        "action_count": getattr(model_instance, "action_count", 0),
                        "reply_count": getattr(model_instance, "reply_count", 0),
                        "last_interaction_time": getattr(model_instance, "last_interaction_time", time.time()),
                        "relationship_score": getattr(model_instance, "relationship_score", 0.3),
                        "consecutive_no_reply": getattr(model_instance, "consecutive_no_reply", 0),
                        "interruption_count": getattr(model_instance, "interruption_count", 0),
                    }
                    loaded_streams_data.append(data_for_from_dict)
                await session.commit()
            return loaded_streams_data

        try:
            all_streams_data_list = await _db_load_all_streams_async()
            self.streams.clear()
            for data in all_streams_data_list:
                stream = ChatStream.from_dict(data)
                stream.saved = True
                self.streams[stream.stream_id] = stream
                # 不在异步加载中设置上下文，避免复杂依赖
                # if stream.stream_id in self.last_messages:
                #     await stream.set_context(self.last_messages[stream.stream_id])

                # 确保 ChatStream 有自己的 context_manager
                if not hasattr(stream, "context_manager"):
                    from src.chat.message_manager.context_manager import SingleStreamContextManager

                    stream.context_manager = SingleStreamContextManager(
                        stream_id=stream.stream_id, context=stream.stream_context
                    )
        except Exception as e:
            logger.error(f"从数据库加载所有聊天流失败 (SQLAlchemy): {e}", exc_info=True)


chat_manager = None


def _convert_to_original_stream(self, optimized_stream) -> "ChatStream":
    """将OptimizedChatStream转换为原始ChatStream以保持兼容性"""
    try:
        # 创建原始ChatStream实例
        original_stream = ChatStream(
            stream_id=optimized_stream.stream_id,
            platform=optimized_stream.platform,
            user_info=optimized_stream._get_effective_user_info(),
            group_info=optimized_stream._get_effective_group_info(),
        )

        # 复制状态
        original_stream.create_time = optimized_stream.create_time
        original_stream.last_active_time = optimized_stream.last_active_time
        original_stream.sleep_pressure = optimized_stream.sleep_pressure
        original_stream.base_interest_energy = optimized_stream.base_interest_energy
        original_stream._focus_energy = optimized_stream._focus_energy
        original_stream.no_reply_consecutive = optimized_stream.no_reply_consecutive
        original_stream.saved = optimized_stream.saved

        # 复制上下文信息（如果存在）
        if hasattr(optimized_stream, "_stream_context") and optimized_stream._stream_context:
            original_stream.stream_context = optimized_stream._stream_context

        if hasattr(optimized_stream, "_context_manager") and optimized_stream._context_manager:
            original_stream.context_manager = optimized_stream._context_manager

        return original_stream

    except Exception as e:
        logger.error(f"转换OptimizedChatStream失败: {e}")
        # 如果转换失败，创建一个新的原始流
        return ChatStream(
            stream_id=optimized_stream.stream_id,
            platform=optimized_stream.platform,
            user_info=optimized_stream._get_effective_user_info(),
            group_info=optimized_stream._get_effective_group_info(),
        )


def get_chat_manager():
    global chat_manager
    if chat_manager is None:
        chat_manager = ChatManager()
    return chat_manager