import collections

import datetime

import functools

import itertools

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.db import transaction

from django.db.models import Max

from django.utils import timezone

from registrasion.exceptions import CartValidationError

from registrasion.models import commerce

from registrasion.models import conditions

from registrasion.models import inventory

from .category import CategoryController

from .conditions import ConditionController

from .discount import DiscountController

from .flag import FlagController

from .product import ProductController

def _modifies_cart(func):

    ''' Decorator that makes the wrapped function raise ValidationError

    if we're doing something that could modify the cart. '''

    @functools.wraps(func)

    def inner(self, *a, **k):

        self._fail_if_cart_is_not_active()

        return func(self, *a, **k)

    return inner

class CartController(object):

    def __init__(self, cart):

        self.cart = cart

    @classmethod

    def for_user(cls, user):

        ''' Returns the user's current cart, or creates a new cart

        if there isn't one ready yet. '''

        try:

            existing = commerce.Cart.objects.get(

                user=user,

                status=commerce.Cart.STATUS_ACTIVE,

            )

        except ObjectDoesNotExist:

            existing = commerce.Cart.objects.create(

                user=user,

                time_last_updated=timezone.now(),

                reservation_duration=datetime.timedelta(),

            )

        return cls(existing)

    def _fail_if_cart_is_not_active(self):

        self.cart.refresh_from_db()

        if self.cart.status != commerce.Cart.STATUS_ACTIVE:

            raise ValidationError("You can only amend active carts.")

    @_modifies_cart

    def extend_reservation(self):

        ''' Updates the cart's time last updated value, which is used to

        determine whether the cart has reserved the items and discounts it

        holds. '''

        reservations = [datetime.timedelta()]

        # If we have vouchers, we're entitled to an hour at minimum.

        if len(self.cart.vouchers.all()) >= 1:

            reservations.append(inventory.Voucher.RESERVATION_DURATION)

        # Else, it's the maximum of the included products

        items = commerce.ProductItem.objects.filter(cart=self.cart)

        agg = items.aggregate(Max("product__reservation_duration"))

        product_max = agg["product__reservation_duration__max"]

        if product_max is not None:

            reservations.append(product_max)

        self.cart.time_last_updated = timezone.now()

        self.cart.reservation_duration = max(reservations)

    @_modifies_cart

    def end_batch(self):

        ''' Performs operations that occur occur at the end of a batch of

        product changes/voucher applications etc.

        THIS SHOULD BE PRIVATE

        '''

        self.recalculate_discounts()

        self.extend_reservation()

        self.cart.revision += 1

        self.cart.save()

    @_modifies_cart

    @transaction.atomic

    def set_quantities(self, product_quantities):

        ''' Sets the quantities on each of the products on each of the

        products specified. Raises an exception (ValidationError) if a limit

        is violated. `product_quantities` is an iterable of (product, quantity)

        pairs. '''

        items_in_cart = commerce.ProductItem.objects.filter(cart=self.cart)

        items_in_cart = items_in_cart.select_related(

            "product",

            "product__category",

        )

        product_quantities = list(product_quantities)

        # n.b need to add have the existing items first so that the new

        # items override the old ones.

        all_product_quantities = dict(itertools.chain(

            ((i.product, i.quantity) for i in items_in_cart.all()),

            product_quantities,

        )).items()

        # Validate that the limits we're adding are OK

        self._test_limits(all_product_quantities)

        for product, quantity in product_quantities:

            try:

                product_item = commerce.ProductItem.objects.get(

                    cart=self.cart,

                    product=product,

                )

                product_item.quantity = quantity

                product_item.save()

            except ObjectDoesNotExist:

                commerce.ProductItem.objects.create(

                    cart=self.cart,

                    product=product,

                    quantity=quantity,

                )

        items_in_cart.filter(quantity=0).delete()

        self.end_batch()

    def _test_limits(self, product_quantities):

        ''' Tests that the quantity changes we intend to make do not violate

        the limits and flag conditions imposed on the products. '''

        errors = []

        # Test each product limit here

        for product, quantity in product_quantities:

            if quantity < 0:

                errors.append((product, "Value must be zero or greater."))

            prod = ProductController(product)

            limit = prod.user_quantity_remaining(self.cart.user)

            if quantity > limit:

                errors.append((

                    product,

                    "You may only have %d of product: %s" % (

                        limit, product,

                    )

                ))

        # Collect by category

        by_cat = collections.defaultdict(list)

        for product, quantity in product_quantities:

            by_cat[product.category].append((product, quantity))

        # Test each category limit here

        for category in by_cat:

            ctrl = CategoryController(category)

            limit = ctrl.user_quantity_remaining(self.cart.user)

            # Get the amount so far in the cart

            to_add = sum(i[1] for i in by_cat[category])

            if to_add > limit:

                errors.append((

                    category,

                    "You may only have %d items in category: %s" % (

                        limit, category.name,

                    )

                ))

        # Test the flag conditions

        errs = FlagController.test_flags(

            self.cart.user,

            product_quantities=product_quantities,

        )

        if errs:

            for error in errs:

                errors.append(error)

        if errors:

            raise CartValidationError(errors)

    @_modifies_cart

    def apply_voucher(self, voucher_code):

        ''' Applies the voucher with the given code to this cart. '''

        # Try and find the voucher

        voucher = inventory.Voucher.objects.get(code=voucher_code.upper())

        # Re-applying vouchers should be idempotent

        if voucher in self.cart.vouchers.all():

            return

        self._test_voucher(voucher)

        # If successful...

        self.cart.vouchers.add(voucher)

        self.end_batch()

    def _test_voucher(self, voucher):

        ''' Tests whether this voucher is allowed to be applied to this cart.

        Raises ValidationError if not. '''

        # Is voucher exhausted?

        active_carts = commerce.Cart.reserved_carts()

        # It's invalid for a user to enter a voucher that's exhausted

        carts_with_voucher = active_carts.filter(vouchers=voucher)

        carts_with_voucher = carts_with_voucher.exclude(pk=self.cart.id)

        if carts_with_voucher.count() >= voucher.limit:

            raise ValidationError(

                "Voucher %s is no longer available" % voucher.code)

        # It's not valid for users to re-enter a voucher they already have

        user_carts_with_voucher = carts_with_voucher.filter(

            user=self.cart.user,

        )

        if user_carts_with_voucher.count() > 0:

            raise ValidationError("You have already entered this voucher.")

    def _test_vouchers(self, vouchers):

        ''' Tests each of the vouchers against self._test_voucher() and raises

        the collective ValidationError.

        Future work will refactor _test_voucher in terms of this, and save some

        queries. '''

        errors = []

        for voucher in vouchers:

            try:

                self._test_voucher(voucher)

            except ValidationError as ve:

                errors.append(ve)

        if errors:

            raise(ValidationError(ve))

    def _test_required_categories(self):

        ''' Makes sure that the owner of this cart has satisfied all of the

        required category constraints in the inventory (be it in this cart

        or others). '''

        required = set(inventory.Category.objects.filter(required=True))

        items = commerce.ProductItem.objects.filter(

            product__category__required=True,

            cart__user=self.cart.user,

        ).exclude(

            cart__status=commerce.Cart.STATUS_RELEASED,

        )

        for item in items:

            required.remove(item.product.category)

        errors = []

        for category in required:

            msg = "You must have at least one item from: %s" % category

            errors.append((None, msg))

        if errors:

            raise ValidationError(errors)

    def _append_errors(self, errors, ve):

        for error in ve.error_list:

            errors.append(error.message[1])

    def validate_cart(self):

        ''' Determines whether the status of the current cart is valid;

        this is normally called before generating or paying an invoice '''

        cart = self.cart

        user = self.cart.user

        errors = []

        try:

            self._test_vouchers(self.cart.vouchers.all())

        except ValidationError as ve:

            errors.append(ve)

        items = commerce.ProductItem.objects.filter(cart=cart)

        product_quantities = list((i.product, i.quantity) for i in items)

        try:

            self._test_limits(product_quantities)

        except ValidationError as ve:

            self._append_errors(errors, ve)

        try:

            self._test_required_categories()

        except ValidationError as ve:

            self._append_errors(errors, ve)

        # Validate the discounts

        # TODO: refactor in terms of available_discounts

        # why aren't we doing that here?!

        discount_items = commerce.DiscountItem.objects.filter(cart=cart)

        seen_discounts = set()

        for discount_item in discount_items:

            discount = discount_item.discount

            if discount in seen_discounts:

                continue

            seen_discounts.add(discount)

            real_discount = conditions.DiscountBase.objects.get_subclass(

                pk=discount.pk)

            cond = ConditionController.for_condition(real_discount)

            if not cond.is_met(user):

                errors.append(

                    ValidationError("Discounts are no longer available")

                )

        if errors:

            raise ValidationError(errors)

    @_modifies_cart

    @transaction.atomic

    def fix_simple_errors(self):

        ''' This attempts to fix the easy errors raised by ValidationError.

        This includes removing items from the cart that are no longer

        available, recalculating all of the discounts, and removing voucher

        codes that are no longer available. '''

        # Fix vouchers first (this affects available discounts)

        to_remove = []

        for voucher in self.cart.vouchers.all():

            try:

                self._test_voucher(voucher)

            except ValidationError:

                to_remove.append(voucher)

        for voucher in to_remove:

            self.cart.vouchers.remove(voucher)

        # Fix products and discounts

        items = commerce.ProductItem.objects.filter(cart=self.cart)

        items = items.select_related("product")

        products = set(i.product for i in items)

        available = set(ProductController.available_products(

            self.cart.user,

            products=products,

        ))

        not_available = products - available

        zeros = [(product, 0) for product in not_available]

        self.set_quantities(zeros)

    @_modifies_cart

    @transaction.atomic

    def recalculate_discounts(self):

        ''' Calculates all of the discounts available for this product.

        '''

        # Delete the existing entries.

        commerce.DiscountItem.objects.filter(cart=self.cart).delete()

        product_items = self.cart.productitem_set.all().select_related(

            "product", "product__category", "product__price"

        )

        products = [i.product for i in product_items]

        # The highest-value discounts will apply to the highest-value

        # products first.

        product_items = reversed(product_items)

        for item in product_items:

            self._add_discount(item.product, item.quantity, discounts)

    def _add_discount(self, product, quantity, discounts):

        ''' Applies the best discounts on the given product, from the given

        discounts.'''

        def matches(discount):

            ''' Returns True if and only if the given discount apples to

            our product. '''

            if isinstance(discount.clause, conditions.DiscountForCategory):

                return discount.clause.category == product.category

            else:

                return discount.clause.product == product

        def value(discount):

            ''' Returns the value of this discount clause

            as applied to this product '''

            if discount.clause.percentage is not None:

                return discount.clause.percentage * product.price

            else:

                return discount.clause.price

        discounts = [i for i in discounts if matches(i)]

        discounts.sort(key=value)

        for candidate in reversed(discounts):

            if quantity == 0:

                break

            elif candidate.quantity == 0:

                # This discount clause has been exhausted by this cart

                continue

            # Get a provisional instance for this DiscountItem

            # with the quantity set to as much as we have in the cart

            discount_item = commerce.DiscountItem.objects.create(

                product=product,

                cart=self.cart,

                discount=candidate.discount,

                quantity=quantity,

            )

            # Truncate the quantity for this DiscountItem if we exceed quantity

            ours = discount_item.quantity

            allowed = candidate.quantity

            if ours > allowed:

                discount_item.quantity = allowed

                discount_item.save()

                # Update the remaining quantity.

                quantity = ours - allowed

            else:

                quantity = 0

            candidate.quantity -= discount_item.quantity

