import collections

import contextlib

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.db.models import Q

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 .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.

    It also wraps the execution of this function in a database transaction,

    and marks the boundaries of a cart operations batch.

    '''

    @functools.wraps(func)

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

        self._fail_if_cart_is_not_active()

        with transaction.atomic():

            with CartController.operations_batch(self.cart.user) as mark:

                mark.mark = True  # Marker that we've modified the cart

                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)

    # Marks the carts that are currently in batches

    _FOR_USER = {}

    _BATCH_COUNT = collections.defaultdict(int)

    _MODIFIED_CARTS = set()

    class _ModificationMarker(object):

        pass

    @classmethod

    @contextlib.contextmanager

    def operations_batch(cls, user):

        ''' Marks the boundary for a batch of operations on a user's cart.

        These markers can be nested. Only on exiting the outermost marker will

        a batch be ended.

        When a batch is ended, discounts are recalculated, and the cart's

        revision is increased.

        '''

        if user not in cls._FOR_USER:

            _ctrl = cls.for_user(user)

            cls._FOR_USER[user] = (_ctrl, _ctrl.cart.id)

        ctrl, _id = cls._FOR_USER[user]

        cls._BATCH_COUNT[_id] += 1

        try:

            success = False

            marker = cls._ModificationMarker()

            yield marker

            if hasattr(marker, "mark"):

                cls._MODIFIED_CARTS.add(_id)

            success = True

        finally:

            cls._BATCH_COUNT[_id] -= 1

            # Only end on the outermost batch marker, and only if

            # it excited cleanly, and a modification occurred

            modified = _id in cls._MODIFIED_CARTS

            outermost = cls._BATCH_COUNT[_id] == 0

            if modified and outermost and success:

                ctrl._end_batch()

                cls._MODIFIED_CARTS.remove(_id)

            # Clear out the cache on the outermost operation

            if outermost:

                del cls._FOR_USER[user]

    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.")

    def _autoextend_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)

    def _end_batch(self):

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

        product changes/voucher applications etc.

        You need to call this after you've finished modifying the user's cart.

        This is normally done by wrapping a block of code using

        ``operations_batch``.

        '''

        self.cart.refresh_from_db()

        self._recalculate_discounts()

        self._autoextend_reservation()

        self.cart.revision += 1

        self.cart.save()

    @_modifies_cart

    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)

        new_items = []

        products = []

        for product, quantity in product_quantities:

            products.append(product)

            if quantity == 0:

                continue

            item = commerce.ProductItem(

                cart=self.cart,

                product=product,

                quantity=quantity,

            )

            new_items.append(item)

        to_delete = (

            Q(quantity=0) |

            Q(product__in=products)

        )

        items_in_cart.filter(to_delete).delete()

        commerce.ProductItem.objects.bulk_create(new_items)

    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 = []

        # Pre-annotate products

        products = [p for (p, q) in product_quantities]

        r = ProductController.attach_user_remainders(self.cart.user, products)

        with_remainders = dict((p, p) for p in r)

        # Test each product limit here

        for product, quantity in product_quantities:

            if quantity < 0:

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

            limit = with_remainders[product].remainder

            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))

        # Pre-annotate categories

        r = CategoryController.attach_user_remainders(self.cart.user, by_cat)

        with_remainders = dict((cat, cat) for cat in r)

        # Test each category limit here

        for category in by_cat:

            limit = with_remainders[category].remainder

            # 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)

    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)

from registrasion.models import commerce

from registrasion.models import inventory

from django.db.models import Case

from django.db.models import F, Q

from django.db.models import Sum

from django.db.models import When

from django.db.models import Value

class AllProducts(object):

    pass

class CategoryController(object):

    def __init__(self, category):

        self.category = category

    @classmethod

    def available_categories(cls, user, products=AllProducts):

        ''' Returns the categories available to the user. Specify `products` if

        you want to restrict to just the categories that hold the specified

        products, otherwise it'll do all. '''

        # STOPGAP -- this needs to be elsewhere tbqh

        from product import ProductController

        if products is AllProducts:

            products = inventory.Product.objects.all().select_related(

                "category",

            )

        available = ProductController.available_products(

            user,

            products=products,

        )

        return set(i.category for i in available)

    @classmethod

    def attach_user_remainders(cls, user, categories):

        '''

        Return:

            queryset(inventory.Product): A queryset containing items from

            ``categories``, with an extra attribute -- remainder = the amount

            of items from this category that is remaining.

        '''

        ids = [category.id for category in categories]

        categories = inventory.Category.objects.filter(id__in=ids)

        cart_filter = (

            Q(product__productitem__cart__user=user) &

            Q(product__productitem__cart__status=commerce.Cart.STATUS_PAID)

        )

        quantity = When(

            cart_filter,

            then='product__productitem__quantity'

        )

        quantity_or_zero = Case(

            quantity,

            default=Value(0),

        )

        remainder = Case(

            When(limit_per_user=None, then=Value(99999999)),

            default=F('limit_per_user') - Sum(quantity_or_zero),

        )

        categories = categories.annotate(remainder=remainder)

        return categories

    def user_quantity_remaining(self, user):

        ''' Returns the quantity of this product that the user add in the

        current cart. '''

        with_remainders = self.attach_user_remainders(user, [self.category])

        return with_remainders[0].remainder

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

