import forms
import models

from django.core.exceptions import ValidationError
from django.conf import settings
from django.contrib import messages
from django.db import transaction
from django.http import HttpResponse
from django.shortcuts import redirect, render

from registrasion.controllers.invoice import InvoiceController
from registrasion.models import commerce

from pinax.stripe import actions
from stripe.error import StripeError

from symposion.conference.models import Conference

CURRENCY = settings.INVOICE_CURRENCY
CONFERENCE_ID = settings.CONFERENCE_ID


def pubkey_script(request):
    ''' Returns a JS snippet that sets the Stripe public key for Stripe.js. '''

    script_template = "Stripe.setPublishableKey('%s');"
    script = script_template % settings.PINAX_STRIPE_PUBLIC_KEY

    return HttpResponse(script, content_type="text/javascript")


def card(request, invoice_id):

    form = forms.CreditCardForm(request.POST or None)

    inv = InvoiceController.for_id_or_404(str(invoice_id))

    if not inv.can_view(user=request.user):
        raise Http404()

    to_invoice = redirect("invoice", inv.invoice.id)

    if request.POST and form.is_valid():
        try:
            inv.validate_allowed_to_pay()  # Verify that we're allowed to do this.
            process_card(request, form, inv)
            return to_invoice
        except StripeError as e:
            form.add_error(None, ValidationError(e))
        except ValidationError as ve:
            form.add_error(None, ve)

    data = {
        "invoice": inv.invoice,
        "form": form,
    }

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


@transaction.atomic
def process_card(request, form, inv):
    ''' Processes the given credit card form

    Arguments:
        request: the current request context
        form: a CreditCardForm
        inv: an InvoiceController
    '''

    conference = Conference.objects.get(id=CONFERENCE_ID)
    amount_to_pay = inv.invoice.balance_due()

    token = form.cleaned_data["stripe_token"]

    customer = actions.customers.get_customer_for_user(request.user)

    if not customer:
        customer = actions.customers.create(request.user)

    card = actions.sources.create_card(customer, token)

    description="Payment for %s invoice #%s" % (
        conference.title, inv.invoice.id
    )

    try:
        charge = actions.charges.create(
            amount_to_pay,
            customer,
            currency=CURRENCY,
            description=description,
            capture=False,
        )

        receipt = charge.stripe_charge.receipt_number
        if not receipt:
            receipt = charge.stripe_charge.id
        reference = "Paid with Stripe receipt number: " + receipt

        # Create the payment object
        models.StripePayment.objects.create(
            invoice=inv.invoice,
            reference=reference,
            amount=charge.amount,
            charge=charge,
        )
    except StripeError as e:
        raise e
    finally:
        # Do not actually charge the account until we've reconciled locally.
        actions.charges.capture(charge)

    inv.update_status()

    messages.success(request, "This invoice was successfully paid.")