"""Windows SMTC-Implementierung via pywinrt."""

import logging
from typing import Any

logger = logging.getLogger(__name__)


class SmtcController:
    def __init__(self) -> None:
        self._paused: list[str] = []
        self._manager: Any = None
        self._broken: bool = False

    async def _ensure_manager(self) -> Any:
        if self._broken:
            raise RuntimeError("SMTC nicht verfügbar")
        if self._manager is None:
            from winrt.windows.media.control import (
                GlobalSystemMediaTransportControlsSessionManager,
            )
            self._manager = (
                await GlobalSystemMediaTransportControlsSessionManager.request_async()
            )
        return self._manager

    async def _pause_session(self, session: Any) -> str | None:
        """Pausiert eine Session wenn sie spielt. Gibt AUMID zurück, sonst None."""
        from winrt.windows.media.control import (
            GlobalSystemMediaTransportControlsSessionPlaybackStatus,
        )
        aumid = session.source_app_user_model_id
        try:
            info = session.get_playback_info()
            if (
                info.playback_status
                != GlobalSystemMediaTransportControlsSessionPlaybackStatus.PLAYING
            ):
                return None
            await session.try_pause_async()
            return aumid
        except Exception as e:
            logger.warning("Konnte Session %s nicht pausieren: %s", aumid, e)
            return None

    async def pause(self) -> None:
        if self._broken:
            self._paused = []
            return

        try:
            manager = await self._ensure_manager()
        except Exception as e:
            logger.warning(
                "SMTC nicht erreichbar, Media-Pause dauerhaft deaktiviert: %s", e
            )
            self._broken = True
            self._paused = []
            return

        sessions = list(manager.get_sessions())
        paused = []
        for session in sessions:
            result = await self._pause_session(session)
            if result is not None:
                paused.append(result)
        self._paused = paused

    async def resume(self) -> None:
        if not self._paused:
            return
        try:
            manager = await self._ensure_manager()
            current = {
                s.source_app_user_model_id: s for s in manager.get_sessions()
            }
        except Exception as e:
            logger.warning("SMTC nicht erreichbar beim Fortsetzen: %s", e)
            self._paused = []
            return
        to_resume = self._paused
        self._paused = []
        for aumid in to_resume:
            session = current.get(aumid)
            if session is None:
                logger.warning(
                    "Session %s nicht mehr vorhanden, wird übersprungen", aumid
                )
                continue
            try:
                await session.try_play_async()
            except Exception as e:
                logger.warning("Konnte Session %s nicht fortsetzen: %s", aumid, e)