import abc
import logging
from datetime import datetime
from typing import List

from dateutil.tz import UTC

from lib_b2b.change import ChangeRecord, ChangeDataProvider
from lib_b2b.errors import RejectionReason, VersionConflictError
from lib_b2b.order import Order
from lib_b2b.order_change import OrderChangeRequest, SimpleOrderPredicate
from lib_b2b.order_status import OrderStatus
from lib_b2b.policy import Policy

logger = logging.getLogger(__name__)


class OrderRejectChangeDataProvider(ChangeDataProvider, metaclass=abc.ABCMeta):
    @property
    @abc.abstractmethod
    def new_status(self) -> OrderStatus:
        raise NotImplementedError

    @property
    @abc.abstractmethod
    def reasons(self) -> List[RejectionReason]:
        raise NotImplementedError


class OrderRejectChangeRequest(OrderChangeRequest):
    # TODO: - Move these policies to be data driven
    _policy = Policy(
        name='reject_change_policy',
        subject=Policy.SUBJECT_ALL,
        predicates=[
            SimpleOrderPredicate(
                lambda o: o.status < OrderStatus.ACCEPTED,
                'Order can only be rejected prior to accepting.')
        ]
    )

    def __init__(self, on_behalf_of: str, change_data_provider: OrderRejectChangeDataProvider):
        super().__init__(on_behalf_of, OrderRejectChangeRequest._policy)
        self.change_data_provider = change_data_provider

    def will_change(self, order: Order) -> bool:
        return self.change_data_provider.new_status is OrderStatus.REJECTED \
               and order.status is not OrderStatus.REJECTED

    def apply(self, order: Order):
        try:
            self.changeable_object = order
            if super().permitted(order):
                if self.will_change(order):
                    before_status = order.status
                    order.set_status(OrderStatus.REJECTED,
                                     version=self.change_data_provider.version())
                    order.modify(
                        data={
                            'acknowledged': True,
                            'acknowledgement_sent': False,
                            'acknowledged_date': datetime.now().astimezone(UTC).isoformat(),
                            'rejection_reason': list(map(lambda x: x.as_dict(), self.change_data_provider.reasons))
                        }
                    )
                    order.record(
                        ChangeRecord(before=before_status.value, after=OrderStatus.REJECTED.value,
                                     description="Order was rejected", when=datetime.now().astimezone(UTC), who=self.on_behalf_of)
                    )
        except ValueError as ve:
            raise VersionConflictError(str(ve))