"""MediaPlayer platform for SlimProto Player integration."""
from __future__ import annotations

import asyncio

from aioslimproto.client import PlayerState, SlimClient
from aioslimproto.const import EventType, SlimEvent
from aioslimproto.server import SlimServer

from homeassistant.components import media_source
from homeassistant.components.media_player import (
    BrowseMedia,
    MediaPlayerDeviceClass,
    MediaPlayerEntity,
    MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
    async_process_play_media_url,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.util.dt import utcnow

from .const import DEFAULT_NAME, DOMAIN, PLAYER_EVENT

STATE_MAPPING = {
    PlayerState.IDLE: STATE_IDLE,
    PlayerState.PLAYING: STATE_PLAYING,
    PlayerState.PAUSED: STATE_PAUSED,
}


async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: ConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up SlimProto MediaPlayer(s) from Config Entry."""
    slimserver: SlimServer = hass.data[DOMAIN]
    added_ids = set()

    async def async_add_player(player: SlimClient) -> None:
        """Add MediaPlayerEntity from SlimClient."""
        # we delay adding the player a small bit because the player name may be received
        # just a bit after connect. This way we can create a device reg entry with the correct name
        # the name will either be available within a few milliseconds after connect or not at all
        # (its an optional data packet)
        for _ in range(10):
            if player.player_id not in player.name:
                break
            await asyncio.sleep(0.1)
        async_add_entities([SlimProtoPlayer(slimserver, player)])

    async def on_slim_event(event: SlimEvent) -> None:
        """Handle player added/connected event."""
        if event.player_id in added_ids:
            return
        added_ids.add(event.player_id)
        player = slimserver.get_player(event.player_id)
        await async_add_player(player)

    # register listener for new players
    config_entry.async_on_unload(
        slimserver.subscribe(on_slim_event, EventType.PLAYER_CONNECTED)
    )

    # add all current items in controller
    await asyncio.gather(*(async_add_player(player) for player in slimserver.players))


class SlimProtoPlayer(MediaPlayerEntity):
    """Representation of MediaPlayerEntity from SlimProto Player."""

    _attr_should_poll = False
    _attr_supported_features = (
        MediaPlayerEntityFeature.PAUSE
        | MediaPlayerEntityFeature.VOLUME_SET
        | MediaPlayerEntityFeature.STOP
        | MediaPlayerEntityFeature.TURN_ON
        | MediaPlayerEntityFeature.TURN_OFF
        | MediaPlayerEntityFeature.PLAY
        | MediaPlayerEntityFeature.PLAY_MEDIA
        | MediaPlayerEntityFeature.VOLUME_MUTE
        | MediaPlayerEntityFeature.BROWSE_MEDIA
    )
    _attr_device_class = MediaPlayerDeviceClass.SPEAKER

    def __init__(self, slimserver: SlimServer, player: SlimClient) -> None:
        """Initialize MediaPlayer entity."""
        self.slimserver = slimserver
        self.player = player
        self._attr_unique_id = player.player_id
        self._attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, self.player.player_id)},
            manufacturer=DEFAULT_NAME,
            model=self.player.device_model or self.player.device_type,
            name=self.player.name,
            hw_version=self.player.firmware,
        )
        # PiCore + SqueezeESP32 player has web interface
        if "-pCP" in self.player.firmware or self.player.device_model == "SqueezeESP32":
            self._attr_device_info[
                "configuration_url"
            ] = f"http://{self.player.device_address}"
        self.update_attributes()

    async def async_added_to_hass(self) -> None:
        """Register callbacks."""
        self.update_attributes()
        self.async_on_remove(
            self.slimserver.subscribe(
                self._on_slim_event,
                (
                    EventType.PLAYER_UPDATED,
                    EventType.PLAYER_CONNECTED,
                    EventType.PLAYER_DISCONNECTED,
                    EventType.PLAYER_NAME_RECEIVED,
                    EventType.PLAYER_CLI_EVENT,
                ),
                player_filter=self.player.player_id,
            )
        )

    @property
    def available(self) -> bool:
        """Return availability of entity."""
        return self.player.connected

    @property
    def state(self) -> str:
        """Return current state."""
        if not self.player.powered:
            return STATE_OFF
        return STATE_MAPPING[self.player.state]

    @callback
    def update_attributes(self) -> None:
        """Handle player updates."""
        self._attr_name = self.player.name
        self._attr_volume_level = self.player.volume_level / 100
        self._attr_media_position = self.player.elapsed_seconds
        self._attr_media_position_updated_at = utcnow()
        self._attr_media_content_id = self.player.current_url
        self._attr_media_content_type = "music"

    async def async_media_play(self) -> None:
        """Send play command to device."""
        await self.player.play()

    async def async_media_pause(self) -> None:
        """Send pause command to device."""
        await self.player.pause()

    async def async_media_stop(self) -> None:
        """Send stop command to device."""
        await self.player.stop()

    async def async_set_volume_level(self, volume: float) -> None:
        """Send new volume_level to device."""
        volume = round(volume * 100)
        await self.player.volume_set(volume)

    async def async_mute_volume(self, mute: bool) -> None:
        """Mute the volume."""
        await self.player.mute(mute)

    async def async_turn_on(self) -> None:
        """Turn on device."""
        await self.player.power(True)

    async def async_turn_off(self) -> None:
        """Turn off device."""
        await self.player.power(False)

    async def async_play_media(self, media_type: str, media_id: str, **kwargs) -> None:
        """Send the play_media command to the media player."""
        to_send_media_type: str | None = media_type
        # Handle media_source
        if media_source.is_media_source_id(media_id):
            sourced_media = await media_source.async_resolve_media(
                self.hass, media_id, self.entity_id
            )
            media_id = sourced_media.url
            to_send_media_type = sourced_media.mime_type

        if to_send_media_type and not to_send_media_type.startswith("audio/"):
            to_send_media_type = None
        media_id = async_process_play_media_url(self.hass, media_id)

        await self.player.play_url(media_id, mime_type=to_send_media_type)

    async def async_browse_media(
        self, media_content_type=None, media_content_id=None
    ) -> BrowseMedia:
        """Implement the websocket media browsing helper."""
        return await media_source.async_browse_media(
            self.hass,
            media_content_id,
            content_filter=lambda item: item.media_content_type.startswith("audio/"),
        )

    async def _on_slim_event(self, event: SlimEvent) -> None:
        """Call when we receive an event from SlimProto."""
        if event.type == EventType.PLAYER_CONNECTED:
            # player reconnected, update our player object
            self.player = self.slimserver.get_player(event.player_id)
        if event.type == EventType.PLAYER_CLI_EVENT:
            # rpc event from player such as a button press,
            # forward on the eventbus for others to handle
            dev_id = self.registry_entry.device_id if self.registry_entry else None
            evt_data = {
                **event.data,
                "entity_id": self.entity_id,
                "device_id": dev_id,
            }
            self.hass.bus.async_fire(PLAYER_EVENT, evt_data)
            return
        self.update_attributes()
        self.async_write_ha_state()
