# -*- coding: utf-8 -*-
"""
事件路由与转换器 (Event Router & Converter)

此模块负责在不同平台（如 Discord）和 OneBot 业务逻辑之间进行数据转换。
核心目标是：**让现有的 OneBot 插件（如 bili.py）在不修改任何代码的情况下，能够处理 Discord 消息。**

实现原理：
1. 接收 Discord 消息 (`discord.Message`)。
2. 将其“伪装”成 OneBot 的 `GroupMessageEvent` 或 `PrivateMessageEvent`。
3. 拦截插件调用的 `event.reply()` 方法。
4. 将插件返回的 OneBot `MessageSegment` 转换为 Discord 格式并发送。
"""
import asyncio
from typing import Union, List, Any, Optional, Dict

try:
    import discord
    DISCORD_AVAILABLE = True
except ImportError:
    DISCORD_AVAILABLE = False

from models.events.message import GroupMessageEvent, PrivateMessageEvent
from models.message import MessageSegment as OneBotMessageSegment
from models.sender import Sender
from core.utils.logger import ModuleLogger

logger = ModuleLogger("EventRouter")

class DiscordBotWrapper:
    """
    包装 DiscordAdapter，提供与 OneBot 相同的发送接口。
    """
    def __init__(self, adapter: Any):
        self.adapter = adapter
        self.self_id = adapter.user.id if adapter.user else 0

    async def send_group_msg(self, group_id: int, message: Union[str, OneBotMessageSegment, List[OneBotMessageSegment]], auto_escape: bool = False):
        channel = self.adapter.get_channel(group_id)
        if not channel:
            logger.error(f"Discord channel {group_id} not found")
            return
        await DiscordToOneBotConverter.send_discord_message(channel, message, self.adapter)

    async def send_private_msg(self, user_id: int, message: Union[str, OneBotMessageSegment, List[OneBotMessageSegment]], auto_escape: bool = False):
        user = self.adapter.get_user(user_id)
        if not user:
            logger.error(f"Discord user {user_id} not found")
            return
        if not user.dm_channel:
            await user.create_dm()
        await DiscordToOneBotConverter.send_discord_message(user.dm_channel, message, self.adapter)

    async def send(self, event, message, **kwargs):
        if isinstance(event, GroupMessageEvent):
            await self.send_group_msg(event.group_id, message)
        elif isinstance(event, PrivateMessageEvent):
            await self.send_private_msg(event.user_id, message)

    def build_forward_node(self, user_id: int, nickname: str, message: Union[str, OneBotMessageSegment, List[OneBotMessageSegment]]) -> Dict[str, Any]:
        """
        构建一个用于合并转发的消息节点 (Node)。
        """
        processed_message = message
        if isinstance(message, OneBotMessageSegment):
            processed_message = [{"type": message.type, "data": message.data}]
        elif isinstance(message, list):
            processed_message = [{"type": seg.type, "data": seg.data} if isinstance(seg, OneBotMessageSegment) else seg for seg in message]
            
        return {
            "type": "node",
            "data": {
                "uin": user_id,
                "name": nickname,
                "content": processed_message
            }
        }

    async def send_forwarded_messages(self, target, nodes):
        """
        模拟发送合并转发消息。
        Discord 不支持像 QQ 那样的合并转发，所以我们将其转换为普通消息发送。
        """
        content = ""
        files = []
        
        for node in nodes:
            if node.get("type") == "node":
                node_data = node.get("data", {})
                node_content = node_data.get("content", [])
                
                if isinstance(node_content, str):
                    import re
                    cq_pattern = r'\[CQ:([^,]+)(?:,([^\]]+))?\]'
                    matches = list(re.finditer(cq_pattern, node_content))
                    
                    if not matches:
                        content += f"{node_content}\n"
                    else:
                        last_end = 0
                        for match in matches:
                            if match.start() > last_end:
                                content += node_content[last_end:match.start()]
                                
                            cq_type = match.group(1)
                            cq_params_str = match.group(2) or ""
                            
                            params = {}
                            if cq_params_str:
                                for param in cq_params_str.split(','):
                                    if '=' in param:
                                        k, v = param.split('=', 1)
                                        params[k] = v
                                        
                            if cq_type in ("image", "video", "record"):
                                        file_url = params.get("url") or params.get("file")
                                        if file_url:
                                            if str(file_url).startswith("http"):
                                                content += f"\n{file_url}\n"
                                            elif str(file_url).startswith("base64://"):
                                                import base64
                                                import io
                                                b64_data = str(file_url)[9:]
                                                if b64_data.startswith("data:image") or b64_data.startswith("data:audio") or b64_data.startswith("data:video"):
                                                    b64_data = b64_data.split(",", 1)[1]
                                                try:
                                                    file_bytes = base64.b64decode(b64_data)
                                                    filename = "file.png" if cq_type == "image" else ("file.mp4" if cq_type == "video" else "file.ogg")
                                                    files.append(discord.File(fp=io.BytesIO(file_bytes), filename=filename))
                                                except Exception as e:
                                                    logger.error(f"解析 Base64 文件失败: {e}")
                                            else:
                                                try:
                                                    files.append(discord.File(file_url))
                                                except Exception as e:
                                                    logger.error(f"无法读取本地文件 {file_url}: {e}")
                            elif cq_type == "face":
                                        # QQ 表情，简单转为文本
                                        face_id = params.get("id")
                                        content += f"[表情:{face_id}]"
                            elif cq_type == "at":
                                qq_id = params.get("qq")
                                if qq_id == "all":
                                    content += "@everyone "
                                else:
                                    content += f"<@{qq_id}> "
                                    
                            last_end = match.end()
                            
                        if last_end < len(node_content):
                            content += node_content[last_end:]
                        content += "\n"
                elif isinstance(node_content, list):
                    for seg in node_content:
                        if isinstance(seg, dict):
                            seg_type = seg.get("type")
                            seg_data = seg.get("data", {})
                            
                            if seg_type == "text":
                                content += seg_data.get("text", "")
                            elif seg_type in ("image", "video", "record"):
                                file_url = seg_data.get("url") or seg_data.get("file")
                                if file_url:
                                    if isinstance(file_url, bytes):
                                        import io
                                        try:
                                            filename = "file.png" if seg_type == "image" else ("file.mp4" if seg_type == "video" else "file.ogg")
                                            files.append(discord.File(fp=io.BytesIO(file_url), filename=filename))
                                        except Exception as e:
                                            logger.error(f"解析 bytes 文件失败: {e}")
                                    elif str(file_url).startswith("http"):
                                        content += f"\n{file_url}\n"
                                    elif str(file_url).startswith("base64://") or "data:image" in str(file_url) or "data:audio" in str(file_url) or "data:video" in str(file_url):
                                        import base64
                                        import io
                                        b64_data = str(file_url)
                                        if b64_data.startswith("base64://"):
                                            b64_data = b64_data[9:]
                                        if b64_data.startswith("data:image") or b64_data.startswith("data:audio") or b64_data.startswith("data:video"):
                                            b64_data = b64_data.split(",", 1)[1]
                                        try:
                                            file_bytes = base64.b64decode(b64_data)
                                            filename = "file.png" if seg_type == "image" else ("file.mp4" if seg_type == "video" else "file.ogg")
                                            files.append(discord.File(fp=io.BytesIO(file_bytes), filename=filename))
                                        except Exception as e:
                                            logger.error(f"解析 Base64 文件失败: {e}")
                                    else:
                                        try:
                                            files.append(discord.File(file_url))
                                        except Exception as e:
                                            logger.error(f"无法读取本地文件 {file_url}: {e}")
                            elif seg_type == "face":
                                face_id = seg_data.get("id")
                                content += f"[表情:{face_id}]"
                content += "\n"
        
        try:
            if content or files:
                # target is usually event, we can use event.bot.send
                if isinstance(target, GroupMessageEvent):
                    channel = self.adapter.get_channel(target.group_id)
                    if channel:
                        await channel.send(content=content, files=files if files else None)
                elif isinstance(target, PrivateMessageEvent):
                    user = self.adapter.get_user(target.user_id)
                    if user:
                        if not user.dm_channel:
                            await user.create_dm()
                        await user.dm_channel.send(content=content, files=files if files else None)
        except Exception as e:
            logger.error(f"发送 Discord 合并转发消息失败: {e}")

