import argparse
from abc import ABCMeta, abstractmethod

import dateutil.relativedelta

from quarg.quassel.types import BufferType, MessageFlag, MessageType
from quarg.utils import errx, parse_isodate

# pylint: disable=too-few-public-methods, unsupported-membership-test

class ParseEnum(argparse.Action, metaclass=ABCMeta):
    def __call__(self, parser, namespace, value, option_string=None):
        key = value.upper()
        if key not in self.enumclass.__members__:
            errx(f'Not a valid {self.enumclass.describe()}: {value}')

        saved = getattr(namespace, self.dest) or []
        saved.append(self.enumclass[key])
        setattr(namespace, self.dest, saved)

    @property
    @abstractmethod
    def enumclass(self):
        pass

class ParseMessageType(ParseEnum):
    @property
    def enumclass(self):
        return MessageType

class ParseMessageFlag(ParseEnum):
    @property
    def enumclass(self):
        return MessageFlag

class ParseBufferType(ParseEnum):
    @property
    def enumclass(self):
        return BufferType

class ParseDate(argparse.Action):
    def __call__(self, parser, namespace, datespec, option_string=None):
        setattr(namespace, self.dest, parse_isodate(datespec))

class ParseAround(argparse.Action):
    def __call__(self, parser, namespace, aroundspec, option_string=None):
        if '/' in aroundspec:
            datespec, rangespec = aroundspec.split('/', 1)
            try:
                hour_range = int(rangespec)
            except ValueError as err:
                errx(err)
        else:
            datespec, hour_range = (aroundspec, 12)

        date = parse_isodate(datespec)

        offset = dateutil.relativedelta.relativedelta(hours=hour_range)
        setattr(namespace, self.dest, (date - offset, date + offset))