"""Channel manager for routing gateway outbound messages."""

from __future__ import annotations

import asyncio
from contextlib import suppress

from beaver.foundation.events import MessageBus, OutboundMessage

from .base import ChannelAdapter


class ChannelManager:
    """Start/stop channel adapters and dispatch outbound messages to them."""

    def __init__(self, bus: MessageBus) -> None:
        self.bus = bus
        self.channels: dict[str, ChannelAdapter] = {}
        self.undeliverable: list[OutboundMessage] = []
        self.started = False

    def register(self, channel: ChannelAdapter) -> None:
        if self.started:
            raise RuntimeError("Cannot register channels after ChannelManager.start()")
        if channel.name in self.channels:
            raise ValueError(f"Channel already registered: {channel.name}")
        if channel.bus is not self.bus:
            raise ValueError("Channel must share the same MessageBus as ChannelManager")
        self.channels[channel.name] = channel

    async def start(self) -> None:
        started: list[ChannelAdapter] = []
        try:
            for channel in self.channels.values():
                await channel.start()
                started.append(channel)
        except BaseException:
            for channel in reversed(started):
                with suppress(BaseException):
                    await channel.stop()
            raise
        else:
            self.started = True

    async def stop(self) -> None:
        errors: list[BaseException] = []
        for channel in reversed(tuple(self.channels.values())):
            try:
                await channel.stop()
            except Exception as exc:  # pragma: no cover - defensive cleanup path
                errors.append(exc)
        self.started = False
        if errors:
            raise RuntimeError(f"Failed to stop {len(errors)} channel(s)") from errors[0]

    async def dispatch_outbound(self, stop_event: asyncio.Event) -> None:
        """Route bus outbound messages until stopped and the queue is drained."""

        while True:
            if stop_event.is_set() and self.bus.outbound_size == 0:
                break

            try:
                message = await asyncio.wait_for(self.bus.consume_outbound(), timeout=0.25)
            except asyncio.TimeoutError:
                continue

            channel = self.channels.get(message.channel)
            if channel is None:
                self.undeliverable.append(message)
                continue

            try:
                await channel.send(message)
            except Exception:  # pragma: no cover - defensive channel isolation
                self.undeliverable.append(message)