"""The broadlink component."""
import asyncio
from base64 import b64decode, b64encode
from binascii import unhexlify
from datetime import timedelta
import logging
import re

import voluptuous as vol

from homeassistant.const import CONF_HOST
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
from homeassistant.util.dt import utcnow

from .const import CONF_PACKET, DOMAIN, SERVICE_LEARN, SERVICE_SEND

_LOGGER = logging.getLogger(__name__)

DEFAULT_RETRY = 3


def data_packet(value):
    """Decode a data packet given for broadlink."""
    value = cv.string(value)
    extra = len(value) % 4
    if extra > 0:
        value = value + ("=" * (4 - extra))
    return b64decode(value)


def hostname(value):
    """Validate a hostname."""
    host = str(value).lower()
    if len(host) > 253:
        raise ValueError
    if host[-1] == ".":
        host = host[:-1]
    allowed = re.compile(r"(?!-)[a-z\d-]{1,63}(?<!-)$")
    if not all(allowed.match(elem) for elem in host.split(".")):
        raise ValueError
    return host


def mac_address(value):
    """Validate and coerce a 48-bit MAC address."""
    mac = str(value).lower()
    if len(mac) == 17:
        mac = mac[0:2] + mac[3:5] + mac[6:8] + mac[9:11] + mac[12:14] + mac[15:17]
    elif len(mac) == 14:
        mac = mac[0:2] + mac[2:4] + mac[5:7] + mac[7:9] + mac[10:12] + mac[12:14]
    elif len(mac) != 12:
        raise ValueError
    return unhexlify(mac)


SERVICE_SEND_SCHEMA = vol.Schema(
    {
        vol.Required(CONF_HOST): cv.string,
        vol.Required(CONF_PACKET): vol.All(cv.ensure_list, [data_packet]),
    }
)

SERVICE_LEARN_SCHEMA = vol.Schema({vol.Required(CONF_HOST): cv.string})


@callback
def async_setup_service(hass, host, device):
    """Register a device for given host for use in services."""
    hass.data.setdefault(DOMAIN, {})[host] = device

    if hass.services.has_service(DOMAIN, SERVICE_LEARN):
        return

    async def _attempt(device, function, *args):
        """Retry a socket-related function until it succeeds."""
        for retry in range(DEFAULT_RETRY):
            if retry and not await _connect(device):
                continue
            try:
                await hass.async_add_executor_job(function, *args)
            except OSError:
                continue
            return
        raise ConnectionError

    async def _connect(device):
        """Connect to the remote."""
        try:
            auth = await hass.async_add_executor_job(device.auth)
        except OSError:
            auth = False
        return auth

    async def _learn_command(call):
        """Learn a packet from remote."""

        device = hass.data[DOMAIN][call.data[CONF_HOST]]

        try:
            await _attempt(device, device.enter_learning)
        except ConnectionError:
            _LOGGER.error("Failed to enter learning mode")
            return

        _LOGGER.info("Press the key you want Home Assistant to learn")
        start_time = utcnow()
        while (utcnow() - start_time) < timedelta(seconds=20):
            packet = await hass.async_add_executor_job(device.check_data)
            if packet:
                data = b64encode(packet).decode("utf8")
                log_msg = f"Received packet is: {data}"
                _LOGGER.info(log_msg)
                hass.components.persistent_notification.async_create(
                    log_msg, title="Broadlink switch"
                )
                return
            await asyncio.sleep(1)
        _LOGGER.error("No signal was received")
        hass.components.persistent_notification.async_create(
            "No signal was received", title="Broadlink switch"
        )

    hass.services.async_register(
        DOMAIN, SERVICE_LEARN, _learn_command, schema=SERVICE_LEARN_SCHEMA
    )

    async def _send_packet(call):
        """Send a packet."""
        device = hass.data[DOMAIN][call.data[CONF_HOST]]
        packets = call.data[CONF_PACKET]
        for packet in packets:
            try:
                await _attempt(device, device.send_data, packet)
            except ConnectionError:
                _LOGGER.error("Failed to send packet to device")
                return

    hass.services.async_register(
        DOMAIN, SERVICE_SEND, _send_packet, schema=SERVICE_SEND_SCHEMA
    )