from __future__ import unicode_literals

import util

import datetime

import itertools

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.contrib.auth.models import User

from django.db import models

from django.db.models import F, Q

from django.utils import timezone

from django.utils.encoding import python_2_unicode_compatible

from django.utils.translation import ugettext_lazy as _

from model_utils.managers import InheritanceManager

# User models

@python_2_unicode_compatible

class Attendee(models.Model):

    ''' Miscellaneous user-related data. '''

    def __str__(self):

        return "%s" % self.user

    @staticmethod

    def get_instance(user):

        ''' Returns the instance of attendee for the given user, or creates

        a new one. '''

        try:

            return Attendee.objects.get(user=user)

        except ObjectDoesNotExist:

            return Attendee.objects.create(user=user)

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

        while not self.access_code:

            access_code = util.generate_access_code()

            if Attendee.objects.filter(access_code=access_code).count() == 0:

                self.access_code = access_code

        return super(Attendee, self).save(*a, **k)

    user = models.OneToOneField(User, on_delete=models.CASCADE)

    # Badge/profile is linked

    access_code = models.CharField(

        max_length=6,

        unique=True,

        db_index=True,

    )

    completed_registration = models.BooleanField(default=False)

class AttendeeProfileBase(models.Model):

    ''' Information for an attendee's badge and related preferences.

    Subclass this in your Django site to ask for attendee information in your

    registration progess.

     '''

    objects = InheritanceManager()

    @classmethod

    def name_field(cls):

        ''' This is used to pre-fill the attendee's name from the

        speaker profile. If it's None, that functionality is disabled. '''

        return None

    def invoice_recipient(self):

        ''' Returns a representation of this attendee profile for the purpose

        of rendering to an invoice. Override in subclasses. '''

        # Manual dispatch to subclass. Fleh.

        slf = AttendeeProfileBase.objects.get_subclass(id=self.id)

        # Actually compare the functions.

        if type(slf).invoice_recipient != type(self).invoice_recipient:

            return type(slf).invoice_recipient(slf)

        # Return a default

        return slf.attendee.user.username

    attendee = models.OneToOneField(Attendee, on_delete=models.CASCADE)

# Inventory Models

@python_2_unicode_compatible