import itertools

from django.db.models import Case

from django.db.models import F, Q

from django.db.models import Sum

from django.db.models import Value

from django.db.models import When

from django.utils import timezone

from registrasion.models import commerce

from registrasion.models import conditions

from registrasion.models import inventory

_BIG_QUANTITY = 99999999  # A big quantity

class ConditionController(object):

    ''' Base class for testing conditions that activate Flag

    or Discount objects. '''

    def __init__(self, condition):

        self.condition = condition

    @staticmethod

    def _controllers():

        return {

            conditions.CategoryFlag: CategoryConditionController,

            conditions.IncludedProductDiscount: ProductConditionController,

            conditions.ProductFlag: ProductConditionController,

            conditions.TimeOrStockLimitDiscount:

                TimeOrStockLimitDiscountController,

            conditions.TimeOrStockLimitFlag:

                TimeOrStockLimitFlagController,

            conditions.VoucherDiscount: VoucherConditionController,

            conditions.VoucherFlag: VoucherConditionController,

        }

    @staticmethod

    def for_type(cls):

        return ConditionController._controllers()[cls]

    @staticmethod

    def for_condition(condition):

        try:

            return ConditionController.for_type(type(condition))(condition)

        except KeyError:

            return ConditionController()

    @classmethod

    def pre_filter(cls, queryset, user):

        ''' Returns only the flag conditions that might be available for this

        user. It should hopefully reduce the number of queries that need to be

        executed to determine if a flag is met.

        If this filtration implements the same query as is_met, then you should

        be able to implement ``is_met()`` in terms of this.

        Arguments:

            queryset (Queryset[c]): The canditate conditions.

            user (User): The user for whom we're testing these conditions.

        Returns:

            Queryset[c]: A subset of the conditions that pass the pre-filter

                test for this user.

        '''

        # Default implementation does NOTHING.

        return queryset

    def passes_filter(self, user):

        ''' Returns true if the condition passes the filter '''

        cls = type(self.condition)

        qs = cls.objects.filter(pk=self.condition.id)

        return self.condition in self.pre_filter(qs, user)

    def user_quantity_remaining(self, user, filtered=False):

        ''' Returns the number of items covered by this flag condition the

        user can add to the current cart. This default implementation returns

        a big number if is_met() is true, otherwise 0.

        Either this method, or is_met() must be overridden in subclasses.

        '''

        return _BIG_QUANTITY if self.is_met(user, filtered) else 0

    def is_met(self, user, filtered=False):

        ''' Returns True if this flag condition is met, otherwise returns

        False.

        Either this method, or user_quantity_remaining() must be overridden

        in subclasses.

        Arguments:

            user (User): The user for whom this test must be met.

            filter (bool): If true, this condition was part of a queryset

                returned by pre_filter() for this user.

        '''

        return self.user_quantity_remaining(user, filtered) > 0

