"""Support for the PrezziBenzina.it service."""
import datetime as dt
from datetime import timedelta
import logging

import voluptuous as vol

from homeassistant.const import ATTR_ATTRIBUTION, ATTR_TIME, CONF_NAME
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.config_validation import PLATFORM_SCHEMA
from homeassistant.helpers.entity import Entity

_LOGGER = logging.getLogger(__name__)

ATTR_FUEL = 'fuel'
ATTR_SERVICE = 'service'
ATTRIBUTION = 'Data provided by PrezziBenzina.it'

CONF_STATION = 'station'
CONF_TYPES = 'fuel_types'

ICON = 'mdi:fuel'

FUEL_TYPES = [
    'Benzina',
    "Benzina speciale",
    'Diesel',
    "Diesel speciale",
    'GPL',
    'Metano',
]

SCAN_INTERVAL = timedelta(minutes=120)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_STATION): cv.string,
    vol.Optional(CONF_NAME, None): cv.string,
    vol.Optional(CONF_TYPES, None):
        vol.All(cv.ensure_list, [vol.In(FUEL_TYPES)]),
})


async def async_setup_platform(
        hass, config, async_add_entities, discovery_info=None):
    """Set up the PrezziBenzina sensor platform."""
    from prezzibenzina import PrezziBenzinaPy

    station = config[CONF_STATION]
    name = config.get(CONF_NAME)
    types = config.get(CONF_TYPES)

    client = PrezziBenzinaPy()
    dev = []
    info = client.get_by_id(station)

    if name is None:
        name = client.get_station_name(station)

    for index, info in enumerate(info):
        if types is not None and info['fuel'] not in types:
            continue
        dev.append(PrezziBenzinaSensor(
            index, client, station, name, info['fuel'], info['service']))

    async_add_entities(dev, True)


class PrezziBenzinaSensor(Entity):
    """Implementation of a PrezziBenzina sensor."""

    def __init__(self, index, client, station, name, ft, srv):
        """Initialize the PrezziBenzina sensor."""
        self._client = client
        self._index = index
        self._data = None
        self._station = station
        self._name = "{} {} {}".format(name, ft, srv)

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

    @property
    def icon(self):
        """Icon to use in the frontend, if any."""
        return ICON

    @property
    def state(self):
        """Return the state of the device."""
        return self._data['price'].replace(" €", "")

    @property
    def unit_of_measurement(self):
        """Return the unit of measurement of this entity, if any."""
        return self._data['price'].split(" ")[1]

    @property
    def device_state_attributes(self):
        """Return the device state attributes of the last update."""
        timestamp = dt.datetime.strptime(
            self._data['date'], "%d/%m/%Y %H:%M").isoformat()

        attrs = {
            ATTR_ATTRIBUTION: ATTRIBUTION,
            ATTR_FUEL: self._data['fuel'],
            ATTR_SERVICE: self._data['service'],
            ATTR_TIME: timestamp,
        }
        return attrs

    async def async_update(self):
        """Get the latest data and updates the states."""
        self._data = self._client.get_by_id(self._station)[self._index]