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.

    '''

            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.

        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

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

                    )

                ))

        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)

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

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

            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)

        )

        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)

    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