class IsMetByFilter(object):

    def is_met(self, user, filtered=False):

        ''' Returns True if this flag condition is met, otherwise returns

        False. It determines if the condition is met by calling pre_filter

        with a queryset containing only self.condition. '''

        if filtered:

            return True  # Why query again?

        return self.passes_filter(user)

class RemainderSetByFilter(object):

    def user_quantity_remaining(self, user, filtered=True):

        ''' returns 0 if the date range is violated, otherwise, it will return

        the quantity remaining under the stock limit.

        The filter for this condition must add an annotation called "remainder"

        in order for this to work.

        '''

        if filtered:

            if hasattr(self.condition, "remainder"):

                return self.condition.remainder

        # Mark self.condition with a remainder

        qs = type(self.condition).objects.filter(pk=self.condition.id)

        qs = self.pre_filter(qs, user)

        if len(qs) > 0:

            return qs[0].remainder

        else:

            return 0

class CategoryConditionController(IsMetByFilter, ConditionController):

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the user has a

        product from a category invoking that item's condition in one of their

        carts. '''

        items = commerce.ProductItem.objects.filter(cart__user=user)

        items = items.exclude(cart__status=commerce.Cart.STATUS_RELEASED)

        items = items.select_related("product", "product__category")

        categories = [item.product.category for item in items]

        return queryset.filter(enabling_category__in=categories)

class ProductConditionController(IsMetByFilter, ConditionController):

    ''' Condition tests for ProductFlag and

    IncludedProductDiscount. '''

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the user has a

        product invoking that item's condition in one of their carts. '''

        items = commerce.ProductItem.objects.filter(cart__user=user)

        items = items.exclude(cart__status=commerce.Cart.STATUS_RELEASED)

        items = items.select_related("product", "product__category")

        products = [item.product for item in items]

        return queryset.filter(enabling_products__in=products)

