import logging
import voluptuous as vol

from homeassistant.components.websocket_api import (
    websocket_command,
    result_message,
    event_message,
    async_register_command,
)

from .const import WS_CONNECT, WS_UPDATE
from .helpers import get_devices, create_entity, get_config, is_setup_complete

_LOGGER = logging.getLogger(__name__)


async def setup_connection(hass, config):
    @websocket_command(
        {
            vol.Required("type"): WS_CONNECT,
            vol.Required("deviceID"): str,
        }
    )
    def handle_connect(hass, connection, msg):
        deviceID = msg["deviceID"]

        device = get_devices(hass).get(deviceID, BrowserModConnection(hass, deviceID))
        device.connect(connection, msg["id"])
        get_devices(hass)[deviceID] = device

        connection.send_message(result_message(msg["id"]))

    @websocket_command(
        {
            vol.Required("type"): WS_UPDATE,
            vol.Required("deviceID"): str,
            vol.Optional("data"): dict,
        }
    )
    def handle_update(hass, connection, msg):
        devices = get_devices(hass)
        deviceID = msg["deviceID"]
        if deviceID in devices:
            devices[deviceID].update(msg.get("data", None))

    async_register_command(hass, handle_connect)
    async_register_command(hass, handle_update)


class BrowserModConnection:
    def __init__(self, hass, deviceID):
        self.hass = hass
        self.deviceID = deviceID
        self.connection = []

        self.media_player = None
        self.screen = None
        self.sensor = None
        self.fully = None
        self.camera = None

    def connect(self, connection, cid):
        self.connection.append((connection, cid))
        self.trigger_update()

        def disconnect():
            self.connection.remove((connection, cid))

        connection.subscriptions[cid] = disconnect

    def send(self, command, **kwargs):
        if self.connection:
            connection, cid = self.connection[-1]
            connection.send_message(
                event_message(
                    cid,
                    {
                        "command": command,
                        **kwargs,
                    },
                )
            )

    def trigger_update(self):
        if is_setup_complete(self.hass):
            self.send("update", **get_config(self.hass, self.deviceID))

    def update(self, data):
        if data.get("browser"):
            self.sensor = self.sensor or create_entity(
                self.hass, "sensor", self.deviceID, self
            )
            if self.sensor:
                self.sensor.data = data.get("browser")

        if data.get("player"):
            self.media_player = self.media_player or create_entity(
                self.hass, "media_player", self.deviceID, self
            )
            if self.media_player:
                self.media_player.data = data.get("player")

        if data.get("screen"):
            self.screen = self.screen or create_entity(
                self.hass, "light", self.deviceID, self
            )
            if self.screen:
                self.screen.data = data.get("screen")

        if data.get("fully"):
            self.fully = self.fully or create_entity(
                self.hass, "binary_sensor", self.deviceID, self
            )
            if self.fully:
                self.fully.data = data.get("fully")

        if data.get("camera"):
            self.camera = self.camera or create_entity(
                self.hass, "camera", self.deviceID, self
            )
            if self.camera:
                self.camera.data = data.get("camera")