import collections

import datetime

import functools

import itertools

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from .flag import FlagController

from .product import ProductController

def _modifies_cart(func):

    ''' Decorator that makes the wrapped function raise ValidationError

    @functools.wraps(func)

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

        self._fail_if_cart_is_not_active()

    return inner

class CartController(object):

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

        ''' 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 product_max is not None:

            reservations.append(product_max)

        self.cart.time_last_updated = timezone.now()

        self.cart.reservation_duration = max(reservations)

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

        product changes/voucher applications etc.

        '''

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

                    product=product,

                    quantity=quantity,

                )

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

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

            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?

                )

        if errors:

            raise ValidationError(errors)

    @_modifies_cart

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

        not_available = products - available

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

        self.set_quantities(zeros)

    @transaction.atomic

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

    @classmethod

    def for_cart(cls, cart):

        ''' Returns an invoice object for a given cart at its current revision.

        If such an invoice does not exist, the cart is validated, and if valid,

        an invoice is generated.'''

        try:

            invoice = commerce.Invoice.objects.exclude(

                status=commerce.Invoice.STATUS_VOID,

            ).get(

                cart=cart,

                cart_revision=cart.revision,

    @classmethod

    @transaction.atomic

    def _generate(cls, cart):

        ''' Generates an invoice for the given cart. '''

        issued = timezone.now()

        reservation_limit = cart.reservation_duration + cart.time_last_updated

        # Never generate a due time that is before the issue time

        due = max(issued, reservation_limit)

        # Get the invoice recipient

        self.invoice.status = commerce.Invoice.STATUS_VOID

        self.invoice.save()

    def _invoice_matches_cart(self):

        ''' Returns true if there is no cart, or if the revision of this

        invoice matches the current revision of the cart. '''

        cart = self.invoice.cart

        if not cart:

            return True

        return cart.revision == self.invoice.cart_revision