"""Sensor support for Netgear Arlo IP cameras."""
import logging

import voluptuous as vol

from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
    ATTR_ATTRIBUTION,
    CONCENTRATION_PARTS_PER_MILLION,
    CONF_MONITORED_CONDITIONS,
    DEVICE_CLASS_HUMIDITY,
    DEVICE_CLASS_TEMPERATURE,
    TEMP_CELSIUS,
    UNIT_PERCENTAGE,
)
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.icon import icon_for_battery_level

from . import ATTRIBUTION, DATA_ARLO, DEFAULT_BRAND, SIGNAL_UPDATE_ARLO

_LOGGER = logging.getLogger(__name__)

# sensor_type [ description, unit, icon ]
SENSOR_TYPES = {
    "last_capture": ["Last", None, "run-fast"],
    "total_cameras": ["Arlo Cameras", None, "video"],
    "captured_today": ["Captured Today", None, "file-video"],
    "battery_level": ["Battery Level", UNIT_PERCENTAGE, "battery-50"],
    "signal_strength": ["Signal Strength", None, "signal"],
    "temperature": ["Temperature", TEMP_CELSIUS, "thermometer"],
    "humidity": ["Humidity", UNIT_PERCENTAGE, "water-percent"],
    "air_quality": ["Air Quality", CONCENTRATION_PARTS_PER_MILLION, "biohazard"],
}

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)): vol.All(
            cv.ensure_list, [vol.In(SENSOR_TYPES)]
        )
    }
)


def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up an Arlo IP sensor."""
    arlo = hass.data.get(DATA_ARLO)
    if not arlo:
        return

    sensors = []
    for sensor_type in config[CONF_MONITORED_CONDITIONS]:
        if sensor_type == "total_cameras":
            sensors.append(ArloSensor(SENSOR_TYPES[sensor_type][0], arlo, sensor_type))
        else:
            for camera in arlo.cameras:
                if sensor_type in ("temperature", "humidity", "air_quality"):
                    continue

                name = f"{SENSOR_TYPES[sensor_type][0]} {camera.name}"
                sensors.append(ArloSensor(name, camera, sensor_type))

            for base_station in arlo.base_stations:
                if (
                    sensor_type in ("temperature", "humidity", "air_quality")
                    and base_station.model_id == "ABC1000"
                ):
                    name = f"{SENSOR_TYPES[sensor_type][0]} {base_station.name}"
                    sensors.append(ArloSensor(name, base_station, sensor_type))

    add_entities(sensors, True)


class ArloSensor(Entity):
    """An implementation of a Netgear Arlo IP sensor."""

    def __init__(self, name, device, sensor_type):
        """Initialize an Arlo sensor."""
        _LOGGER.debug("ArloSensor created for %s", name)
        self._name = name
        self._data = device
        self._sensor_type = sensor_type
        self._state = None
        self._icon = f"mdi:{SENSOR_TYPES.get(self._sensor_type)[2]}"

    @property
    def name(self):
        """Return the name of this camera."""
        return self._name

    async def async_added_to_hass(self):
        """Register callbacks."""
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass, SIGNAL_UPDATE_ARLO, self._update_callback
            )
        )

    @callback
    def _update_callback(self):
        """Call update method."""
        self.async_schedule_update_ha_state(True)

    @property
    def state(self):
        """Return the state of the sensor."""
        return self._state

    @property
    def icon(self):
        """Icon to use in the frontend, if any."""
        if self._sensor_type == "battery_level" and self._state is not None:
            return icon_for_battery_level(
                battery_level=int(self._state), charging=False
            )
        return self._icon

    @property
    def unit_of_measurement(self):
        """Return the units of measurement."""
        return SENSOR_TYPES.get(self._sensor_type)[1]

    @property
    def device_class(self):
        """Return the device class of the sensor."""
        if self._sensor_type == "temperature":
            return DEVICE_CLASS_TEMPERATURE
        if self._sensor_type == "humidity":
            return DEVICE_CLASS_HUMIDITY
        return None

    def update(self):
        """Get the latest data and updates the state."""
        _LOGGER.debug("Updating Arlo sensor %s", self.name)
        if self._sensor_type == "total_cameras":
            self._state = len(self._data.cameras)

        elif self._sensor_type == "captured_today":
            self._state = len(self._data.captured_today)

        elif self._sensor_type == "last_capture":
            try:
                video = self._data.last_video
                self._state = video.created_at_pretty("%m-%d-%Y %H:%M:%S")
            except (AttributeError, IndexError):
                error_msg = (
                    f"Video not found for {self.name}. "
                    f"Older than {self._data.min_days_vdo_cache} days?"
                )
                _LOGGER.debug(error_msg)
                self._state = None

        elif self._sensor_type == "battery_level":
            try:
                self._state = self._data.battery_level
            except TypeError:
                self._state = None

        elif self._sensor_type == "signal_strength":
            try:
                self._state = self._data.signal_strength
            except TypeError:
                self._state = None

        elif self._sensor_type == "temperature":
            try:
                self._state = self._data.ambient_temperature
            except TypeError:
                self._state = None

        elif self._sensor_type == "humidity":
            try:
                self._state = self._data.ambient_humidity
            except TypeError:
                self._state = None

        elif self._sensor_type == "air_quality":
            try:
                self._state = self._data.ambient_air_quality
            except TypeError:
                self._state = None

    @property
    def device_state_attributes(self):
        """Return the device state attributes."""
        attrs = {}

        attrs[ATTR_ATTRIBUTION] = ATTRIBUTION
        attrs["brand"] = DEFAULT_BRAND

        if self._sensor_type != "total_cameras":
            attrs["model"] = self._data.model_id

        return attrs
