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)

        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

            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:

    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(

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,

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

        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,

        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)

        passed_limits = set(

            product

            for product in all_products

            if cat_quants[product.category].remainder > 0

            if prod_quants[product].remainder > 0

        )

        failed_and_messages = FlagController.test_flags(

            user, products=passed_limits

        )

        failed_conditions = set(i[0] for i in failed_and_messages)

        out = list(passed_limits - failed_conditions)

        out.sort(key=lambda product: product.order)

        return out

    @classmethod

    def attach_user_remainders(cls, user, products):

        '''

        Return:

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

            ``product``, with an extra attribute -- remainder = the amount of

            this item that is remaining.

        '''

        ids = [product.id for product in products]

        products = inventory.Product.objects.filter(id__in=ids)

        cart_filter = (

            Q(productitem__cart__user=user) &

            Q(productitem__cart__status=commerce.Cart.STATUS_PAID)

        )

        quantity = When(

            cart_filter,

            then='productitem__quantity'

        )

        quantity_or_zero = Case(

    handled = False if products_form.errors else True

    # Making this a function to lazily evaluate when it's displayed

    # in templates.

    discounts = util.lazy(

        DiscountController.available_discounts,

        request.user,

        [],

        products,

    )

    return products_form, discounts, handled

def _set_quantities_from_products_form(products_form, current_cart):

    quantities = list(products_form.product_quantities())

    id_to_quantity = dict(i[:2] for i in quantities)

    pks = [i[0] for i in quantities]

    products = inventory.Product.objects.filter(

        id__in=pks,

    ).select_related("category")

    product_quantities = [

        (product, id_to_quantity[product.id]) for product in products

    ]

    field_names = dict(

        (i[0][0], i[1][2]) for i in zip(product_quantities, quantities)

    )

    try:

        current_cart.set_quantities(product_quantities)

    except CartValidationError as ve:

        for ve_field in ve.error_list:

            product, message = ve_field.message

            if product in field_names:

                field = field_names[product]

            elif isinstance(product, inventory.Product):

                continue

            else:

                field = None

            products_form.add_error(field, message)

def _handle_voucher(request, prefix):

    ''' Handles a voucher form in the given request. Returns the voucher

    form instance, and whether the voucher code was handled. '''