from __future__ import annotations

from typing import TYPE_CHECKING, AsyncIterator

from sdk.agent_session import build_thread_key
from sdk.interface import Attachment, MessageChunk, MessageResponse, PlatformClient, User, UserSettings
from sdk.prototype_state import PrototypeStateStore

if TYPE_CHECKING:
    from sdk.agent_session import AgentSessionClient


class RealPlatformClient(PlatformClient):
    def __init__(
        self,
        agent_sessions: AgentSessionClient,
        prototype_state: PrototypeStateStore,
        platform: str = "matrix",
    ) -> None:
        self._agent_sessions = agent_sessions
        self._prototype_state = prototype_state
        self._platform = platform

    async def get_or_create_user(
        self,
        external_id: str,
        platform: str,
        display_name: str | None = None,
    ) -> User:
        return await self._prototype_state.get_or_create_user(
            external_id=external_id,
            platform=platform,
            display_name=display_name,
        )

    async def send_message(
        self,
        user_id: str,
        chat_id: str,
        text: str,
        attachments: list[Attachment] | None = None,
    ) -> MessageResponse:
        thread_key = build_thread_key(self._platform, user_id, chat_id)
        return await self._agent_sessions.send_message(thread_key=thread_key, text=text)

    async def stream_message(
        self,
        user_id: str,
        chat_id: str,
        text: str,
        attachments: list[Attachment] | None = None,
    ) -> AsyncIterator[MessageChunk]:
        thread_key = build_thread_key(self._platform, user_id, chat_id)
        async for chunk in self._agent_sessions.stream_message(thread_key=thread_key, text=text):
            yield chunk

    async def get_settings(self, user_id: str) -> UserSettings:
        return await self._prototype_state.get_settings(user_id)

    async def update_settings(self, user_id: str, action) -> None:
        await self._prototype_state.update_settings(user_id, action)