import string

from django.utils.crypto import get_random_string

def generate_access_code():

    ''' Generates an access code for users' payments as well as their

    fulfilment code for check-in.

    The access code will 4 characters long, which allows for 1,500,625

    unique codes, which really should be enough for anyone. '''

    length = 4

    # all upper-case letters + digits 1-9 (no 0 vs O confusion)

    chars = string.uppercase + string.digits[1:]

    # 4 chars => 35 ** 4 = 1500625 (should be enough for anyone)

    return get_random_string(length=length, allowed_chars=chars)

def all_arguments_optional(ntcls):

    ''' Takes a namedtuple derivative and makes all of the arguments optional.

    '''

    ntcls.__new__.__defaults__ = (

        (None,) * len(ntcls._fields)

    )

    return ntcls

    Returns:

        redirect or render:

            In the case of a ``POST`` request, it'll redirect to ``dashboard``,

            or otherwise, it will render ``registrasion/profile_form.html``

            with data::

                {

                    "form": form,  # Instance of ATTENDEE_PROFILE_FORM.

                }

    '''

    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 = people.Attendee.get_instance(request.user)

    try:

        profile = attendee.attendeeprofilebase

        profile = people.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):

    ''' Form for selecting products from an individual product category.

    Arguments:

        category_id (castable to int): The id of the category to display.

    Returns:

        redirect or render:

            If the form has been sucessfully submitted, redirect to

            ``dashboard``. Otherwise, render

            ``registrasion/product_category.html`` with data::

                {

                    "category": category,         # An inventory.Category for

                                                  # category_id

                    "discounts": discounts,       # A list of

                                                  # DiscountAndQuantity

                    "form": products_form,        # A form for selecting

                                                  # products

                    "voucher_form": voucher_form, # A form for entering a

                                                  # voucher code

                }

    '''

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

    ProductsForm = forms.ProductsForm(category, products)

    # Create initial data for each of products in category

    items = commerce.ProductItem.objects.filter(

        product__in=products,

        cart=current_cart.cart,

    ).select_related("product")

    quantities = []

    seen = set()

    for item in items:

        quantities.append((item.product, item.quantity))

        seen.add(item.product)

    zeros = set(products) - seen

    for product in zeros:

        quantities.append((product, 0))

    products_form = ProductsForm(

        request.POST or None,

        product_quantities=quantities,

        prefix=prefix,

    )

    if request.method == "POST" and products_form.is_valid():

        if products_form.has_changed():

            _set_quantities_from_products_form(products_form, current_cart)

        # If category is required, the user must have at least one

        # in an active+valid cart

        if category.required:

            carts = commerce.Cart.objects.filter(user=request.user)

            items = commerce.ProductItem.objects.filter(

                product__category=category,

                cart=carts,

            )

            if len(items) == 0:

                products_form.add_error(

                    None,

                    "You must have at least one item from this category",

                )

    handled = False if products_form.errors else True

        request.user,

        [],

        products,

    )

    return products_form, discounts, handled

def _set_quantities_from_products_form(products_form, current_cart):

    quantities = list(products_form.product_quantities())

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

    products = inventory.Product.objects.filter(

        id__in=pks,

    ).select_related("category")

    product_quantities = [

        (products.get(pk=i[0]), i[1]) for i in quantities

    ]

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

    voucher_form = forms.VoucherForm(request.POST or None, prefix=prefix)

    current_cart = CartController.for_user(request.user)

    if (voucher_form.is_valid() and

            voucher_form.cleaned_data["voucher"].strip()):

        voucher = voucher_form.cleaned_data["voucher"]

        voucher = inventory.Voucher.normalise_code(voucher)

        if len(current_cart.cart.vouchers.filter(code=voucher)) > 0:

            # This voucher has already been applied to this cart.

            # Do not apply code

            handled = False

        else:

            try:

                current_cart.apply_voucher(voucher)

            except Exception as e:

                voucher_form.add_error("voucher", e)

            handled = True

    else:

        handled = False

    return (voucher_form, handled)

@login_required

def checkout(request):

    ''' Runs the checkout process for the current cart.

    If the query string contains ``fix_errors=true``, Registrasion will attempt

    to fix errors preventing the system from checking out, including by

    cancelling expired discounts and vouchers, and removing any unavailable

    products.

    Returns:

        render or redirect:

            If the invoice is generated successfully, or there's already a

            valid invoice for the current cart, redirect to ``invoice``.

            If there are errors when generating the invoice, render

            ``registrasion/checkout_errors.html`` with the following data::

                {

                    "error_list", [str, ...]  # The errors to display.

                }

    '''

    current_cart = CartController.for_user(request.user)

    if "fix_errors" in request.GET and request.GET["fix_errors"] == "true":

        current_cart.fix_simple_errors()

    try:

        current_invoice = InvoiceController.for_cart(current_cart.cart)

    except ValidationError as ve:

        return _checkout_errors(request, ve)

    return redirect("invoice", current_invoice.invoice.id)

def _checkout_errors(request, errors):

    error_list = []

    for error in errors.error_list:

        if isinstance(error, tuple):

            error = error[1]

        error_list.append(error)

    data = {

        "error_list": error_list,

    }

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

def invoice_access(request, access_code):

    ''' Redirects to an invoice for the attendee that matches the given access

    code, if any.

    If the attendee has multiple invoices, we use the following tie-break:

    - If there's an unpaid invoice, show that, otherwise

    - If there's a paid invoice, show the most recent one, otherwise

    - Show the most recent invoid of all

    Arguments:

        access_code (castable to int): The access code for the user whose

            invoice you want to see.

    Returns:

        redirect:

            Redirect to the selected invoice for that user.

    Raises:

        Http404: If the user has no invoices.

    '''

    invoices = commerce.Invoice.objects.filter(

        user__attendee__access_code=access_code,

    ).order_by("-issue_time")

    if not invoices:

        raise Http404()

    unpaid = invoices.filter(status=commerce.Invoice.STATUS_UNPAID)

    paid = invoices.filter(status=commerce.Invoice.STATUS_PAID)

    if unpaid:

        invoice = unpaid[0]  # (should only be 1 unpaid invoice?)

    elif paid:

        invoice = paid[0]  # Most recent paid invoice

    else:

        invoice = invoices[0]  # Most recent of any invoices

    return redirect("invoice", invoice.id, access_code)

def invoice(request, invoice_id, access_code=None):

    ''' Displays an invoice.

    This view is not authenticated, but it will only allow access to either:

    the user the invoice belongs to; staff; or a request made with the correct

    access code.

    Arguments:

        invoice_id (castable to int): The invoice_id for the invoice you want

            to view.

        access_code (Optional[str]): The access code for the user who owns

            this invoice.

    Returns:

        render:

            Renders ``registrasion/invoice.html``, with the following

            data::

                {

                    "invoice": models.commerce.Invoice(),

                }

    Raises:

        Http404: if the current user cannot view this invoice and the correct

            access_code is not provided.

    '''

    current_invoice = InvoiceController.for_id_or_404(invoice_id)