ForcePilot/backend/package/yuxi/channels/adapters/irc/adapter.py

from __future__ import annotations

import asyncio
import os
import time
from collections.abc import AsyncIterator
from datetime import datetime
from typing import Any, ClassVar

from dataclasses import dataclass, field

from yuxi.channels.base import BaseChannelAdapter
from yuxi.channels.capabilities import ChannelCapabilities
from yuxi.channels.exceptions import (
    ChannelAuthenticationError,
    ChannelException,
)
from yuxi.channels.meta import ChannelMeta
from yuxi.channels.models import (
    ChannelMessage,
    ChannelResponse,
    ChannelStatus,
    ChannelType,
    DeliveryResult,
    HealthStatus,
)
from yuxi.channels.registry import register_builtin_adapter
from yuxi.utils.datetime_utils import utc_now_naive
from yuxi.utils.logging_config import logger

from ._isupport import ISupport
from .auth import (
    get_server_password,
    nick_recover,
    nickserv_identify,
    nickserv_register,
    resolve_password,
    sasl_authenticate,
    sasl_external_authenticate,
    sasl_scram_sha256_authenticate,
    send_pass,
)
from .channel_runtime import ChannelRuntime
from .connection import IRCConnection
from .formatter import convert_markdown_tables, format_outbound
from .monitor import IRCMonitor
from .normalizer import normalize_inbound as _normalizer_inbound
from .normalizer import resolve_chat_id
from .probe import ping_probe
from .protocol import extract_nick, parse_irc_line
from .sanitize import sanitize_outbound_text
from .security import (
    IRCSecurityConfig,
    collect_security_warnings,
)
from .send import send_media_text, send_privmsg
from .send_cache import SentMessageCache
from .session import resolve_channel_user_id, resolve_thread_id

_JOIN_DELAY = 0.5
_DEFAULT_CONNECT_TIMEOUT = 30.0
_MAX_NICK_RETRIES = 3
_TOPIC_TIMEOUT = 5.0


@dataclass
class IrcStatus:
    host: str = ""
    port: int = 6697
    tls: bool = True
    nick: str = ""
    connected: bool = False
    configured: bool = False
    probe_ok: bool | None = None
    last_inbound_at: float | None = None
    last_outbound_at: float | None = None
    last_error: str | None = None
    joined_channels: list[str] = field(default_factory=list)
    account_id: str = "default"


def _env_or(key: str, default: Any, config: dict) -> Any:
    env_map: dict[str, tuple[str, type]] = {
        "server": ("IRC_HOST", str),
        "port": ("IRC_PORT", int),
        "use_tls": ("IRC_TLS", bool),
        "nick": ("IRC_NICK", str),
        "username": ("IRC_USERNAME", str),
        "realname": ("IRC_REALNAME", str),
        "password": ("IRC_PASSWORD", str),
        "sasl_username": ("IRC_SASL_USERNAME", str),
        "sasl_password": ("IRC_SASL_PASSWORD", str),
        "nickserv_service": ("IRC_NICKSERV_SERVICE", str),
        "nickserv_register_email": ("IRC_NICKSERV_REGISTER_EMAIL", str),
        "nickserv_password": ("IRC_NICKSERV_PASSWORD", str),
        "nickserv_password_file": ("IRC_NICKSERV_PASSWORD_FILE", str),
        "server_password": ("IRC_SERVER_PASSWORD", str),
        "server_password_file": ("IRC_SERVER_PASSWORD_FILE", str),
        "dm_policy": ("IRC_DM_POLICY", str),
        "group_policy": ("IRC_GROUP_POLICY", str),
        "channels": ("IRC_CHANNELS", str),
    }

    env_entry = env_map.get(key)
    if env_entry is None:
        return config.get(key, default)

    env_var, py_type = env_entry
    env_val = os.environ.get(env_var, "")
    if env_val:
        if py_type is bool:
            return env_val.lower() in ("1", "true", "yes")
        if py_type is int:
            try:
                return int(env_val)
            except ValueError:
                return config.get(key, default)
        return env_val

    return config.get(key, default)


