"""In-memory channel adapter for tests and local gateway embedding."""

from __future__ import annotations

from typing import Any

from beaver.foundation.events import InboundMessage, MessageBus, OutboundMessage


class MemoryChannelAdapter:
    """A local channel that stores outbound messages in memory."""

    def __init__(self, bus: MessageBus, *, name: str = "memory") -> None:
        self.name = name
        self.bus = bus
        self.started = False
        self.sent_messages: list[OutboundMessage] = []

    async def start(self) -> None:
        self.started = True

    async def stop(self) -> None:
        self.started = False

    async def send(self, message: OutboundMessage) -> None:
        self.sent_messages.append(message)

    async def publish_text(
        self,
        content: str,
        *,
        session_id: str | None = None,
        user_id: str | None = None,
        title: str | None = None,
        execution_context: str | None = None,
        model: str | None = None,
        provider_name: str | None = None,
        embedding_model: str | None = None,
        metadata: dict[str, Any] | None = None,
    ) -> InboundMessage:
        """Publish a text message from this channel into the shared bus."""

        message = InboundMessage(
            channel=self.name,
            content=content,
            session_id=session_id,
            user_id=user_id,
            title=title,
            execution_context=execution_context,
            model=model,
            provider_name=provider_name,
            embedding_model=embedding_model,
            metadata=metadata or {},
        )
        await self.bus.publish_inbound(message)
        return message