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

    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:

        # 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

        )

        # discounts that match categories for provided products

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

            discounts = cls._annotate_with_past_uses(discounts, user)

            all_subsets.append(discounts)

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

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

        # The set of all potential discounts

        discount_clauses = set(itertools.chain(

            product_discounts.filter(discount__in=filtered_discounts),

            all_category_discounts.filter(discount__in=filtered_discounts),

        ))

        # Replace discounts with the filtered ones

        # These are the correct subclasses (saves query later on), and have

        # correct annotations from filters if necessary.

        for clause in discount_clauses:

            clause.discount = from_filter[clause.discount.id]

        return discount_clauses

    @classmethod

    def _annotate_with_past_uses(cls, queryset, user):

        ''' Annotates the queryset with a usage count for that discount by the

        given user. '''

        past_use_quantity = When(

            (

                Q(discountitem__cart__user=user) &

                Q(discountitem__cart__status=commerce.Cart.STATUS_PAID)

            ),

            then="discountitem__quantity",

        )

        past_use_quantity_or_zero = Case(

            past_use_quantity,

            default=Value(0),

        )

        return queryset

            if f.dif > 0 and f.dif != dif_count[product]:

                do_not_disable[product] = False

                if product not in messages:

                    messages[product] = "Some disable-if-false " \

                                        "conditions were not met"

            if f.eit > 0 and product not in do_enable:

                do_enable[product] = False

                if product not in messages:

                    messages[product] = "Some enable-if-true " \

                                        "conditions were not met"

        for product in itertools.chain(do_not_disable, do_enable):

            f = total_flags.get(product)

            if product in do_enable:

                # If there's an enable-if-true, we need need of those met too.

                # (do_not_disable will default to true otherwise)

                valid[product] = do_not_disable[product] and do_enable[product]

            elif product in do_not_disable:

                # If there's a disable-if-false condition, all must be met

                valid[product] = do_not_disable[product]

        error_fields = [

            (product, messages[product])

            for product in valid if not valid[product]

        ]

        return error_fields

    @classmethod

    def _filtered_flags(cls, user, products):

        '''

        Returns:

            Sequence[flagbase]: All flags that passed the filter function.

        '''

        types = list(ConditionController._controllers())

        flagtypes = [i for i in types if issubclass(i, conditions.FlagBase)]

        # Get all flags for the products and categories.

        prods = (

            product.flagbase_set.all()

            for product in products

        )

        cats = (

            category.flagbase_set.all()

            for category in set(product.category for product in products)

        )

        all_flags = reduce(operator.or_, itertools.chain(prods, cats))

        all_subsets = []

        for flagtype in flagtypes:

            flags = flagtype.objects.filter(id__in=all_flags)

            ctrl = ConditionController.for_type(flagtype)

            flags = ctrl.pre_filter(flags, user)

            all_subsets.append(flags)

        return itertools.chain(*all_subsets)

ConditionAndRemainder = namedtuple(

    "ConditionAndRemainder",

    (

        "condition",

        "remainder",

    ),

)

_FlagCounter = namedtuple(

    "_FlagCounter",

    (

        "products",

        "categories",

    ),

)

_ConditionsCount = namedtuple(

    "ConditionsCount",

    (

        "dif",

        "eit",

    ),

)

class FlagCounter(_FlagCounter):

    @classmethod

    def count(cls):

        # Get the count of how many conditions should exist per product

        flagbases = conditions.FlagBase.objects

        keys = ("eit", "dif")

        flags = [

            for condition_type in types

        ]

        cats = defaultdict(lambda: defaultdict(int))

        prod = defaultdict(lambda: defaultdict(int))

        for key, flagcounts in zip(keys, flags):

            for row in flagcounts:

                if row["products"] is not None:

                    prod[row["products"]][key] = row["count"]

                if row["categories"] is not None:

                    cats[row["categories"]][key] = row["count"]

        return cls(products=prod, categories=cats)

    def get(self, product):

        p = self.products[product.id]

        c = self.categories[product.category.id]

        eit = p["eit"] + c["eit"]

        dif = p["dif"] + c["dif"]

        return _ConditionsCount(dif=dif, eit=eit)