"""Support gathering system information of hosts which are running glances."""
from datetime import timedelta
import logging

import voluptuous as vol

from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
    CONF_HOST,
    CONF_NAME,
    CONF_PORT,
    CONF_USERNAME,
    CONF_PASSWORD,
    CONF_SSL,
    CONF_VERIFY_SSL,
    CONF_RESOURCES,
    STATE_UNAVAILABLE,
    TEMP_CELSIUS,
)
from homeassistant.exceptions import PlatformNotReady
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from homeassistant.util import Throttle

_LOGGER = logging.getLogger(__name__)

CONF_VERSION = "version"

DEFAULT_HOST = "localhost"
DEFAULT_NAME = "Glances"
DEFAULT_PORT = "61208"
DEFAULT_VERSION = 2

MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=1)

SENSOR_TYPES = {
    "disk_use_percent": ["Disk used percent", "%", "mdi:harddisk"],
    "disk_use": ["Disk used", "GiB", "mdi:harddisk"],
    "disk_free": ["Disk free", "GiB", "mdi:harddisk"],
    "memory_use_percent": ["RAM used percent", "%", "mdi:memory"],
    "memory_use": ["RAM used", "MiB", "mdi:memory"],
    "memory_free": ["RAM free", "MiB", "mdi:memory"],
    "swap_use_percent": ["Swap used percent", "%", "mdi:memory"],
    "swap_use": ["Swap used", "GiB", "mdi:memory"],
    "swap_free": ["Swap free", "GiB", "mdi:memory"],
    "processor_load": ["CPU load", "15 min", "mdi:memory"],
    "process_running": ["Running", "Count", "mdi:memory"],
    "process_total": ["Total", "Count", "mdi:memory"],
    "process_thread": ["Thread", "Count", "mdi:memory"],
    "process_sleeping": ["Sleeping", "Count", "mdi:memory"],
    "cpu_use_percent": ["CPU used", "%", "mdi:memory"],
    "cpu_temp": ["CPU Temp", TEMP_CELSIUS, "mdi:thermometer"],
    "docker_active": ["Containers active", "", "mdi:docker"],
    "docker_cpu_use": ["Containers CPU used", "%", "mdi:docker"],
    "docker_memory_use": ["Containers RAM used", "MiB", "mdi:docker"],
}

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_HOST, default=DEFAULT_HOST): cv.string,
        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
        vol.Optional(CONF_USERNAME): cv.string,
        vol.Optional(CONF_PASSWORD): cv.string,
        vol.Optional(CONF_SSL, default=False): cv.boolean,
        vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
        vol.Optional(CONF_RESOURCES, default=["disk_use"]): vol.All(
            cv.ensure_list, [vol.In(SENSOR_TYPES)]
        ),
        vol.Optional(CONF_VERSION, default=DEFAULT_VERSION): vol.In([2, 3]),
    }
)


async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
    """Set up the Glances sensors."""
    from glances_api import Glances

    name = config[CONF_NAME]
    host = config[CONF_HOST]
    port = config[CONF_PORT]
    version = config[CONF_VERSION]
    var_conf = config[CONF_RESOURCES]
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    ssl = config[CONF_SSL]
    verify_ssl = config[CONF_VERIFY_SSL]

    session = async_get_clientsession(hass, verify_ssl)
    glances = GlancesData(
        Glances(
            hass.loop,
            session,
            host=host,
            port=port,
            version=version,
            username=username,
            password=password,
            ssl=ssl,
        )
    )

    await glances.async_update()

    if glances.api.data is None:
        raise PlatformNotReady

    dev = []
    for resource in var_conf:
        dev.append(GlancesSensor(glances, name, resource))

    async_add_entities(dev, True)