_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. '''

        in_user_carts = Q(

            enabling_category__product__productitem__cart__user=user

        )

        released = commerce.Cart.STATUS_RELEASED

        in_released_carts = Q(

            enabling_category__product__productitem__cart__status=released

        )

        queryset = queryset.filter(in_user_carts)

        queryset = queryset.exclude(in_released_carts)

        return queryset

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. '''

        in_user_carts = Q(enabling_products__productitem__cart__user=user)

        released = commerce.Cart.STATUS_RELEASED

        in_released_carts = Q(

            enabling_products__productitem__cart__status=released

        )

        queryset = queryset.filter(in_user_carts)

        queryset = queryset.exclude(in_released_carts)

        return queryset

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):

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 F, 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):

        ''' Returns all discounts available to this user for the given

        categories and products. The discounts also list the available quantity

        for this user, not including products that are pending purchase. '''

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

        discounts = []

        # Markers so that we don't need to evaluate given conditions

        # more than once

        accepted_discounts = set()

        failed_discounts = set()

        for clause in filtered_clauses:

            discount = clause.discount

            cond = ConditionController.for_condition(discount)

            past_use_count = clause.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

                is_accepted = discount in accepted_discounts

                if is_accepted or cond.is_met(user, filtered=True):

                    # 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:

            Sequence[discountbase]: All discounts that passed the filter

            function.

        '''

        types = list(ConditionController._controllers())

        discounttypes = [

            i for i in types if issubclass(i, conditions.DiscountBase)

        ]

        # 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

        )

        # discounts that match categories for provided products

        product_category_discounts = conditions.DiscountForCategory.objects

        product_category_discounts = product_category_discounts.filter(

            category__in=(product.category for product in products)

        )

        # (Not relevant: discounts that match products in provided categories)

        product_discounts = product_discounts.select_related(

            "product",

            "product__category",

        )

        all_category_discounts = (

            category_discounts | product_category_discounts

        )

        all_category_discounts = all_category_discounts.select_related(

            "category",

        )

        valid_discounts = conditions.DiscountBase.objects.filter(

            Q(discountforproduct__in=product_discounts) |

            Q(discountforcategory__in=all_category_discounts)

        )

        all_subsets = []

        for discounttype in discounttypes:

            discounts = discounttype.objects.filter(id__in=valid_discounts)

            ctrl = ConditionController.for_type(discounttype)

            discounts = ctrl.pre_filter(discounts, user)

            all_subsets.append(discounts)

        filtered_discounts = list(itertools.chain(*all_subsets))

        # Map from discount key to itself

        # (contains annotations needed in the future)

        from_filter = dict((i.id, i) for i in filtered_discounts)

        clause_sets = (

            product_discounts.filter(discount__in=filtered_discounts),

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 When

from django.db.models import Value

from registrasion.models import commerce

from registrasion.models import inventory

from .category import CategoryController

from .flag import FlagController

class ProductController(object):

    def __init__(self, product):

        self.product = product

    @classmethod

    def available_products(cls, user, category=None, products=None):

        ''' Returns a list of all of the products that are available per

        flag conditions from the given categories. '''

        if category is None and products is None:

            raise ValueError("You must provide products or a category")

        if category is not None:

            all_products = inventory.Product.objects.filter(category=category)

            all_products = all_products.select_related("category")

        else:

            all_products = []

        if products is not None:

            all_products = set(itertools.chain(all_products, products))

        categories = set(product.category for product in all_products)

        r = CategoryController.attach_user_remainders(user, categories)

        cat_quants = dict((c, c) for c in r)

        r = ProductController.attach_user_remainders(user, all_products)

        prod_quants = dict((p, p) for p in r)