"""Sensor for Crime Reports."""
from collections import defaultdict
from datetime import timedelta
import logging

import voluptuous as vol

from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
    CONF_INCLUDE,
    CONF_EXCLUDE,
    CONF_NAME,
    CONF_LATITUDE,
    CONF_LONGITUDE,
    ATTR_ATTRIBUTION,
    ATTR_LATITUDE,
    ATTR_LONGITUDE,
    CONF_RADIUS,
    LENGTH_KILOMETERS,
    LENGTH_METERS,
)
from homeassistant.helpers.entity import Entity
from homeassistant.util import slugify
from homeassistant.util.distance import convert
from homeassistant.util.dt import now
import homeassistant.helpers.config_validation as cv

_LOGGER = logging.getLogger(__name__)

DOMAIN = "crimereports"

EVENT_INCIDENT = "{}_incident".format(DOMAIN)

SCAN_INTERVAL = timedelta(minutes=30)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_NAME): cv.string,
        vol.Required(CONF_RADIUS): vol.Coerce(float),
        vol.Inclusive(CONF_LATITUDE, "coordinates"): cv.latitude,
        vol.Inclusive(CONF_LONGITUDE, "coordinates"): cv.longitude,
        vol.Optional(CONF_INCLUDE): vol.All(cv.ensure_list, [cv.string]),
        vol.Optional(CONF_EXCLUDE): vol.All(cv.ensure_list, [cv.string]),
    }
)


def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the Crime Reports platform."""
    latitude = config.get(CONF_LATITUDE, hass.config.latitude)
    longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
    name = config.get(CONF_NAME)
    radius = config.get(CONF_RADIUS)
    include = config.get(CONF_INCLUDE)
    exclude = config.get(CONF_EXCLUDE)

    add_entities(
        [CrimeReportsSensor(hass, name, latitude, longitude, radius, include, exclude)],
        True,
    )


class CrimeReportsSensor(Entity):
    """Representation of a Crime Reports Sensor."""

    def __init__(self, hass, name, latitude, longitude, radius, include, exclude):
        """Initialize the Crime Reports sensor."""
        import crimereports

        self._hass = hass
        self._name = name
        self._include = include
        self._exclude = exclude
        radius_kilometers = convert(radius, LENGTH_METERS, LENGTH_KILOMETERS)
        self._crimereports = crimereports.CrimeReports(
            (latitude, longitude), radius_kilometers
        )
        self._attributes = None
        self._state = None
        self._previous_incidents = set()

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

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

    @property
    def device_state_attributes(self):
        """Return the state attributes."""
        return self._attributes

    def _incident_event(self, incident):
        """Fire if an event occurs."""
        data = {
            "type": incident.get("type"),
            "description": incident.get("friendly_description"),
            "timestamp": incident.get("timestamp"),
            "location": incident.get("location"),
        }
        if incident.get("coordinates"):
            data.update(
                {
                    ATTR_LATITUDE: incident.get("coordinates")[0],
                    ATTR_LONGITUDE: incident.get("coordinates")[1],
                }
            )
        self._hass.bus.fire(EVENT_INCIDENT, data)

    def update(self):
        """Update device state."""
        import crimereports

        incident_counts = defaultdict(int)
        incidents = self._crimereports.get_incidents(
            now().date(), include=self._include, exclude=self._exclude
        )
        fire_events = len(self._previous_incidents) > 0
        if len(incidents) < len(self._previous_incidents):
            self._previous_incidents = set()
        for incident in incidents:
            incident_type = slugify(incident.get("type"))
            incident_counts[incident_type] += 1
            if fire_events and incident.get("id") not in self._previous_incidents:
                self._incident_event(incident)
            self._previous_incidents.add(incident.get("id"))
        self._attributes = {ATTR_ATTRIBUTION: crimereports.ATTRIBUTION}
        self._attributes.update(incident_counts)
        self._state = len(incidents)