class TimeOrStockLimitConditionController(

        RemainderSetByFilter,

        ConditionController,

    ):

    ''' Common condition tests for TimeOrStockLimit Flag and

    Discount.'''

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the date falls into

        any specified range, but not yet where the stock limit is not yet

        reached.'''

        now = timezone.now()

        # Keep items with no start time, or start time not yet met.

        queryset = queryset.filter(Q(start_time=None) | Q(start_time__lte=now))

        queryset = queryset.filter(Q(end_time=None) | Q(end_time__gte=now))

        # Filter out items that have been reserved beyond the limits

        quantity_or_zero = self._calculate_quantities(user)

        remainder = Case(

            When(limit=None, then=Value(_BIG_QUANTITY)),

            default=F("limit") - Sum(quantity_or_zero),

        )

        queryset = queryset.annotate(remainder=remainder)

        queryset = queryset.filter(remainder__gt=0)

        return queryset

    @classmethod

    def _relevant_carts(cls, user):

        reserved_carts = commerce.Cart.reserved_carts()

        reserved_carts = reserved_carts.exclude(

            user=user,

            status=commerce.Cart.STATUS_ACTIVE,

        )

        return reserved_carts

class TimeOrStockLimitFlagController(

        TimeOrStockLimitConditionController):

    @classmethod

    def _calculate_quantities(cls, user):

        reserved_carts = cls._relevant_carts(user)

        # Calculate category lines

        reserved_category_products = (

            Q(categories__product__productitem__cart__in=reserved_carts)

        )

        # Calculate product lines

        reserved_products = (

            Q(products=F('products__productitem__product')) &

            Q(products__productitem__cart__in=reserved_carts)

        )

        category_quantity_in_reserved_carts = When(

            reserved_category_products,

            then="categories__product__productitem__quantity",

        )

        product_quantity_in_reserved_carts = When(

            reserved_products,

            then="products__productitem__quantity",

        )

        quantity_or_zero = Case(

            category_quantity_in_reserved_carts,

            product_quantity_in_reserved_carts,

            default=Value(0),

        )

        return quantity_or_zero

class TimeOrStockLimitDiscountController(TimeOrStockLimitConditionController):

    @classmethod

    def _calculate_quantities(cls, user):

        reserved_carts = cls._relevant_carts(user)

        quantity_in_reserved_carts = When(

            discountitem__cart__in=reserved_carts,

            then="discountitem__quantity"

        )

        quantity_or_zero = Case(

            quantity_in_reserved_carts,

            default=Value(0)

        )

        return quantity_or_zero

class VoucherConditionController(IsMetByFilter, ConditionController):

    ''' Condition test for VoucherFlag and VoucherDiscount.'''

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the user has entered

        a voucher that invokes that item's condition in one of their carts. '''

        carts = commerce.Cart.objects.filter(

            user=user,

        )

        vouchers = [cart.vouchers.all() for cart in carts]

        return queryset.filter(voucher__in=itertools.chain(*vouchers))