class GlancesSensor(Entity):
    """Implementation of a Glances sensor."""

    def __init__(self, glances, name, sensor_type):
        """Initialize the sensor."""
        self.glances = glances
        self._name = name
        self.type = sensor_type
        self._state = None
        self._unit_of_measurement = SENSOR_TYPES[sensor_type][1]

    @property
    def name(self):
        """Return the name of the sensor."""
        return "{} {}".format(self._name, SENSOR_TYPES[self.type][0])

    @property
    def icon(self):
        """Icon to use in the frontend, if any."""
        return SENSOR_TYPES[self.type][2]

    @property
    def unit_of_measurement(self):
        """Return the unit the value is expressed in."""
        return self._unit_of_measurement

    @property
    def available(self):
        """Could the device be accessed during the last update call."""
        return self.glances.available

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

    async def async_update(self):
        """Get the latest data from REST API."""
        await self.glances.async_update()
        value = self.glances.api.data

        if value is not None:
            if self.type == "disk_use_percent":
                self._state = value["fs"][0]["percent"]
            elif self.type == "disk_use":
                self._state = round(value["fs"][0]["used"] / 1024 ** 3, 1)
            elif self.type == "disk_free":
                try:
                    self._state = round(value["fs"][0]["free"] / 1024 ** 3, 1)
                except KeyError:
                    self._state = round(
                        (value["fs"][0]["size"] - value["fs"][0]["used"]) / 1024 ** 3, 1
                    )
            elif self.type == "memory_use_percent":
                self._state = value["mem"]["percent"]
            elif self.type == "memory_use":
                self._state = round(value["mem"]["used"] / 1024 ** 2, 1)
            elif self.type == "memory_free":
                self._state = round(value["mem"]["free"] / 1024 ** 2, 1)
            elif self.type == "swap_use_percent":
                self._state = value["memswap"]["percent"]
            elif self.type == "swap_use":
                self._state = round(value["memswap"]["used"] / 1024 ** 3, 1)
            elif self.type == "swap_free":
                self._state = round(value["memswap"]["free"] / 1024 ** 3, 1)
            elif self.type == "processor_load":
                # Windows systems don't provide load details
                try:
                    self._state = value["load"]["min15"]
                except KeyError:
                    self._state = value["cpu"]["total"]
            elif self.type == "process_running":
                self._state = value["processcount"]["running"]
            elif self.type == "process_total":
                self._state = value["processcount"]["total"]
            elif self.type == "process_thread":
                self._state = value["processcount"]["thread"]
            elif self.type == "process_sleeping":
                self._state = value["processcount"]["sleeping"]
            elif self.type == "cpu_use_percent":
                self._state = value["quicklook"]["cpu"]
            elif self.type == "cpu_temp":
                for sensor in value["sensors"]:
                    if sensor["label"] in [
                        "amdgpu 1",
                        "aml_thermal",
                        "Core 0",
                        "Core 1",
                        "CPU Temperature",
                        "CPU",
                        "cpu-thermal 1",
                        "cpu_thermal 1",
                        "exynos-therm 1",
                        "Package id 0",
                        "Physical id 0",
                        "radeon 1",
                        "soc-thermal 1",
                        "soc_thermal 1",
                    ]:
                        self._state = sensor["value"]
            elif self.type == "docker_active":
                count = 0
                try:
                    for container in value["docker"]["containers"]:
                        if (
                            container["Status"] == "running"
                            or "Up" in container["Status"]
                        ):
                            count += 1
                    self._state = count
                except KeyError:
                    self._state = count
            elif self.type == "docker_cpu_use":
                cpu_use = 0.0
                try:
                    for container in value["docker"]["containers"]:
                        if (
                            container["Status"] == "running"
                            or "Up" in container["Status"]
                        ):
                            cpu_use += container["cpu"]["total"]
                        self._state = round(cpu_use, 1)
                except KeyError:
                    self._state = STATE_UNAVAILABLE
            elif self.type == "docker_memory_use":
                mem_use = 0.0
                try:
                    for container in value["docker"]["containers"]:
                        if (
                            container["Status"] == "running"
                            or "Up" in container["Status"]
                        ):
                            mem_use += container["memory"]["usage"]
                        self._state = round(mem_use / 1024 ** 2, 1)
                except KeyError:
                    self._state = STATE_UNAVAILABLE


class GlancesData:
    """The class for handling the data retrieval."""

    def __init__(self, api):
        """Initialize the data object."""
        self.api = api
        self.available = True

    @Throttle(MIN_TIME_BETWEEN_UPDATES)
    async def async_update(self):
        """Get the latest data from the Glances REST API."""
        from glances_api.exceptions import GlancesApiError

        try:
            await self.api.get_data()
            self.available = True
        except GlancesApiError:
            _LOGGER.error("Unable to fetch data from Glances")
            self.available = False
