from __future__ import annotations

import typing
import asyncio
import traceback
import base64
import json
import os
from urllib.parse import urlparse

import nio

from langbot.pkg.utils import httpclient
import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
import langbot_plugin.api.entities.builtin.platform.message as platform_message
import langbot_plugin.api.entities.builtin.platform.events as platform_events
import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_platform_logger


_MAX_MATRIX_MEDIA_BYTES = 10 * 1024 * 1024


def _decode_matrix_base64_limited(value: str) -> bytes:
    if ';base64,' in value:
        value = value.split(';base64,', 1)[1]
    max_encoded_bytes = 4 * ((_MAX_MATRIX_MEDIA_BYTES + 2) // 3)
    if len(value) > max_encoded_bytes:
        raise ValueError('Matrix media exceeds the size limit')
    decoded = base64.b64decode(value)
    if len(decoded) > _MAX_MATRIX_MEDIA_BYTES:
        raise ValueError('Matrix media exceeds the size limit')
    return decoded


def _read_matrix_file_limited(path: str) -> bytes:
    if os.path.getsize(path) > _MAX_MATRIX_MEDIA_BYTES:
        raise ValueError('Matrix media exceeds the size limit')
    with open(path, 'rb') as file:
        body = file.read(_MAX_MATRIX_MEDIA_BYTES + 1)
    if len(body) > _MAX_MATRIX_MEDIA_BYTES:
        raise ValueError('Matrix media exceeds the size limit')
    return body


async def _download_matrix_media_limited(
    client: nio.AsyncClient,
    mxc_url: str,
) -> tuple[bytes, str]:
    parsed = urlparse(mxc_url)
    if parsed.scheme != 'mxc' or not parsed.netloc or not parsed.path.strip('/'):
        raise ValueError('Invalid Matrix media URL')
    method, path = nio.Api.download(
        parsed.netloc,
        parsed.path.replace('/', ''),
        access_token=None,
    )
    headers = {}
    if client.access_token:
        headers['Authorization'] = f'Bearer {client.access_token}'
    response = await client.send(method, path, headers=headers, timeout=30)
    try:
        response.raise_for_status()
        body = await httpclient.read_limited(
            response,
            max_bytes=_MAX_MATRIX_MEDIA_BYTES,
        )
        return body, response.headers.get('Content-Type', 'application/octet-stream')
    finally:
        response.release()


class MatrixMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
    @staticmethod
    async def yiri2target(message_chain: platform_message.MessageChain, client: nio.AsyncClient) -> list[dict]:
        components = []
        for component in message_chain:
            if isinstance(component, platform_message.Plain):
                components.append({'type': 'text', 'text': component.text})
            elif isinstance(component, platform_message.Image):
                image_bytes = None
                if component.base64:
                    image_bytes = await asyncio.to_thread(
                        _decode_matrix_base64_limited,
                        component.base64,
                    )
                elif component.url:
                    session = httpclient.get_session()
                    async with session.get(component.url) as response:
                        image_bytes = await httpclient.read_limited(
                            response,
                            max_bytes=_MAX_MATRIX_MEDIA_BYTES,
                        )
                elif component.path:
                    image_bytes = await asyncio.to_thread(
                        _read_matrix_file_limited,
                        str(component.path),
                    )
                if image_bytes:
                    resp = await client.upload(image_bytes, content_type='image/png')
                    if isinstance(resp, nio.UploadResponse):
                        components.append({'type': 'image', 'mxc_url': resp.content_uri})
            elif isinstance(component, platform_message.File):
                file_bytes = None
                if component.base64:
                    file_bytes = await asyncio.to_thread(
                        _decode_matrix_base64_limited,
                        component.base64,
                    )
                elif component.url:
                    session = httpclient.get_session()
                    async with session.get(component.url) as response:
                        file_bytes = await httpclient.read_limited(
                            response,
                            max_bytes=_MAX_MATRIX_MEDIA_BYTES,
                        )
                elif component.path:
                    file_bytes = await asyncio.to_thread(
                        _read_matrix_file_limited,
                        str(component.path),
                    )
                if file_bytes:
                    file_name = getattr(component, 'name', None) or 'file'
                    resp = await client.upload(file_bytes, content_type='application/octet-stream', filename=file_name)
                    if isinstance(resp, nio.UploadResponse):
                        components.append(
                            {
                                'type': 'file',
                                'mxc_url': resp.content_uri,
                                'filename': file_name,
                                'size': len(file_bytes),
                            }
                        )
            elif isinstance(component, platform_message.Forward):
                for node in component.node_list:
                    components.extend(await MatrixMessageConverter.yiri2target(node.message_chain, client))
        return components

    @staticmethod
    async def target2yiri(event: nio.RoomMessageText | nio.RoomMessageImage, client: nio.AsyncClient, bot_user_id: str):
        message_components = []

        if isinstance(event, nio.RoomMessageText):
            text = event.body
            if bot_user_id and bot_user_id in text:
                message_components.append(platform_message.At(target=bot_user_id))
                text = text.replace(bot_user_id, '').strip()
            message_components.append(platform_message.Plain(text=text))

        elif isinstance(event, nio.RoomMessageImage):
            mxc_url = event.url
            if mxc_url:
                body, content_type = await _download_matrix_media_limited(
                    client,
                    mxc_url,
                )
                b64 = (await asyncio.to_thread(base64.b64encode, body)).decode('utf-8')
                message_components.append(platform_message.Image(base64=f'data:{content_type};base64,{b64}'))
            if event.body:
                message_components.append(platform_message.Plain(text=event.body))

        return platform_message.MessageChain(message_components)


class MatrixEventConverter(abstract_platform_adapter.AbstractEventConverter):
    @staticmethod
    async def yiri2target(event: platform_events.MessageEvent):
        return event.source_platform_object

    @staticmethod
    async def target2yiri(
        event: nio.RoomMessageText | nio.RoomMessageImage,
        room: nio.MatrixRoom,
        client: nio.AsyncClient,
        bot_user_id: str,
        bridge_user_ids: list[str] | None = None,
    ):
        lb_message = await MatrixMessageConverter.target2yiri(event, client, bot_user_id)

        # Determine if this is a direct/private chat or a group chat.
        # Exclude bot itself and bridge bots, count remaining real users.
        exclude_ids = {bot_user_id}
        if bridge_user_ids:
            exclude_ids.update(bridge_user_ids)
        real_users = [uid for uid in room.users if uid not in exclude_ids]
        is_direct = len(real_users) <= 1

        if is_direct:
            return platform_events.FriendMessage(
                sender=platform_entities.Friend(
                    id=event.sender,
                    nickname=room.user_name(event.sender) or event.sender,
                    remark='',
                ),
                message_chain=lb_message,
                time=event.server_timestamp / 1000.0,
                source_platform_object={'event': event, 'room': room},
            )
        else:
            return platform_events.GroupMessage(
                sender=platform_entities.GroupMember(
                    id=event.sender,
                    member_name=room.user_name(event.sender) or event.sender,
                    permission=platform_entities.Permission.Member,
                    group=platform_entities.Group(
                        id=room.room_id,
                        name=room.display_name or room.room_id,
                        permission=platform_entities.Permission.Member,
                    ),
                    special_title='',
                ),
                message_chain=lb_message,
                time=event.server_timestamp / 1000.0,
                source_platform_object={'event': event, 'room': room},
            )


class BridgeState:
    """Per-bridge runtime state."""

    def __init__(self, user_id: str, login_command: str, logout_command: str, success_keyword: str, check_command: str):
        self.user_id = user_id
        self.login_command = login_command
        self.logout_command = logout_command
        self.success_keyword = success_keyword
        self.check_command = check_command or login_command
        self.logged_in = False
        self.dm_room_id: str | None = None
        self.login_task: asyncio.Task | None = None
        self.check_task: asyncio.Task | None = None
        self.check_responded = False


class MatrixAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
    client: typing.Any = None
    message_converter: MatrixMessageConverter = MatrixMessageConverter()
    event_converter: MatrixEventConverter = MatrixEventConverter()
    config: dict
    listeners: typing.Dict[typing.Type[platform_events.Event], typing.Callable] = {}
    _running: bool = False
    _initial_sync_done: bool = False
    _bridges: list = []

    def __init__(self, config: dict, logger: abstract_platform_logger.AbstractEventLogger):
        homeserver_url = config.get('homeserver_url', '')
        access_token = config.get('access_token', '')
        user_id = config.get('user_id', '')

        if not homeserver_url or not access_token or not user_id:
            raise ValueError('Matrix 机器人缺少必要配置项 (homeserver_url, user_id, access_token)')

        client = nio.AsyncClient(homeserver_url, user_id)
        client.access_token = access_token
        client.user_id = user_id

        super().__init__(
            config=config,
            logger=logger,
            bot_account_id=user_id,
            client=client,
            listeners={},
        )

        # Parse bridges config AFTER super().__init__() to avoid Pydantic resetting _bridges
        self._bridges = []
        bridges_raw = config.get('bridges', '')
        if bridges_raw:
            if isinstance(bridges_raw, str):
                try:
                    bridges_list = json.loads(bridges_raw)
                except (json.JSONDecodeError, TypeError) as e:
                    raise ValueError(f'bridges 配置 JSON 解析失败: {e}\n原始值: {bridges_raw}')
            else:
                bridges_list = bridges_raw
            for b in bridges_list:
                if isinstance(b, dict) and b.get('user_id', '').strip():
                    self._bridges.append(
                        BridgeState(
                            user_id=b['user_id'].strip(),
                            login_command=b.get('login_command', '').strip(),
                            logout_command=b.get('logout_command', '').strip(),
                            success_keyword=b.get('success_keyword', 'Successfully logged in').strip(),
                            check_command=b.get('check_command', '').strip(),
                        )
                    )
        # Backward compatibility: old single-bridge config
        if not self._bridges:
            old_user_id = config.get('bridge_user_id', '').strip()
            old_command = config.get('bridge_login_command', '').strip()
            old_keyword = config.get('bridge_login_success_keyword', 'Successfully logged in').strip()
            old_check = config.get('bridge_check_command', '').strip()
            old_logout = config.get('bridge_logout_command', '').strip()
            if old_user_id:
                self._bridges.append(
                    BridgeState(
                        user_id=old_user_id,
                        login_command=old_command,
                        logout_command=old_logout,
                        success_keyword=old_keyword,
                        check_command=old_check,
                    )
                )

    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
        components = await self.message_converter.yiri2target(message, self.client)
        for component in components:
            await self._send_component(target_id, component)

    async def reply_message(
        self,
        message_source: platform_events.MessageEvent,
        message: platform_message.MessageChain,
        quote_origin: bool = False,
    ):
        source_obj = message_source.source_platform_object
        room_id = source_obj['room'].room_id
        components = await self.message_converter.yiri2target(message, self.client)

        for component in components:
            if quote_origin:
                original_event = source_obj['event']
                await self._send_component(room_id, component, reply_to=original_event.event_id)
            else:
                await self._send_component(room_id, component)

    async def _send_component(self, room_id: str, component: dict, reply_to: str | None = None):
        content = {}
        if component['type'] == 'text':
            content = {
                'msgtype': 'm.text',
                'body': component['text'],
            }
        elif component['type'] == 'image':
            content = {
                'msgtype': 'm.image',
                'body': 'image.png',
                'url': component['mxc_url'],
            }
        elif component['type'] == 'file':
            content = {
                'msgtype': 'm.file',
                'body': component.get('filename', 'file'),
                'url': component['mxc_url'],
                'info': {'size': component.get('size', 0)},
            }

        if reply_to and content:
            content['m.relates_to'] = {
                'm.in_reply_to': {'event_id': reply_to},
            }

        if content:
            await self.client.room_send(
                room_id=room_id,
                message_type='m.room.message',
                content=content,
            )

    def register_listener(
        self,
        event_type: typing.Type[platform_events.Event],
        callback: typing.Callable[
            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
        ],
    ):
        self.listeners[event_type] = callback

    async def run_async(self):
        self._running = True
        await self.logger.info('Matrix adapter starting...')

        # Debug: log bridge parsing result
        bridges_raw = self.config.get('bridges', '')
        await self.logger.debug(f'bridges config raw: type={type(bridges_raw).__name__}, repr={repr(bridges_raw)}')
        await self.logger.debug(
            f'parsed _bridges count: {len(self._bridges)}, ids: {[b.user_id for b in self._bridges]}'
        )

        # Collect all bridge bot user IDs for filtering
        _bridge_user_ids = [b.user_id for b in self._bridges]
        _bridge_user_id_set = set(_bridge_user_ids)

        # Auto-join invited rooms
        async def on_invite(room: nio.MatrixRoom, event: nio.InviteMemberEvent):
            if event.membership == 'invite' and event.state_key == self.client.user_id:
                await self.client.join(room.room_id)
                await self.logger.debug(f'Auto-joined room: {room.display_name or room.room_id}')

        self.client.add_event_callback(on_invite, nio.InviteMemberEvent)

        # Handle text messages
        async def on_message(room: nio.MatrixRoom, event: nio.RoomMessageText):
            if not self._initial_sync_done:
                return
            if event.sender == self.client.user_id:
                return

            # Admin commands (from any non-bridge user)
            if event.sender not in _bridge_user_id_set:
                body = (event.body or '').strip()
                if body == '!relogin':
                    await self._handle_relogin_command(room.room_id)
                    return
                if body == '!status':
                    await self._handle_status_command(room.room_id)
                    return

            if event.sender in _bridge_user_id_set:
                return
            try:
                lb_event = await self.event_converter.target2yiri(
                    event, room, self.client, self.bot_account_id, _bridge_user_ids
                )
                if type(lb_event) in self.listeners:
                    result = self.listeners[type(lb_event)](lb_event, self)
                    if asyncio.iscoroutine(result):
                        await result
            except Exception:
                await self.logger.error(f'Error handling Matrix message: {traceback.format_exc()}')

        self.client.add_event_callback(on_message, nio.RoomMessageText)

        # Handle image messages
        async def on_image(room: nio.MatrixRoom, event: nio.RoomMessageImage):
            if not self._initial_sync_done:
                return
            if event.sender == self.client.user_id:
                return
            if event.sender in _bridge_user_id_set:
                return
            try:
                lb_event = await self.event_converter.target2yiri(
                    event, room, self.client, self.bot_account_id, _bridge_user_ids
                )
                if type(lb_event) in self.listeners:
                    result = self.listeners[type(lb_event)](lb_event, self)
                    if asyncio.iscoroutine(result):
                        await result
            except Exception:
                await self.logger.error(f'Error handling Matrix image: {traceback.format_exc()}')

        self.client.add_event_callback(on_image, nio.RoomMessageImage)

        # Set up bridge-specific callbacks for each bridge
        _disconnect_keywords = ['disconnected', 'logged out', 'connection lost', 'session expired', 'token expired']

        for bridge in self._bridges:
            # Login success detection (notice)
            async def on_bridge_notice(room: nio.MatrixRoom, event: nio.RoomMessageNotice, _b=bridge):
                if not self._initial_sync_done:
                    return
                if event.sender != _b.user_id:
                    return
                _b.check_responded = True
                if _b.success_keyword in (event.body or ''):
                    _b.logged_in = True
                    await self.logger.info(f'[{_b.user_id}] Bridge login succeeded.')
                # Disconnect detection
                body_lower = (event.body or '').lower()
                for kw in _disconnect_keywords:
                    if kw in body_lower and _b.logged_in:
                        _b.logged_in = False
                        await self.logger.info(f'[{_b.user_id}] Bridge 账号掉线 (检测到: "{kw}"), 将自动重新登录...')
                        self._restart_bridge_login(_b)
                        break

            self.client.add_event_callback(on_bridge_notice, nio.RoomMessageNotice)

            # Login success + disconnect detection (text)
            async def on_bridge_text(room: nio.MatrixRoom, event: nio.RoomMessageText, _b=bridge):
                if not self._initial_sync_done:
                    return
                if event.sender != _b.user_id:
                    return
                _b.check_responded = True
                if _b.success_keyword in (event.body or ''):
                    _b.logged_in = True
                    await self.logger.info(f'[{_b.user_id}] Bridge login succeeded.')
                body_lower = (event.body or '').lower()
                for kw in _disconnect_keywords:
                    if kw in body_lower and _b.logged_in:
                        _b.logged_in = False
                        await self.logger.info(f'[{_b.user_id}] Bridge 账号掉线 (检测到: "{kw}"), 将自动重新登录...')
                        self._restart_bridge_login(_b)
                        break

            self.client.add_event_callback(on_bridge_text, nio.RoomMessageText)

            # QR code image forwarding
            async def on_bridge_image(room: nio.MatrixRoom, event: nio.RoomMessageImage, _b=bridge):
                if not self._initial_sync_done:
                    return
                if event.sender != _b.user_id:
                    return
                mxc_url = event.url
                if not mxc_url:
                    return
                try:
                    body, content_type = await _download_matrix_media_limited(
                        self.client,
                        mxc_url,
                    )
                    b64 = (await asyncio.to_thread(base64.b64encode, body)).decode('utf-8')
                    await self.logger.info(
                        f'[{_b.user_id}] Bridge 发送了二维码，请扫码登录:',
                        images=[platform_message.Image(base64=f'data:{content_type};base64,{b64}')],
                    )
                except Exception:
                    await self.logger.error(
                        f'[{_b.user_id}] Failed to download bridge QR image: {traceback.format_exc()}'
                    )

            self.client.add_event_callback(on_bridge_image, nio.RoomMessageImage)

        await self.logger.debug('Matrix adapter running, starting sync...')

        # Initial sync to skip old messages
        resp = await self.client.sync(timeout=10000)
        if isinstance(resp, nio.SyncResponse):
            await self.logger.debug(f'Matrix initial sync done, next_batch: {resp.next_batch}')
        self._initial_sync_done = True

        # Display account info
        display_name = self.client.user_id
        try:
            profile_resp = await self.client.get_displayname(self.client.user_id)
            if isinstance(profile_resp, nio.ProfileGetDisplayNameResponse) and profile_resp.displayname:
                display_name = profile_resp.displayname
        except Exception:
            pass
        joined_rooms = len(self.client.rooms)
        homeserver = self.config.get('homeserver_url', '')
        bridge_info = ''
        if self._bridges:
            bridge_names = ', '.join(b.user_id for b in self._bridges)
            bridge_info = f' | 桥接: [{bridge_names}]'
        await self.logger.info(
            f'Matrix 账号: {display_name} ({self.client.user_id}) | '
            f'服务器: {homeserver} | 已加入 {joined_rooms} 个房间{bridge_info}'
        )

        # Start bridge login and status check tasks for each bridge
        for bridge in self._bridges:
            if bridge.login_command:
                await self.logger.info(
                    f'[{bridge.user_id}] Bridge login enabled (命令: "{bridge.login_command}", '
                    f'关键词: "{bridge.success_keyword}")'
                )
                bridge.login_task = asyncio.create_task(self._periodic_bridge_login(bridge))
                bridge.check_task = asyncio.create_task(self._periodic_bridge_check(bridge))
            else:
                await self.logger.debug(f'[{bridge.user_id}] Bridge login not configured (no login_command)')

        # Main sync loop
        while self._running:
            try:
                await self.client.sync(timeout=30000)
            except Exception:
                await self.logger.error(f'Matrix sync error: {traceback.format_exc()}')
                await asyncio.sleep(5)

    async def _periodic_bridge_login(self, bridge: BridgeState):
        """Periodically send login command to a bridge bot until login succeeds."""
        try:
            await self.logger.info(f'[{bridge.user_id}] Bridge login task started, looking for DM room...')
            dm_room_id = None
            for room_id, room in self.client.rooms.items():
                if room.member_count == 2 and bridge.user_id in [m for m in room.users]:
                    dm_room_id = room_id
                    break

            if not dm_room_id:
                resp = await self.client.room_create(
                    is_direct=True,
                    invite=[bridge.user_id],
                )
                if isinstance(resp, nio.RoomCreateResponse):
                    dm_room_id = resp.room_id
                    await self.logger.debug(f'[{bridge.user_id}] Created DM room: {dm_room_id}')
                else:
                    await self.logger.error(f'[{bridge.user_id}] Failed to create DM room: {resp}')
                    return

            bridge.dm_room_id = dm_room_id

            # Force logout first on every adapter start
            logout_cmd = bridge.logout_command or bridge.login_command.replace('login', 'logout')
            await self.logger.info(f'[{bridge.user_id}] 强制登出: "{logout_cmd}"')
            await self.client.room_send(
                room_id=dm_room_id,
                message_type='m.room.message',
                content={'msgtype': 'm.text', 'body': logout_cmd},
            )
            await asyncio.sleep(3)

            while self._running and not bridge.logged_in:
                await self.logger.debug(f'[{bridge.user_id}] Sending "{bridge.login_command}" in room {dm_room_id}')
                await self.client.room_send(
                    room_id=dm_room_id,
                    message_type='m.room.message',
                    content={'msgtype': 'm.text', 'body': bridge.login_command},
                )
                for _ in range(60):
                    if not self._running or bridge.logged_in:
                        break
                    await asyncio.sleep(1)

            if bridge.logged_in:
                await self.logger.debug(f'[{bridge.user_id}] Bridge login confirmed, periodic login stopped.')
        except asyncio.CancelledError:
            pass
        except Exception:
            await self.logger.error(f'[{bridge.user_id}] Bridge periodic login error: {traceback.format_exc()}')

    def _restart_bridge_login(self, bridge: BridgeState):
        """Cancel existing login task and start a new one."""
        if bridge.login_task and not bridge.login_task.done():
            bridge.login_task.cancel()
        bridge.login_task = asyncio.create_task(self._periodic_bridge_login(bridge))

    async def _periodic_bridge_check(self, bridge: BridgeState):
        """Periodically check a bridge's login status."""
        try:
            while self._running and not bridge.logged_in:
                await asyncio.sleep(5)

            check_interval = 300  # 5 minutes
            response_timeout = 30
            await self.logger.debug(f'[{bridge.user_id}] Bridge status check started (interval: {check_interval}s)')

            while self._running:
                for _ in range(check_interval):
                    if not self._running:
                        return
                    await asyncio.sleep(1)

                if not bridge.logged_in or not bridge.dm_room_id:
                    continue

                try:
                    bridge.check_responded = False
                    await self.client.room_send(
                        room_id=bridge.dm_room_id,
                        message_type='m.room.message',
                        content={'msgtype': 'm.text', 'body': bridge.check_command},
                    )
                    await self.logger.debug(f'[{bridge.user_id}] Bridge status check: sent "{bridge.check_command}"')

                    for _ in range(response_timeout):
                        if bridge.check_responded or not self._running:
                            break
                        await asyncio.sleep(1)

                    if bridge.check_responded:
                        await self.logger.debug(f'[{bridge.user_id}] Bridge status check: OK')
                    else:
                        await self.logger.info(
                            f'[{bridge.user_id}] Bridge status check: 无响应, 可能已掉线, 尝试重新登录...'
                        )
                        bridge.logged_in = False
                        self._restart_bridge_login(bridge)
                except Exception:
                    await self.logger.error(f'[{bridge.user_id}] Bridge status check error: {traceback.format_exc()}')
        except asyncio.CancelledError:
            pass
        except Exception:
            await self.logger.error(f'[{bridge.user_id}] Bridge status check fatal error: {traceback.format_exc()}')

    async def _handle_relogin_command(self, room_id: str):
        """Handle !relogin command: logout then re-login all bridges."""
        if not self._bridges:
            await self.client.room_send(
                room_id=room_id,
                message_type='m.room.message',
                content={'msgtype': 'm.text', 'body': '没有配置任何桥。'},
            )
            return

        lines = ['开始重新登录所有桥...']
        for bridge in self._bridges:
            if not bridge.login_command or not bridge.dm_room_id:
                lines.append(f'[{bridge.user_id}] 跳过（未配置登录命令或无DM房间）')
                continue

                # Use configured logout command, fallback to deriving from login command
                logout_cmd = bridge.logout_command or bridge.login_command.replace('login', 'logout')
            lines.append(f'[{bridge.user_id}] 发送 "{logout_cmd}"...')

            # Cancel existing tasks
            if bridge.login_task and not bridge.login_task.done():
                bridge.login_task.cancel()
            if bridge.check_task and not bridge.check_task.done():
                bridge.check_task.cancel()

            # Send logout
            try:
                await self.client.room_send(
                    room_id=bridge.dm_room_id,
                    message_type='m.room.message',
                    content={'msgtype': 'm.text', 'body': logout_cmd},
                )
            except Exception as e:
                lines.append(f'[{bridge.user_id}] logout 发送失败: {e}')

            await asyncio.sleep(2)

            # Reset state and restart login
            bridge.logged_in = False
            self._restart_bridge_login(bridge)
            lines.append(f'[{bridge.user_id}] 已触发重新登录')

        await self.client.room_send(
            room_id=room_id,
            message_type='m.room.message',
            content={'msgtype': 'm.text', 'body': '\n'.join(lines)},
        )

    async def _handle_status_command(self, room_id: str):
        """Handle !status command: show bridge states."""
        if not self._bridges:
            await self.client.room_send(
                room_id=room_id,
                message_type='m.room.message',
                content={'msgtype': 'm.text', 'body': '没有配置任何桥。'},
            )
            return

        lines = ['桥状态:']
        for bridge in self._bridges:
            status = '已登录 ✓' if bridge.logged_in else '未登录 ✗'
            dm = bridge.dm_room_id or '无'
            lines.append(f'• {bridge.user_id}: {status} (DM: {dm})')
        await self.client.room_send(
            room_id=room_id,
            message_type='m.room.message',
            content={'msgtype': 'm.text', 'body': '\n'.join(lines)},
        )

    async def kill(self) -> bool:
        self._running = False
        bridge_tasks = []
        for bridge in self._bridges:
            if bridge.login_task and not bridge.login_task.done():
                bridge.login_task.cancel()
                bridge_tasks.append(bridge.login_task)
            if bridge.check_task and not bridge.check_task.done():
                bridge.check_task.cancel()
                bridge_tasks.append(bridge.check_task)
        if bridge_tasks:
            await asyncio.gather(*bridge_tasks, return_exceptions=True)
        if self.client:
            await self.client.close()
        await self.logger.debug('Matrix adapter stopped')
        return True

    async def unregister_listener(
        self,
        event_type: typing.Type[platform_events.Event],
        callback: typing.Callable[
            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
        ],
    ):
        if event_type in self.listeners:
            del self.listeners[event_type]