import itertools

from conditions import ConditionController

from registrasion.models import commerce

from registrasion.models import conditions

from django.db.models import Case

from django.db.models import Q

from django.db.models import Sum

from django.db.models import Value

from django.db.models import When

class DiscountAndQuantity(object):

    ''' Represents a discount that can be applied to a product or category

    for a given user.

    Attributes:

        discount (conditions.DiscountBase): The discount object that the

            clause arises from. A given DiscountBase can apply to multiple

            clauses.

        clause (conditions.DiscountForProduct|conditions.DiscountForCategory):

            A clause describing which product or category this discount item

            applies to. This casts to ``str()`` to produce a human-readable

            version of the clause.

        quantity (int): The number of times this discount item can be applied

            for the given user.

    '''

    def __init__(self, discount, clause, quantity):

        self.discount = discount

        self.clause = clause

        self.quantity = quantity

    def __repr__(self):

        return "(discount=%s, clause=%s, quantity=%d)" % (

            self.discount, self.clause, self.quantity,

        )

class DiscountController(object):

    @classmethod

    def available_discounts(cls, user, categories, products):

        filtered_clauses = cls._filtered_discounts(user, categories, products)

        discounts = []

        accepted_discounts = set()

        failed_discounts = set()

        for clause in filtered_clauses:

            discount = clause.discount

            cond = ConditionController.for_condition(discount)

            past_use_count = discount.past_use_count

            if past_use_count >= clause.quantity:

                # This clause has exceeded its use count

                pass

            elif discount not in failed_discounts:

                # This clause is still available

                    # This clause is valid for this user

                    discounts.append(DiscountAndQuantity(

                        discount=discount,

                        clause=clause,

                        quantity=clause.quantity - past_use_count,

                    ))

                    accepted_discounts.add(discount)

                else:

                    # This clause is not valid for this user

                    failed_discounts.add(discount)

        return discounts

    @classmethod

    def _filtered_discounts(cls, user, categories, products):

        '''

        Returns:

        '''

        types = list(ConditionController._controllers())

        # discounts that match provided categories

        category_discounts = conditions.DiscountForCategory.objects.filter(

            category__in=categories

        )

        # discounts that match provided products

        product_discounts = conditions.DiscountForProduct.objects.filter(

            product__in=products

        )