初始化

src/mais4u/mais4u_chat/gift_manager.py

@@ -0,0 +1,155 @@
+import asyncio
+from typing import Dict, Tuple, Callable, Optional
+from dataclasses import dataclass
+
+from src.chat.message_receive.message import MessageRecvS4U
+from src.common.logger import get_logger
+
+logger = get_logger("gift_manager")
+
+
+@dataclass
+class PendingGift:
+    """等待中的礼物消息"""
+    message: MessageRecvS4U
+    total_count: int
+    timer_task: asyncio.Task
+    callback: Callable[[MessageRecvS4U], None]
+
+
+class GiftManager:
+    """礼物管理器，提供防抖功能"""
+    
+    def __init__(self):
+        """初始化礼物管理器"""
+        self.pending_gifts: Dict[Tuple[str, str], PendingGift] = {}
+        self.debounce_timeout = 5.0  # 3秒防抖时间
+    
+    async def handle_gift(self, message: MessageRecvS4U, callback: Optional[Callable[[MessageRecvS4U], None]] = None) -> bool:
+        """处理礼物消息，返回是否应该立即处理
+        
+        Args:
+            message: 礼物消息
+            callback: 防抖完成后的回调函数
+            
+        Returns:
+            bool: False表示消息被暂存等待防抖，True表示应该立即处理
+        """
+        if not message.is_gift:
+            return True
+            
+        # 构建礼物的唯一键：(发送人ID, 礼物名称)
+        gift_key = (message.message_info.user_info.user_id, message.gift_name)
+        
+        # 如果已经有相同的礼物在等待中，则合并
+        if gift_key in self.pending_gifts:
+            await self._merge_gift(gift_key, message)
+            return False
+        
+        # 创建新的等待礼物
+        await self._create_pending_gift(gift_key, message, callback)
+        return False
+    
+    async def _merge_gift(self, gift_key: Tuple[str, str], new_message: MessageRecvS4U) -> None:
+        """合并礼物消息"""
+        pending_gift = self.pending_gifts[gift_key]
+        
+        # 取消之前的定时器
+        if not pending_gift.timer_task.cancelled():
+            pending_gift.timer_task.cancel()
+        
+        # 累加礼物数量
+        try:
+            new_count = int(new_message.gift_count)
+            pending_gift.total_count += new_count
+            
+            # 更新消息为最新的（保留最新的消息，但累加数量）
+            pending_gift.message = new_message
+            pending_gift.message.gift_count = str(pending_gift.total_count)
+            pending_gift.message.gift_info = f"{pending_gift.message.gift_name}:{pending_gift.total_count}"
+            
+        except ValueError:
+            logger.warning(f"无法解析礼物数量: {new_message.gift_count}")
+            # 如果无法解析数量，保持原有数量不变
+        
+        # 重新创建定时器
+        pending_gift.timer_task = asyncio.create_task(
+            self._gift_timeout(gift_key)
+        )
+        
+        logger.debug(f"合并礼物: {gift_key}, 总数量: {pending_gift.total_count}")
+    
+    async def _create_pending_gift(
+        self, 
+        gift_key: Tuple[str, str], 
+        message: MessageRecvS4U, 
+        callback: Optional[Callable[[MessageRecvS4U], None]]
+    ) -> None:
+        """创建新的等待礼物"""
+        try:
+            initial_count = int(message.gift_count)
+        except ValueError:
+            initial_count = 1
+            logger.warning(f"无法解析礼物数量: {message.gift_count}，默认设为1")
+        
+        # 创建定时器任务
+        timer_task = asyncio.create_task(self._gift_timeout(gift_key))
+        
+        # 创建等待礼物对象
+        pending_gift = PendingGift(
+            message=message,
+            total_count=initial_count,
+            timer_task=timer_task,
+            callback=callback
+        )
+        
+        self.pending_gifts[gift_key] = pending_gift
+        
+        logger.debug(f"创建等待礼物: {gift_key}, 初始数量: {initial_count}")
+    
+    async def _gift_timeout(self, gift_key: Tuple[str, str]) -> None:
+        """礼物防抖超时处理"""
+        try:
+            # 等待防抖时间
+            await asyncio.sleep(self.debounce_timeout)
+            
+            # 获取等待中的礼物
+            if gift_key not in self.pending_gifts:
+                return
+                
+            pending_gift = self.pending_gifts.pop(gift_key)
+            
+            logger.info(f"礼物防抖完成: {gift_key}, 最终数量: {pending_gift.total_count}")
+            
+            message = pending_gift.message
+            message.processed_plain_text = f"用户{message.message_info.user_info.user_nickname}送出了礼物{message.gift_name} x{pending_gift.total_count}"
+            
+            # 执行回调
+            if pending_gift.callback:
+                try:
+                    pending_gift.callback(message)
+                except Exception as e:
+                    logger.error(f"礼物回调执行失败: {e}", exc_info=True)
+            
+        except asyncio.CancelledError:
+            # 定时器被取消，不需要处理
+            pass
+        except Exception as e:
+            logger.error(f"礼物防抖处理异常: {e}", exc_info=True)
+    
+    def get_pending_count(self) -> int:
+        """获取当前等待中的礼物数量"""
+        return len(self.pending_gifts)
+    
+    async def flush_all(self) -> None:
+        """立即处理所有等待中的礼物"""
+        for gift_key in list(self.pending_gifts.keys()):
+            pending_gift = self.pending_gifts.get(gift_key)
+            if pending_gift and not pending_gift.timer_task.cancelled():
+                pending_gift.timer_task.cancel()
+                await self._gift_timeout(gift_key)
+
+
+# 创建全局礼物管理器实例
+gift_manager = GiftManager()
+