class DiscordToOneBotConverter:
    """
    将 Discord 消息转换为 OneBot 消息事件的转换器。
    """
    
    @staticmethod
    def create_mock_event(discord_message: 'discord.Message', adapter: Any) -> Union[GroupMessageEvent, PrivateMessageEvent]:
        """
        将 discord.Message 伪装成 OneBot 的 MessageEvent。
        
        Args:
            discord_message: 原始的 Discord 消息对象
            adapter: DiscordAdapter 实例，用于回调发送消息
            
        Returns:
            伪装后的 OneBot 事件对象
        """
        # 在方法内部导入 logger，避免作用域问题
        from core.utils.logger import logger
        
        # 1. 提取基础信息
        user_id = discord_message.author.id
        message_id = discord_message.id
        
        # 处理 Discord 的 raw_message
        # 如果消息是以 @机器人 开头，Discord 的 content 会是 "<@机器人ID> /echo 1"
        # 我们需要把前面的 @ 提及去掉，否则命令匹配器 (matcher) 无法识别以 "/" 开头的命令
        raw_message = discord_message.content
        
        # 构造 message 列表 (将文本和附件转换为 MessageSegment)
        message_list = []
        
        # 添加文本内容
        if discord_message.content:
            # 处理 Discord 自定义表情 <:name:id> 或 <a:name:id>
            import re
            content = discord_message.content
            
            # 查找所有自定义表情
            emoji_pattern = r'<a?:([^:]+):(\d+)>'
            
            # 如果有表情，我们需要将文本分割成多个片段
            if re.search(emoji_pattern, content):
                last_end = 0
                for match in re.finditer(emoji_pattern, content):
                    # 添加表情前的文本
                    if match.start() > last_end:
                        text_part = content[last_end:match.start()]
                        if text_part:
                            message_list.append(OneBotMessageSegment.text(text_part))
                    
                    # 添加表情作为图片
                    emoji_name = match.group(1)
                    emoji_id = match.group(2)
                    is_animated = match.group(0).startswith('<a:')
                    ext = 'gif' if is_animated else 'png'
                    emoji_url = f"https://cdn.discordapp.com/emojis/{emoji_id}.{ext}"
                    
                    seg = OneBotMessageSegment.image(emoji_url)
                    seg.data["filename"] = f"{emoji_name}.{ext}"
                    message_list.append(seg)
                    
                    last_end = match.end()
                
                # 添加剩余的文本
                if last_end < len(content):
                    text_part = content[last_end:]
                    if text_part:
                        message_list.append(OneBotMessageSegment.text(text_part))
            else:
                message_list.append(OneBotMessageSegment.text(content))
        
        # 如果消息只包含表情（没有文本），更新 raw_message 以包含表情信息
        if not raw_message.strip() or raw_message.strip().startswith('<'):
            import re
            raw_message = re.sub(r'<a?:([^:]+):(\d+)>', r'[\1]', raw_message)
        
        # 添加附件信息
        if discord_message.attachments:
            logger.debug(f"[DiscordToOneBotConverter] 检测到 {len(discord_message.attachments)} 个附件")
            for attachment in discord_message.attachments:
                filename = attachment.filename.lower()
                logger.debug(f"[DiscordToOneBotConverter] 处理附件: {attachment.filename}, MIME: {attachment.content_type}")
                # 检查是否是语音文件
                if filename.endswith(('.amr', '.silk', '.mp3', '.wav', '.ogg', '.m4a')):
                    seg = OneBotMessageSegment.record(attachment.url)
                    seg.data["filename"] = attachment.filename
                    message_list.append(seg)
                    raw_message += f"\n[语音: {attachment.filename}]"
                    logger.debug(f"[DiscordToOneBotConverter] 识别为语音文件: {attachment.filename}")
                elif filename.endswith(('.mp4', '.avi', '.mkv', '.mov', '.flv', '.wmv')):
                    seg = OneBotMessageSegment.video(attachment.url)
                    seg.data["filename"] = attachment.filename
                    message_list.append(seg)
                    raw_message += f"\n[视频: {attachment.filename}]"
                    logger.debug(f"[DiscordToOneBotConverter] 识别为视频文件: {attachment.filename}")
                elif filename.endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
                    image_type = "gif" if filename.endswith('.gif') else None
                    seg = OneBotMessageSegment.image(attachment.url, image_type=image_type)
                    seg.data["filename"] = attachment.filename
                    message_list.append(seg)
                    raw_message += f"\n[图片: {attachment.filename}]"
                    logger.debug(f"[DiscordToOneBotConverter] 识别为图片文件: {attachment.filename}")
                else:
                    seg = OneBotMessageSegment.file(attachment.url)
                    seg.data["filename"] = attachment.filename
                    message_list.append(seg)
                    raw_message += f"\n[文件: {attachment.filename}]"
                    logger.success(f"[DiscordToOneBotConverter] 识别为普通文件: {attachment.filename}")
                    
        # 添加贴纸 (Stickers) 信息
        if hasattr(discord_message, 'stickers') and discord_message.stickers:
            for sticker in discord_message.stickers:
                seg = OneBotMessageSegment.image(sticker.url)
                seg.data["filename"] = f"{sticker.name}.png"
                message_list.append(seg)
                raw_message += f"\n[贴纸: {sticker.name}]"
        bot_mention = f"<@{adapter.user.id}>"
        if raw_message.startswith(bot_mention):
            raw_message = raw_message[len(bot_mention):].strip()
            # 如果 message_list 的第一个元素是文本，也需要去掉 @ 提及
            if message_list and message_list[0].type == "text":
                text_content = message_list[0].data.get("text", "")
                if text_content.startswith(bot_mention):
                    message_list[0].data["text"] = text_content[len(bot_mention):].strip()
            
        # 构造发送者信息
        sender = Sender(
            user_id=user_id,
            nickname=discord_message.author.display_name,
            card=getattr(discord_message.author, 'nick', ''), # 群名片
            role="member" # 简化处理，默认都是普通成员
        )
        
        # 2. 判断是群聊还是私聊
        is_private = isinstance(discord_message.channel, discord.DMChannel)
        
        import time
        current_time = int(time.time())
        self_id = adapter.user.id if adapter.user else 0
        
        # 注入 Discord 特定信息（用于跨平台插件识别）
        discord_channel_id = discord_message.channel.id if not isinstance(discord_message.channel, discord.DMChannel) else None
        discord_username = discord_message.author.name
        discord_discriminator = f"#{discord_message.author.discriminator}" if discord_message.author.discriminator != "0" else ""
        
        if is_private:
            # 构造私聊事件
            event = PrivateMessageEvent(
                time=current_time,
                self_id=self_id,
                platform="discord",
                message_type="private",
                sub_type="friend",
                message_id=message_id,
                user_id=user_id,
                raw_message=raw_message,
                message=message_list,
                sender=sender
            )
        else:
            # 构造群聊事件
            group_id = discord_message.channel.id
            event = GroupMessageEvent(
                time=current_time,
                self_id=self_id,
                platform="discord",
                message_type="group",
                sub_type="normal",
                message_id=message_id,
                user_id=user_id,
                group_id=group_id,
                raw_message=raw_message,
                message=message_list,
                sender=sender
            )
            
        # 注入 Discord 特定属性（用于跨平台插件识别）
        event._is_discord_message = True
        event.discord_channel_id = discord_channel_id
        event.discord_username = discord_username
        event.discord_discriminator = discord_discriminator
            
        # 注入 DiscordBotWrapper
        event.bot = DiscordBotWrapper(adapter)
        
        return event

    @staticmethod
    async def send_discord_message(
        channel: 'discord.abc.Messageable', 
        message: Union[str, OneBotMessageSegment, List[OneBotMessageSegment]],
        adapter: Any
    ):
        """
        将 OneBot 的消息段转换为 Discord 格式并发送。
        
        Args:
            channel: Discord 频道对象 (TextChannel, DMChannel 等)
            message: 插件返回的 OneBot 消息内容 (字符串或 MessageSegment 列表)
            adapter: DiscordAdapter 实例
        """
        content = ""
        files = []
        
        # 统一转换为列表处理
        if not isinstance(message, list):
            message = [message]
            
        import re
        
        for segment in message:
            if isinstance(segment, str):
                # 尝试解析 CQ 码
                cq_pattern = r'\[CQ:([^,]+)(?:,([^\]]+))?\]'
                matches = list(re.finditer(cq_pattern, segment))
                
                if not matches:
                    content += segment
                    continue
                    
                last_end = 0
                for match in matches:
                    # 添加 CQ 码之前的纯文本
                    if match.start() > last_end:
                        content += segment[last_end:match.start()]
                        
                    cq_type = match.group(1)
                    cq_params_str = match.group(2) or ""
                    
                    # 解析参数
                    params = {}
                    if cq_params_str:
                        for param in cq_params_str.split(','):
                            if '=' in param:
                                k, v = param.split('=', 1)
                                params[k] = v
                                
                    if cq_type in ("image", "video", "record"):
                        file_url = params.get("url") or params.get("file")
                        if file_url:
                            if str(file_url).startswith("http"):
                                content += f"\n{file_url}"
                            elif str(file_url).startswith("base64://") or "data:image" in str(file_url) or "data:audio" in str(file_url) or "data:video" in str(file_url):
                                import base64
                                import io
                                b64_data = str(file_url)
                                if b64_data.startswith("base64://"):
                                    b64_data = b64_data[9:]
                                if b64_data.startswith("data:image") or b64_data.startswith("data:audio") or b64_data.startswith("data:video"):
                                    b64_data = b64_data.split(",", 1)[1]
                                try:
                                    file_bytes = base64.b64decode(b64_data)
                                    filename = "file.png" if cq_type == "image" else ("file.mp4" if cq_type == "video" else "file.ogg")
                                    files.append(discord.File(fp=io.BytesIO(file_bytes), filename=filename))
                                except Exception as e:
                                    logger.error(f"解析 Base64 文件失败: {e}")
                            else:
                                try:
                                    files.append(discord.File(file_url))
                                except Exception as e:
                                    logger.error(f"无法读取本地文件 {file_url}: {e}")
                    elif cq_type == "face":
                        face_id = params.get("id")
                        content += f"[表情:{face_id}]"
                    elif cq_type == "at":
                        qq_id = params.get("qq")
                        if qq_id == "all":
                            content += "@everyone "
                        else:
                            content += f"<@{qq_id}> "
                            
                    last_end = match.end()
                    
                # 添加最后一个 CQ 码之后的纯文本
                if last_end < len(segment):
                    content += segment[last_end:]
                    
            elif isinstance(segment, OneBotMessageSegment):
                # 解析 OneBot 的 MessageSegment
                seg_type = segment.type
                seg_data = segment.data
                
                if seg_type == "text":
                    content += seg_data.get("text", "")
                elif seg_type in ("image", "video", "record"):
                    # OneBot 的图片/视频/语音通常有 file (URL或本地路径) 或 url 字段
                    file_url = seg_data.get("url") or seg_data.get("file")
                    
                    if file_url:
                        # 处理 bytes 类型
                        if isinstance(file_url, bytes):
                            import io
                            try:
                                filename = "file.png" if seg_type == "image" else ("file.mp4" if seg_type == "video" else "file.ogg")
                                files.append(discord.File(fp=io.BytesIO(file_url), filename=filename))
                            except Exception as e:
                                logger.error(f"解析 bytes 文件失败: {e}")
                        elif str(file_url).startswith("http"):
                            # 如果是网络 URL，直接拼接到文本中，Discord 会自动解析预览
                            content += f"\n{file_url}"
                        elif str(file_url).startswith("base64://") or "data:image" in str(file_url) or "data:audio" in str(file_url) or "data:video" in str(file_url):
                            # 处理 Base64 文件 (需要解码并作为文件上传)
                            import base64
                            import io
                            b64_data = str(file_url)
                            if b64_data.startswith("base64://"):
                                b64_data = b64_data[9:]
                            if b64_data.startswith("data:image") or b64_data.startswith("data:audio") or b64_data.startswith("data:video"):
                                b64_data = b64_data.split(",", 1)[1]
                            try:
                                file_bytes = base64.b64decode(b64_data)
                                filename = "file.png" if seg_type == "image" else ("file.mp4" if seg_type == "video" else "file.ogg")
                                files.append(discord.File(fp=io.BytesIO(file_bytes), filename=filename))
                            except Exception as e:
                                logger.error(f"解析 Base64 文件失败: {e}")
                        else:
                            # 假设是本地文件路径
                            try:
                                files.append(discord.File(file_url))
                            except Exception as e:
                                logger.error(f"无法读取本地文件 {file_url}: {e}")
                elif seg_type == "face":
                    face_id = seg_data.get("id")
                    content += f"[表情:{face_id}]"
                elif seg_type == "at":
                    qq_id = seg_data.get("qq")
                    if qq_id == "all":
                        content += "@everyone "
                    else:
                        # 尝试将 QQ 号映射回 Discord ID (这里简单处理，直接拼接)
                        content += f"<@{qq_id}> "
                elif seg_type == "reply":
                    # 忽略回复段，或者你可以尝试映射 message_id
                    pass

        # 发送消息到 Discord
        try:
            # 如果内容为空但有文件，Discord 允许发送
            if content or files:
                await channel.send(content=content, files=files if files else None)
            else:
                logger.warning("尝试发送空消息到 Discord，已拦截")
        except Exception as e:
            logger.error(f"发送 Discord 消息失败: {e}")