import logging

import tzlocal
from django.utils import timezone as tz
from django.utils.translation import gettext_lazy as _


__all__ = (
    "BaseMetadata",
    "Request",
)

local_tz = tzlocal.get_localzone()
logger = logging.getLogger("aircox")


# FIXME liquidsoap does not manage timezones -- we have to convert
#       'on_air' metadata we get from it into utc one in order to work
#       correctly.


class BaseMetadata:
    """Base class for handling request metadata."""

    controller = None
    """Controller."""
    rid = None
    """Request id."""
    uri = None
    """Request uri."""
    status = None
    """Current playing status."""
    request_status = None
    """Requests' status."""
    air_time = None
    """Launch datetime."""

    def __init__(self, controller=None, rid=None, data=None):
        self.controller = controller
        self.rid = rid
        if data is not None:
            self.validate(data)

    @property
    def is_playing(self):
        return self.status == "playing"

    @property
    def status_verbose(self):
        return self.validate_status(self.status, True)

    def fetch(self):
        data = self.controller.send("request.metadata ", self.rid, parse=True)
        if data:
            self.validate(data)

    def validate_status(self, status, i18n=False):
        on_air = self.controller.source
        if (
            on_air
            and status == "playing"
            and (on_air == self or on_air.rid == self.rid)
        ):
            return _("playing") if i18n else "playing"
        elif status == "playing":
            return _("paused") if i18n else "paused"
        else:
            return _("stopped") if i18n else "stopped"

    def validate_air_time(self, air_time):
        if air_time:
            air_time = tz.datetime.strptime(air_time, "%Y/%m/%d %H:%M:%S")
            return local_tz.localize(air_time)

    def validate(self, data):
        """Validate provided data and set as attribute (must already be
        declared)"""
        for key, value in data.items():
            if hasattr(self, key) and not callable(getattr(self, key)):
                setattr(self, key, value)
        self.uri = data.get("initial_uri")

        self.air_time = self.validate_air_time(data.get("on_air"))
        self.status = self.validate_status(data.get("status"))
        self.request_status = data.get("status")


class Request(BaseMetadata):
    title = None
    artist = None