import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from core.handlers.event_handler import MessageHandler, NoticeHandler, RequestHandler
from models.events.message import GroupMessageEvent
from models.events.notice import GroupIncreaseNoticeEvent
from models.events.request import FriendRequestEvent

@pytest.fixture
def mock_bot():
    bot = AsyncMock()
    return bot

@pytest.mark.asyncio
async def test_message_handler_run_handler_injection(mock_bot):
    """测试参数注入"""
    handler = MessageHandler(prefixes=("/",))
    
    # 1. 测试注入 bot 和 event
    async def func1(bot, event):
        assert bot == mock_bot
        assert event.user_id == 123
        return True
        
    event = MagicMock(spec=GroupMessageEvent)
    event.user_id = 123
    
    result = await handler._run_handler(func1, mock_bot, event)
    assert result is True
    
    # 2. 测试注入 args
    async def func2(args):
        assert args == ["arg1", "arg2"]
        return True
        
    result = await handler._run_handler(func2, mock_bot, event, args=["arg1", "arg2"])
    assert result is True

@pytest.mark.asyncio
async def test_message_handler_command_parsing(mock_bot):
    """测试命令解析"""
    handler = MessageHandler(prefixes=("/",))
    
    mock_func = AsyncMock()
    handler.commands["test"] = {
        "func": mock_func,
        "permission": None,
        "override_permission_check": False,
        "plugin_name": "test_plugin"
    }
    
    event = MagicMock(spec=GroupMessageEvent)
    event.raw_message = "/test arg1 arg2"
    event.user_id = 123
    
    # Mock permission manager
    with patch("core.managers.permission_manager.PermissionManager.check_permission", new_callable=AsyncMock) as mock_perm:
        mock_perm.return_value = True
        
        await handler.handle(mock_bot, event)
        
        mock_func.assert_called_once()
        # 验证 args 参数是否正确传递
        call_args = mock_func.call_args
        if "args" in call_args.kwargs:
            assert call_args.kwargs["args"] == ["arg1", "arg2"]

@pytest.mark.asyncio
async def test_notice_handler(mock_bot):
    """测试通知事件分发"""
    handler = NoticeHandler()
    
    mock_func = AsyncMock()
    handler.handlers.append({
        "type": "group_increase",
        "func": mock_func,
        "plugin_name": "test_plugin"
    })
    
    event = MagicMock(spec=GroupIncreaseNoticeEvent)
    event.notice_type = "group_increase"
    
    await handler.handle(mock_bot, event)
    
    mock_func.assert_called_once()

@pytest.mark.asyncio
async def test_sync_handler_execution(mock_bot):
    """测试同步处理函数的执行"""
    handler = MessageHandler(prefixes=("/",))
    
    def sync_func(event):
        return True
        
    event = MagicMock(spec=GroupMessageEvent)
    
    # 同步函数应该在线程池中运行
    result = await handler._run_handler(sync_func, mock_bot, event)
    assert result is True

@pytest.mark.asyncio
async def test_message_handler_management(mock_bot):
    """测试消息处理器的管理（注册、卸载、清空）"""
    handler = MessageHandler(prefixes=("/",))
    
    # 测试 on_message 装饰器
    @handler.on_message()
    async def msg_handler(event):
        pass
        
    assert len(handler.message_handlers) == 1
    
    # 测试 command 装饰器
    @handler.command("cmd1", "cmd2")
    async def cmd_handler(event):
        pass
        
    assert len(handler.commands) == 2
    assert "cmd1" in handler.commands
    assert "cmd2" in handler.commands
    
    # 测试 unregister_by_plugin_name
    # 直接从已注册的处理器中获取 plugin_name
    if handler.message_handlers:
        plugin_name = handler.message_handlers[0]["plugin_name"]
        handler.unregister_by_plugin_name(plugin_name)
    
    assert len(handler.message_handlers) == 0
    assert len(handler.commands) == 0
    
    # 测试 clear
    handler.commands["cmd"] = {}
    handler.message_handlers.append({})
    handler.clear()
    assert len(handler.commands) == 0
    assert len(handler.message_handlers) == 0

@pytest.mark.asyncio
async def test_request_handler(mock_bot):
    """测试请求事件处理器"""
    handler = RequestHandler()
    
    mock_func = AsyncMock()
    
    # 测试 register 装饰器
    @handler.register("friend")
    async def req_handler(event):
        await mock_func(event)
        
    assert len(handler.handlers) == 1
    
    event = MagicMock(spec=FriendRequestEvent)
    event.request_type = "friend"
    
    await handler.handle(mock_bot, event)
    mock_func.assert_called_once()
    
    # 测试 unregister 和 clear
    import inspect
    module = inspect.getmodule(req_handler)
    plugin_name = module.__name__
    
    handler.unregister_by_plugin_name(plugin_name)
    assert len(handler.handlers) == 0
    
    handler.handlers.append({})
    handler.clear()
    assert len(handler.handlers) == 0

@pytest.mark.asyncio
async def test_permission_denied(mock_bot):
    """测试权限不足的情况"""
    handler = MessageHandler(prefixes=("/",))
    
    mock_func = AsyncMock()
    handler.commands["admin_cmd"] = {
        "func": mock_func,
        "permission": "ADMIN", # 假设 Permission.ADMIN
        "override_permission_check": False,
        "plugin_name": "test_plugin"
    }
    
    event = MagicMock(spec=GroupMessageEvent)
    event.raw_message = "/admin_cmd"
    event.user_id = 123
    
    # Mock permission manager returning False
    with patch("core.managers.permission_manager.PermissionManager.check_permission", new_callable=AsyncMock) as mock_perm:
        mock_perm.return_value = False
        
        await handler.handle(mock_bot, event)
        
        mock_func.assert_not_called()
        # 应该发送拒绝消息
        mock_bot.send.assert_called_once()