@register_builtin_adapter
class IRCAdapter(BaseChannelAdapter):
    channel_id: ClassVar[str] = "irc"
    channel_type: ClassVar[ChannelType] = ChannelType.IRC
    webhook_path: ClassVar[str | None] = None

    text_chunk_limit: ClassVar[int] = 350
    supports_markdown: ClassVar[bool] = True
    supports_media: ClassVar[bool] = True
    supports_streaming: ClassVar[bool] = True
    streaming_modes: ClassVar[list[str]] = ["off", "block"]
    max_media_size_mb: ClassVar[int] = 100

    capabilities = ChannelCapabilities(
        chat_types=["direct", "group"],
        supports_markdown=True,
        supports_streaming=True,
        streaming_modes=["off", "block"],
        text_chunk_limit=350,
        max_media_size_mb=100,
    )
    meta = ChannelMeta(
        id="irc",
        label="IRC",
        selection_label="IRC (Server + Nick)",
        blurb="IRC 渠道适配器，支持 SASL/NickServ 认证、多账户、频道管理",
        order=80,
        docs_path="docs/channels/irc",
        docs_label="IRC 文档",
        system_image="number",
        markdown_capable=True,
        detail_label="IRC",
        aliases=["internet-relay-chat"],
        quickstart_allow_from=["*"],
    )

    MAX_CHANNELS: int = 20

    def __init__(self, config: dict[str, Any] | None = None):
        super().__init__(config)
        self._status = ChannelStatus.DISCONNECTED

        self._server = _env_or("server", "irc.libera.chat", self.config)
        self._port = _env_or("port", 6697, self.config)
        self._use_tls = _env_or("use_tls", True, self.config)
        self._connect_timeout = float(self.config.get("connect_timeout", _DEFAULT_CONNECT_TIMEOUT))
        self._nick = _env_or("nick", "ForcePilotBot", self.config)
        self._username = _env_or("username", self._nick, self.config)
        self._realname = _env_or("realname", "ForcePilot IRC Bot", self.config)
        self._password = _env_or("password", "", self.config)
        self._sasl_username = _env_or("sasl_username", "", self.config)
        self._sasl_password = _env_or("sasl_password", "", self.config)
        self._use_sasl = self.config.get("use_sasl", True) and bool(self._sasl_username)
        self._sasl_mechanism = self.config.get("sasl_mechanism", "PLAIN")

        self._server_password = get_server_password(self.config)

        self._nickserv_service = _env_or("nickserv_service", "NickServ", self.config)
        self._nickserv_password = (
            resolve_password(
                password=_env_or("nickserv_password", "", self.config),
                password_file=_env_or("nickserv_password_file", "", self.config),
                env_var="IRC_NICKSERV_PASSWORD",
            )
            or self._password
        )

        self._nickserv_register = self.config.get("nickserv_register", False)
        self._nickserv_register_email = _env_or("nickserv_register_email", "", self.config)
        self._nickserv_enabled = bool(self._nickserv_password)

        self._auto_join = self._resolve_auto_join()
        self._nick_recovery = self.config.get("nick_recovery", True)

        self.dm_policy = _env_or("dm_policy", "pairing", self.config)
        self.group_policy = _env_or("group_policy", "allowlist", self.config)
        self.allow_from = self.config.get("allowFrom", [])
        self.group_allow_from = self.config.get("groupAllowFrom", [])
        self.groups = self.config.get("groups", {})
        self._reply_enabled = self.config.get("reply_enabled", False)
        self._probe_timeout = float(self.config.get("probe_timeout", 8.0))
        self._markdown_table_mode = self.config.get("markdown", {}).get("tableMode", "off")
        self._chunker_mode = self.config.get("chunker_mode", "length")
        self._block_streaming_coalesce = self.config.get(
            "blockStreamingCoalesce",
        )
        if self._block_streaming_coalesce is None:
            self._block_streaming_coalesce = {}
        self._disable_block_streaming = self.config.get("disable_block_streaming", False)
        self._streaming_buffer: dict[str, list[str]] = {}
        self._streaming_timer: dict[str, asyncio.Task | None] = {}

        self.security_config = IRCSecurityConfig(
            dm_policy=self.dm_policy,
            group_policy=self.group_policy,
            allow_from=list(self.allow_from) if isinstance(self.allow_from, list) else [],
            group_allow_from=list(self.group_allow_from) if isinstance(self.group_allow_from, list) else [],
            groups=self.groups if isinstance(self.groups, dict) else {},
            dangerously_allow_name_matching=self.config.get("dangerouslyAllowNameMatching", False),
            group_allow_from_fallback_to_allow_from=self.config.get("groupAllowFromFallbackToAllowFrom", False),
        )

        self._connection = IRCConnection(
            {
                "server": self._server,
                "port": self._port,
                "use_tls": self._use_tls,
                "connect_timeout": self._connect_timeout,
            }
        )
        self._isupport = ISupport()
        self._channel_runtime = ChannelRuntime()
        self._monitor: IRCMonitor | None = None
        self._ready_event = asyncio.Event()
        self._ready_at: datetime | None = None

        self._last_inbound_at: float | None = None
        self._last_outbound_at: float | None = None
        self._last_error: str | None = None
        self._connected = False
        self._disconnecting = False
        self._sent_message_cache = SentMessageCache()
        self._topic_futures: dict[str, asyncio.Future] = {}
        self._account_id = config.get("_account_id", "default")
        self._extra_caps: list[str] = []
        self._delivery_tracker: Any = None

    def _resolve_auto_join(self) -> list:
        channels_env = _env_or("channels", "", self.config)
        if isinstance(channels_env, str) and channels_env:
            return [ch.strip() for ch in channels_env.split(",") if ch.strip()]
        return self.config.get("auto_join_channels", [])

    @property
    def nick(self) -> str:
        return self._nick

    def mark_pong(self) -> None:
        self._connection.mark_pong()

    def _check_abort(self) -> None:
        if self._disconnecting:
            raise ChannelException("IRC adapter is disconnecting", retryable=False)

    async def _do_sasl_auth(self, deadline: float) -> bool | None:
        if self._sasl_mechanism == "EXTERNAL":
            await sasl_external_authenticate(
                self._connection.send_line,
                self._connection.read_line,
                timeout=max(1.0, deadline - time.monotonic()),
            )
        elif self._sasl_mechanism == "SCRAM-SHA-256":
            await sasl_scram_sha256_authenticate(
                self._connection.send_line,
                self._connection.read_line,
                self._sasl_username,
                self._sasl_password,
                timeout=max(1.0, deadline - time.monotonic()),
            )
        else:
            await sasl_authenticate(
                self._connection.send_line,
                self._connection.read_line,
                self._sasl_username,
                self._sasl_password,
                timeout=max(1.0, deadline - time.monotonic()),
            )
        return True

    def send_line(self, line: str) -> None:
        self._connection.send_line(line)

    @property
    def isupport(self) -> ISupport:
        return self._isupport

    async def read_line(self) -> str | None:
        return await self._connection.read_line()

    async def connect(self) -> None:
        self._status = ChannelStatus.CONNECTING
        self._ready_event.clear()

        try:
            await self._connection.connect()

            if self._server_password:
                await send_pass(self._connection.send_line, self._server_password)

            self._send_cap_and_nickuser()

            registered = False
            sasl_done = False
            nick_retries = 0
            deadline = time.monotonic() + self._connect_timeout

            while time.monotonic() < deadline:
                line = await self._connection.read_line()
                if line is None:
                    continue
                logger.debug(f"IRC <: {line}")

                _prefix, command, _args = parse_irc_line(line)

                if command == "005":
                    self._isupport.feed_line(line)
                    continue

                if command == "CAP" and "ACK" in line and self._use_sasl and not sasl_done:
                    await self._do_sasl_auth(deadline)
                    sasl_done = True
                    self._connection.send_line("CAP END")
                    await self._connection.drain()
                    continue

                if command in ("376", "422"):
                    logger.info("IRC registration complete")
                    registered = True
                    break

                if command == "433":
                    if nick_retries < _MAX_NICK_RETRIES:
                        nick_retries += 1
                        fallback_nick = f"{self._nick}_{nick_retries}"
                        logger.warning(f"IRC nick {self._nick} in use, trying {fallback_nick}")
                        self._nick = fallback_nick
                        self._connection.send_line(f"NICK {fallback_nick}")
                        await self._connection.drain()
                        continue
                    logger.warning(f"IRC nick {self._nick} in use after {_MAX_NICK_RETRIES} retries")
                    registered = True
                    break

                if command == "436":
                    if nick_retries < _MAX_NICK_RETRIES:
                        nick_retries += 1
                        fallback_nick = f"{self._nick}_{nick_retries}"
                        logger.warning(f"IRC nick collision for {self._nick}, trying {fallback_nick}")
                        self._nick = fallback_nick
                        self._connection.send_line(f"NICK {fallback_nick}")
                        await self._connection.drain()
                        continue
                    raise ChannelAuthenticationError(
                        "IRC nick collision after retries",
                        retryable=False,
                    )

                if command == "432":
                    raise ChannelAuthenticationError(
                        f"IRC erroneous nickname: {self._nick}",
                        retryable=False,
                    )

                if command == "464":
                    raise ChannelAuthenticationError(
                        "IRC password required or incorrect",
                        retryable=False,
                    )

                if command == "465":
                    raise ChannelAuthenticationError(
                        "IRC you are banned from this server",
                        retryable=False,
                    )

                if command == "ERROR":
                    args_str = " ".join(_args)
                    raise ChannelException(f"IRC server error: {args_str}")

            if not registered:
                raise ChannelException("IRC registration timed out", retryable=True)

            if not sasl_done and self._use_sasl and self._sasl_username:
                await self._do_sasl_auth(time.monotonic() + 30.0)
            elif self._nickserv_password:
                await nickserv_identify(
                    self._connection.send_line,
                    self._nickserv_password,
                    service=self._nickserv_service,
                )

            if self._nickserv_register and self._nickserv_password:
                await nickserv_register(
                    self._connection.send_line,
                    self._nickserv_password,
                    email=self._nickserv_register_email,
                    service=self._nickserv_service,
                )

            if self._nick_recovery and self._use_sasl:
                await nick_recover(
                    self._connection.send_line,
                    self._nick,
                    self._sasl_password or self._nickserv_password,
                    service=self._nickserv_service,
                )
                await self._connection.drain()

            await self._join_channels()

            self._connection.on_reconnect(self._on_reconnect_handler)

            self._monitor = IRCMonitor(self.config, self)
            self._monitor.on_message(self._handle_message)
            await self._monitor.start()

            await self._connection.start_keepalive()

            self._ready_event.set()
            self._ready_at = utc_now_naive()
            self._status = ChannelStatus.CONNECTED
            self._connected = True
            logger.info(
                f"IRC adapter connected: {self._nick} @ {self._server}, "
                f"joined {len(self._channel_runtime.joined_channels)} "
                f"channels"
            )

            warnings = collect_security_warnings(
                self.security_config,
                use_tls=self._use_tls,
                nickserv_enabled=self._nickserv_enabled,
            )
            for w in warnings:
                logger.warning(f"IRC security warning: {w}")

        except ChannelAuthenticationError:
            self._status = ChannelStatus.ERROR
            self._last_error = str(ChannelAuthenticationError.__name__)
            raise
        except Exception as e:
            self._status = ChannelStatus.ERROR
            self._last_error = str(e)
            raise ChannelException(f"IRC connection failed: {e}", retryable=True)

    async def disconnect(self) -> None:
        self._disconnecting = True
        self._status = ChannelStatus.DISCONNECTED
        self._connected = False
        self._ready_event.clear()

        if self._monitor:
            await self._monitor.stop()
            self._monitor = None

        try:
            self._connection.send_line("QUIT :ForcePilot shutting down")
            await self._connection.drain()
        except Exception:
            pass

        await self._connection.disconnect()
        self._ready_at = None
        logger.info("IRC adapter disconnected")

    async def send(self, response: ChannelResponse) -> DeliveryResult:
        self._check_abort()
        if self._status != ChannelStatus.CONNECTED:
            return DeliveryResult(success=False, error="IRC not connected")

        try:
            chat_id = response.identity.channel_chat_id or self._nick
            text = sanitize_outbound_text(response.content)
            text = convert_markdown_tables(text, self._markdown_table_mode)

            reply_to_id = ""
            if self._reply_enabled and response.reply_to_message_id:
                reply_to_id = response.reply_to_message_id

            await send_privmsg(
                self._connection.send_line,
                chat_id,
                text,
                nick=self._nick,
                username=self._username,
                server=self._server,
                reply_to_id=reply_to_id,
                chunker_mode=self._chunker_mode,
            )
            await self._connection.drain()
            self._last_outbound_at = time.monotonic()
            msg_id = response.identity.channel_message_id or ""
            if msg_id:
                self._sent_message_cache.put(msg_id, chat_id, text)
            return DeliveryResult(success=True)

        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def send_media(self, chat_id: str, media_type: str, data: Any) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED:
            return DeliveryResult(success=False, error="IRC not connected")

        try:
            if media_type == "url" or (isinstance(data, str) and data.startswith(("http://", "https://"))):
                url = data if isinstance(data, str) else str(data)
                text = f"Attachment: {url}"
                await send_media_text(
                    self._connection.send_line,
                    chat_id,
                    text,
                    nick=self._nick,
                    username=self._username,
                    server=self._server,
                )
                await self._connection.drain()
                self._last_outbound_at = time.monotonic()
                return DeliveryResult(success=True)

            return DeliveryResult(
                success=False,
                error="IRC only supports URL attachments",
            )
        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def receive(self) -> AsyncIterator[ChannelMessage]:
        if False:
            yield

    def normalize_inbound(self, raw: dict[str, Any]) -> ChannelMessage:
        return _normalizer_inbound(raw, self.channel_id, self.channel_type, self._nick)

    def format_outbound(self, response: ChannelResponse) -> dict[str, Any]:
        return format_outbound(response)

    async def health_check(self) -> HealthStatus:
        if self._status != ChannelStatus.CONNECTED:
            return HealthStatus(status="degraded", last_error="IRC not connected")

        return await ping_probe(
            self._connection.send_line,
            self._connection.read_line,
            self._server,
            timeout=self._probe_timeout,
            metadata={
                "server": self._server,
                "nick": self._nick,
                "joined_channels": list(self._channel_runtime.joined_channels),
                "tls": self._use_tls,
                "dm_policy": self.dm_policy,
                "group_policy": self.group_policy,
            },
        )

    async def send_stream_chunk(
        self,
        chat_id: str,
        message_id: str,
        chunk_text: str,
        finished: bool = False,
    ) -> DeliveryResult:
        self._check_abort()
        if self._status != ChannelStatus.CONNECTED:
            return DeliveryResult(success=False, error="IRC not connected")

        if self._disable_block_streaming:
            text = sanitize_outbound_text(chunk_text)
            text = convert_markdown_tables(text, self._markdown_table_mode)
            await send_privmsg(
                self._connection.send_line,
                chat_id,
                text,
                nick=self._nick,
                username=self._username,
                server=self._server,
                chunker_mode=self._chunker_mode,
            )
            await self._connection.drain()
            self._last_outbound_at = time.monotonic()
            return DeliveryResult(success=True)

        coalesce_config = self._block_streaming_coalesce
        coalesce_delay = coalesce_config.get("delay_ms", 0) / 1000.0 if isinstance(coalesce_config, dict) else 0

        try:
            text = sanitize_outbound_text(chunk_text)
            text = convert_markdown_tables(text, self._markdown_table_mode)

            if coalesce_delay > 0 and not finished:
                key = f"{chat_id}:{message_id}"
                self._streaming_buffer.setdefault(key, []).append(text)
                if self._streaming_timer.get(key):
                    self._streaming_timer[key].cancel()  # type: ignore[union-attr]
                self._streaming_timer[key] = asyncio.create_task(self._flush_coalesced(key, chat_id, coalesce_delay))
                return DeliveryResult(success=True)

            if coalesce_delay > 0 and finished:
                key = f"{chat_id}:{message_id}"
                buffered = self._streaming_buffer.pop(key, [])
                timer = self._streaming_timer.pop(key, None)
                if timer:
                    timer.cancel()
                text = "".join(buffered) + text if buffered else text

            if finished:
                final_text = text
            else:
                ellipsis = "\u2026"
                ellipsis_bytes = len(ellipsis.encode("utf-8"))
                chunk_bytes = text.encode("utf-8")
                if len(chunk_bytes) < 30:
                    return DeliveryResult(success=True)
                if len(chunk_bytes) + ellipsis_bytes > self.text_chunk_limit:
                    cut_bytes = self.text_chunk_limit - ellipsis_bytes
                    final_text = _truncate_utf8(chunk_bytes, cut_bytes) + ellipsis
                else:
                    final_text = text + ellipsis

            await send_privmsg(
                self._connection.send_line,
                chat_id,
                final_text,
                nick=self._nick,
                username=self._username,
                server=self._server,
                chunker_mode=self._chunker_mode,
            )
            await self._connection.drain()
            self._last_outbound_at = time.monotonic()
            if finished and message_id:
                self._sent_message_cache.put(message_id, chat_id, final_text)
            return DeliveryResult(success=True)
        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def _flush_coalesced(self, key: str, chat_id: str, delay: float) -> None:
        await asyncio.sleep(delay)
        buffered = self._streaming_buffer.pop(key, None)
        self._streaming_timer.pop(key, None)
        if not buffered:
            return
        combined = "".join(buffered)
        try:
            await send_privmsg(
                self._connection.send_line,
                chat_id,
                combined,
                nick=self._nick,
                username=self._username,
                server=self._server,
                chunker_mode=self._chunker_mode,
            )
            await self._connection.drain()
            self._last_outbound_at = time.monotonic()
        except Exception as e:
            logger.warning(f"IRC coalesce flush failed: {e}")

    async def get_user_info(self, channel_user_id: str) -> dict[str, Any]:
        return {"nick": resolve_channel_user_id(channel_user_id)}

    async def get_topic(self, channel: str) -> str | None:
        if self._status != ChannelStatus.CONNECTED:
            return None
        try:
            loop = asyncio.get_running_loop()
            fut: asyncio.Future = loop.create_future()
            self._topic_futures[channel.lower()] = fut
            self._connection.send_line(f"TOPIC {channel}")
            await self._connection.drain()
            result = await asyncio.wait_for(fut, timeout=_TOPIC_TIMEOUT)
            return result if result else None
        except TimeoutError:
            logger.warning(f"IRC get_topic timed out for {channel}")
            return None
        except Exception as e:
            logger.warning(f"IRC get_topic failed for {channel}: {e}")
            return None
        finally:
            self._topic_futures.pop(channel.lower(), None)

    async def set_topic(self, channel: str, topic: str) -> bool:
        if self._status != ChannelStatus.CONNECTED:
            return False
        try:
            self._connection.send_line(f"TOPIC {channel} :{topic}")
            await self._connection.drain()
            logger.info(f"IRC set_topic for {channel}: {topic[:50]}...")
            return True
        except Exception as e:
            logger.warning(f"IRC set_topic failed for {channel}: {e}")
            return False

    def _resolve_chat_id(self, target: str, sender_nick: str) -> str:
        return resolve_chat_id(target, sender_nick)

    def _resolve_channel_user_id(self, nick: str) -> str:
        return resolve_channel_user_id(nick)

    def _resolve_thread_id(self, agent_id: str, chat_id: str) -> str:
        return resolve_thread_id(agent_id, chat_id)

    def _handle_channel_event(self, command: str, prefix: str | None, args: list[str]) -> None:
        if command == "JOIN":
            channel = args[0] if args else ""
            nick = extract_nick(prefix)
            self._channel_runtime.handle_join(channel, nick)

        elif command == "PART":
            channel = args[0] if args else ""
            nick = extract_nick(prefix)
            self._channel_runtime.handle_part(channel, nick)

        elif command == "KICK":
            channel = args[0] if len(args) >= 1 else ""
            kicked_nick = args[1] if len(args) >= 2 else ""
            self._channel_runtime.handle_kick(channel, kicked_nick)

        elif command == "QUIT":
            nick = extract_nick(prefix)
            reason = args[0] if args else ""
            self._channel_runtime.handle_quit(nick)
            logger.debug(f"IRC QUIT: {nick} ({reason})")

        elif command == "NICK":
            old_nick = extract_nick(prefix)
            new_nick = args[0] if args else ""
            self._channel_runtime.handle_nick_change(old_nick, new_nick)

        elif command == "MODE":
            channel = args[0] if args else ""
            modes = " ".join(args[1:]) if len(args) > 1 else ""
            self._channel_runtime.handle_mode(channel, modes)
            logger.debug(f"IRC MODE {channel}: {modes}")

        elif command == "TOPIC":
            channel = args[0] if args else ""
            topic = args[1] if len(args) >= 2 else ""
            logger.debug(f"IRC TOPIC {channel}: {topic}")

        elif command == "332":
            if len(args) >= 3:
                channel = args[1]
                topic = args[2]
                logger.debug(f"IRC TOPIC for {channel}: {topic}")
                topic_fut = self._topic_futures.get(channel.lower())
                if topic_fut and not topic_fut.done():
                    topic_fut.set_result(topic)

        elif command == "333":
            if len(args) >= 4:
                channel = args[1]
                who = args[2]
                when = args[3]
                logger.debug(f"IRC TOPIC set by {who} at {when} on {channel}")
                topic_fut = self._topic_futures.get(channel.lower())
                if topic_fut and not topic_fut.done():
                    topic_fut.set_result("")

        elif command == "353":
            if len(args) >= 4:
                channel = args[2]
                names_str = args[3]
                self._channel_runtime.handle_names(channel, names_str)

        elif command == "366":
            channel = args[1] if len(args) >= 2 else ""
            if channel:
                logger.info(f"IRC NAMES complete for {channel}")

    def _send_cap_and_nickuser(self) -> None:
        self._connection.send_line("CAP LS 302")
        caps = ["server-time"]
        if self._use_sasl:
            caps.append("sasl")
        caps.extend(self._extra_caps)
        self._connection.send_line(f"CAP REQ :{' '.join(caps)}")
        self._connection.send_line(f"NICK {self._nick}")
        self._connection.send_line(f"USER {self._username} 0 * :{self._realname}")
        self._connection.drain()

    def status(self) -> IrcStatus:
        return IrcStatus(
            host=self._server,
            port=self._port,
            tls=self._use_tls,
            nick=self._nick,
            connected=self._connected,
            configured=bool(self._server and self._nick),
            last_inbound_at=self._last_inbound_at,
            last_outbound_at=self._last_outbound_at,
            last_error=self._last_error,
            joined_channels=list(self._channel_runtime.joined_channels),
            account_id=self._account_id,
        )

    async def join_channel(self, channel: str) -> bool:
        if self._status != ChannelStatus.CONNECTED:
            return False
        if not channel.startswith("#") and not channel.startswith("&"):
            channel = f"#{channel}"
        if channel in self._channel_runtime.joined_channels:
            return True
        self._connection.send_line(f"JOIN {channel}")
        self._channel_runtime.add_channel(channel)
        await self._connection.drain()
        logger.info(f"IRC joined channel: {channel}")
        return True

    async def part_channel(self, channel: str, reason: str = "") -> bool:
        if self._status != ChannelStatus.CONNECTED:
            return False
        if not channel.startswith("#") and not channel.startswith("&"):
            channel = f"#{channel}"
        if channel not in self._channel_runtime.joined_channels:
            return False
        cmd = f"PART {channel}"
        if reason:
            cmd += f" :{reason}"
        self._connection.send_line(cmd)
        self._channel_runtime.remove_channel(channel)
        await self._connection.drain()
        logger.info(f"IRC parted channel: {channel}")
        return True

    def set_extra_caps(self, caps: list[str]) -> None:
        self._extra_caps = list(caps)

    def resolve_topic_future(self, channel: str, topic: str) -> None:
        fut = self._topic_futures.get(channel.lower())
        if fut and not fut.done():
            fut.set_result(topic)

    async def _join_channels(self) -> None:
        for channel_config in self._auto_join:
            channel_name = channel_config if isinstance(channel_config, str) else channel_config.get("name", "")
            if channel_name and (channel_name.startswith("#") or channel_name.startswith("&")):
                self._connection.send_line(f"JOIN {channel_name}")
                self._channel_runtime.add_channel(channel_name)
                await asyncio.sleep(_JOIN_DELAY)
        await self._connection.drain()
        logger.info(f"IRC joined channels: {self._channel_runtime.joined_channels}")

    async def _on_reconnect_handler(self) -> None:
        caps_to_request = ["server-time"]
        if self._use_sasl:
            caps_to_request.append("sasl")
        caps_to_request.extend(self._extra_caps)
        self._connection.send_line("CAP LS 302")
        self._connection.send_line(f"CAP REQ :{' '.join(caps_to_request)}")
        self._connection.send_line(f"NICK {self._nick}")
        self._connection.send_line(f"USER {self._username} 0 * :{self._realname}")
        await self._connection.drain()

        deadline = time.monotonic() + self._connect_timeout
        registered = False
        sasl_done = False
        while time.monotonic() < deadline:
            line = await self._connection.read_line()
            if line is None:
                continue
            logger.debug(f"IRC <: {line}")

            _prefix, command, _args = parse_irc_line(line)

            if command == "CAP" and "ACK" in line and self._use_sasl and not sasl_done:
                await self._do_sasl_auth(deadline)
                sasl_done = True
                self._connection.send_line("CAP END")
                await self._connection.drain()
                continue

            if command in ("376", "422"):
                registered = True
                break
            if command in ("433", "436"):
                registered = True
                break

        if not registered:
            logger.error("IRC re-registration timed out after reconnect")
            return

        if not sasl_done and self._use_sasl and self._sasl_username:
            await self._do_sasl_auth(time.monotonic() + 30.0)
        elif self._nickserv_password:
            await nickserv_identify(
                self._connection.send_line,
                self._nickserv_password,
                service=self._nickserv_service,
            )

        if self._nick_recovery and self._use_sasl:
            await nick_recover(
                self._connection.send_line,
                self._nick,
                self._sasl_password or self._nickserv_password,
                service=self._nickserv_service,
            )
            await self._connection.drain()

        await self._join_channels()
        if self._monitor:
            await self._monitor.start()
        await self._connection.start_keepalive()

        self._ready_event.set()
        self._ready_at = utc_now_naive()
        self._status = ChannelStatus.CONNECTED
        logger.info("IRC adapter reconnected and channels rejoined")


def _truncate_utf8(data: bytes, max_bytes: int) -> str:
    if len(data) <= max_bytes:
        return data.decode("utf-8")
    cut = max_bytes
    while cut > 0 and (data[cut - 1] & 0xC0) == 0x80:
        cut -= 1
    if cut == 0:
        cut = max(1, max_bytes)
    return data[:cut].decode("utf-8")