class Category(models.Model):

    ''' Registration product categories '''

    class Meta:

        verbose_name_plural = _("categories")

    def __str__(self):

        return self.name

    RENDER_TYPE_RADIO = 1

    RENDER_TYPE_QUANTITY = 2

    CATEGORY_RENDER_TYPES = [

        (RENDER_TYPE_RADIO, _("Radio button")),

        (RENDER_TYPE_QUANTITY, _("Quantity boxes")),

    ]

    name = models.CharField(

        max_length=65,

        verbose_name=_("Name"),

    )

    description = models.CharField(

        max_length=255,

        verbose_name=_("Description"),

    )

    limit_per_user = models.PositiveIntegerField(

        null=True,

        blank=True,

        verbose_name=_("Limit per user"),

        help_text=_("The total number of items from this category one "

                    "attendee may purchase."),

    )

    required = models.BooleanField(

        blank=True,

        help_text=_("If enabled, a user must select an "

                    "item from this category."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

        db_index=True,

    )

    render_type = models.IntegerField(

        choices=CATEGORY_RENDER_TYPES,

        verbose_name=_("Render type"),

        help_text=_("The registration form will render this category in this "

                    "style."),

    )

@python_2_unicode_compatible

class Product(models.Model):

    ''' Registration products '''

    def __str__(self):

        return "%s - %s" % (self.category.name, self.name)

    name = models.CharField(

        max_length=65,

        verbose_name=_("Name"),

    )

    description = models.CharField(

        max_length=255,

        verbose_name=_("Description"),

        null=True,

        blank=True,

    )

    category = models.ForeignKey(

        Category,

        verbose_name=_("Product category")

    )

    price = models.DecimalField(

        max_digits=8,

        decimal_places=2,

        verbose_name=_("Price"),

    )

    limit_per_user = models.PositiveIntegerField(

        null=True,

        blank=True,

        verbose_name=_("Limit per user"),

    )

    reservation_duration = models.DurationField(

        default=datetime.timedelta(hours=1),

        verbose_name=_("Reservation duration"),

        help_text=_("The length of time this product will be reserved before "

                    "it is released for someone else to purchase."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

        db_index=True,

    )

@python_2_unicode_compatible

from registrasion import models as rego

from registrasion.controllers.category import CategoryController

from collections import namedtuple

from django import template

from django.db.models import Sum

register = template.Library()

ProductAndQuantity = namedtuple("ProductAndQuantity", ["product", "quantity"])

@register.assignment_tag(takes_context=True)

def available_categories(context):

    ''' Returns all of the available product categories '''

    return CategoryController.available_categories(context.request.user)

@register.assignment_tag(takes_context=True)

def invoices(context):

    ''' Returns all of the invoices that this user has. '''

    return rego.Invoice.objects.filter(cart__user=context.request.user)

@register.assignment_tag(takes_context=True)

def items_pending(context):

    ''' Returns all of the items that this user has in their current cart,

    and is awaiting payment. '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=True,

    return all_items

@register.assignment_tag(takes_context=True)

def items_purchased(context, category=None):

    ''' Returns all of the items that this user has purchased, optionally

    from the given category. '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=False,

        cart__released=False,

    ).select_related("product", "product__category")

    if category:

        all_items = all_items.filter(product__category=category)

    pq = all_items.values("product").annotate(quantity=Sum("quantity")).all()

    products = rego.Product.objects.all()

    out = []

    for item in pq:

        prod = products.get(pk=item["product"])

        out.append(ProductAndQuantity(prod, item["quantity"]))

    return out

@register.filter

def multiply(value, arg):

    ''' Multiplies value by arg '''

    return value * arg

import sys

from registrasion import forms

from registrasion import models as rego

from registrasion.controllers import discount

from registrasion.controllers.cart import CartController

from registrasion.controllers.invoice import InvoiceController

from registrasion.controllers.product import ProductController

from registrasion.exceptions import CartValidationError

from collections import namedtuple

from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.contrib import messages

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.http import Http404

from django.shortcuts import get_object_or_404

from django.shortcuts import redirect

from django.shortcuts import render

GuidedRegistrationSection = namedtuple(

    "GuidedRegistrationSection",

    (

        "title",

        "discounts",

        "description",

        "form",

    )

)

GuidedRegistrationSection.__new__.__defaults__ = (

    (None,) * len(GuidedRegistrationSection._fields)

)

def get_form(name):

    dot = name.rindex(".")

    mod_name, form_name = name[:dot], name[dot + 1:]

    __import__(mod_name)

    return getattr(sys.modules[mod_name], form_name)

@login_required

def guided_registration(request, page_id=0):

    ''' Goes through the registration process in order,

    making sure user sees all valid categories.

    WORK IN PROGRESS: the finalised version of this view will allow

    grouping of categories into a specific page. Currently, it just goes

    through each category one by one

    '''

    next_step = redirect("guided_registration")

    sections = []

    attendee = rego.Attendee.get_instance(request.user)

    if attendee.completed_registration:

        return render(

            request,

            "registrasion/guided_registration_complete.html",

            {},

        )

    # Step 1: Fill in a badge and collect a voucher code

    try:

        profile = attendee.attendeeprofilebase

    except ObjectDoesNotExist:

        profile = None

    if not profile:

        # TODO: if voucherform is invalid, make sure

        # that profileform does not save

        voucher_form, voucher_handled = handle_voucher(request, "voucher")

        profile_form, profile_handled = handle_profile(request, "profile")

        voucher_section = GuidedRegistrationSection(

            title="Voucher Code",

            form=voucher_form,

        )

        profile_section = GuidedRegistrationSection(

            title="Profile and Personal Information",

            form=profile_form,

        )

        title = "Attendee information"

        current_step = 1

        sections.append(voucher_section)

        sections.append(profile_section)

    else:

        # We're selling products

        # Get the next category

        cats = rego.Category.objects

            # Only display the first Category

            title = "Select ticket type"

            current_step = 2

            cats = [cats[0]]

        else:

            # Set title appropriately for remaining categories

            current_step = 3

            title = "Additional items"

        all_products = rego.Product.objects.filter(

            category__in=cats,

        ).select_related("category")

        available_products = set(ProductController.available_products(

            request.user,

            products=all_products,

        ))

        for category in cats:

            products = [

                i for i in available_products

                if i.category == category

            ]

            prefix = "category_" + str(category.id)

            p = handle_products(request, category, products, prefix)

            products_form, discounts, products_handled = p

            section = GuidedRegistrationSection(

                title=category.name,

                description=category.description,

                discounts=discounts,

                form=products_form,

            )

            if products:

                sections.append(section)

    if sections and request.method == "POST":

        for section in sections:

            if section.form.errors:

                break

        else:

            attendee.save()

            # We've successfully processed everything

            return next_step

    data = {

        "current_step": current_step,

        "sections": sections,

        "title": title,

        "total_steps": 3,

    }

    return render(request, "registrasion/guided_registration.html", data)

@login_required

def edit_profile(request):

    form, handled = handle_profile(request, "profile")

    if handled and not form.errors:

        messages.success(

            request,

            "Your attendee profile was updated.",

        )

        return redirect("dashboard")

    data = {

        "form": form,

    }

    return render(request, "registrasion/profile_form.html", data)

def handle_profile(request, prefix):

    ''' Returns a profile form instance, and a boolean which is true if the

    form was handled. '''

    attendee = rego.Attendee.get_instance(request.user)

    try:

        profile = attendee.attendeeprofilebase

        profile = rego.AttendeeProfileBase.objects.get_subclass(pk=profile.id)

    except ObjectDoesNotExist:

        profile = None

    ProfileForm = get_form(settings.ATTENDEE_PROFILE_FORM)

    # Load a pre-entered name from the speaker's profile,

    # if they have one.

    try:

        speaker_profile = request.user.speaker_profile

        speaker_name = speaker_profile.name

    except ObjectDoesNotExist:

        speaker_name = None

    name_field = ProfileForm.Meta.model.name_field()

    initial = {}

    if profile is None and name_field is not None:

        initial[name_field] = speaker_name

    form = ProfileForm(

        request.POST or None,

        initial=initial,

        instance=profile,

        prefix=prefix

    )

    handled = True if request.POST else False

    if request.POST and form.is_valid():

        form.instance.attendee = attendee

        form.save()

    return form, handled

@login_required

def product_category(request, category_id):

    ''' Registration selections form for a specific category of items.

    '''

    PRODUCTS_FORM_PREFIX = "products"

    VOUCHERS_FORM_PREFIX = "vouchers"

    # Handle the voucher form *before* listing products.

    # Products can change as vouchers are entered.

    v = handle_voucher(request, VOUCHERS_FORM_PREFIX)

    voucher_form, voucher_handled = v

    category_id = int(category_id)  # Routing is [0-9]+

    category = rego.Category.objects.get(pk=category_id)

    products = ProductController.available_products(

        request.user,

        category=category,

    )

    if not products:

        messages.warning(

            request,

            "There are no products available from category: " + category.name,

        )

        return redirect("dashboard")

    p = handle_products(request, category, products, PRODUCTS_FORM_PREFIX)

    products_form, discounts, products_handled = p

    if request.POST and not voucher_handled and not products_form.errors:

        # Only return to the dashboard if we didn't add a voucher code

        # and if there's no errors in the products form

        messages.success(

            request,

            "Your reservations have been updated.",

        )

        return redirect("dashboard")

    data = {

        "category": category,

        "discounts": discounts,

        "form": products_form,

        "voucher_form": voucher_form,

    }

    return render(request, "registrasion/product_category.html", data)

def handle_products(request, category, products, prefix):

    ''' Handles a products list form in the given request. Returns the

    form instance, the discounts applicable to this form, and whether the

    contents were handled. '''

    current_cart = CartController.for_user(request.user)