from django.utils import simplejson
from django.shortcuts import render_to_response, redirect, HttpResponseRedirect
from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext
from django.http import HttpResponse
from django.conf import settings
from django.contrib import messages
from django.db.models import Q
from django.contrib.auth import logout
from django.core.mail import send_mail
from models import *
from worker_fns import user_login

from cloudnine.shop.models import *
from cloudnine.shop.forms import *
from cloudnine.shop.basket import *
from shop.shipping import Shipping

from forms import *

import logging


def trade_home(request):

    data = {'pageclass':'home'}

    return render_to_response('trade/index.html', data, RequestContext(request))

def irons(request):

    logging.debug('iron method called')

    data = {'pageclass':'irons'}

    #Add to basket
    basket = Basket(request)

    #Add all selected products to basket
    if request.method == "POST":
        if int(request.POST['cloud-nine-iron']) > 0:
            product = get_object_or_404(Product, slug="cloud-nine-iron")
            basket.add_item(product, request.POST['cloud-nine-iron'])

        if int(request.POST['trade-cloud-nine-iron']) > 0:
            product = get_object_or_404(Product, slug="trade-cloud-nine-iron")
            basket.add_item(product, request.POST['trade-cloud-nine-iron'])

        if int(request.POST['cloud-nine-wide-iron']) > 0:
            product = get_object_or_404(Product, slug="cloud-nine-wide-iron")
            basket.add_item(product, request.POST['cloud-nine-wide-iron'])

        if int(request.POST['trade-cloud-nine-wide-iron']) > 0:
            product = get_object_or_404(Product, slug="trade-cloud-nine-wide-iron")
            basket.add_item(product, request.POST['trade-cloud-nine-wide-iron'])

        if int(request.POST['cloud-nine-micro-iron']) > 0:
            product = get_object_or_404(Product, slug="cloud-nine-micro-iron")
            basket.add_item(product, request.POST['cloud-nine-micro-iron'])

        if int(request.POST['trade-cloud-nine-micro-iron']) > 0:
            product = get_object_or_404(Product, slug="trade-cloud-nine-micro-iron")
            basket.add_item(product, request.POST['trade-cloud-nine-micro-iron'])

        return HttpResponseRedirect('/basket/')

    cloud_nine_iron = get_object_or_404(Product, slug="cloud-nine-iron")
    cloud_nine_wide_iron = get_object_or_404(Product, slug="cloud-nine-wide-iron")
    cloud_nine_micro_iron = get_object_or_404(Product, slug="cloud-nine-micro-iron")

    trade_cloud_nine_iron = get_object_or_404(Product, slug="trade-cloud-nine-iron")
    trade_cloud_nine_wide_iron = get_object_or_404(Product, slug="trade-cloud-nine-wide-iron")
    trade_cloud_nine_micro_iron = get_object_or_404(Product, slug="trade-cloud-nine-micro-iron")

    data['cloud_nine_iron'] = cloud_nine_iron
    data['cloud_nine_wide_iron'] = cloud_nine_wide_iron
    data['cloud_nine_micro_iron'] = cloud_nine_micro_iron

    data['trade_cloud_nine_iron'] = trade_cloud_nine_iron
    data['trade_cloud_nine_wide_iron'] = trade_cloud_nine_wide_iron
    data['trade_cloud_nine_micro_iron'] = trade_cloud_nine_micro_iron

    return render_to_response('trade/irons.html', data, RequestContext(request))


def wand(request):

    data = {'pageclass':'wand'}

    basket = Basket(request)

    #Add all selected products to basket
    if request.method == "POST":
        if int(request.POST['cloud-nine-wand']) > 0:
            product = get_object_or_404(Product, slug="cloud-nine-wand")
            basket.add_item(product, request.POST['cloud-nine-wand'])
        if int(request.POST['trade-cloud-nine-wand']) > 0:
            product = get_object_or_404(Product, slug="trade-cloud-nine-wand")
            basket.add_item(product, request.POST['trade-cloud-nine-wand'])

        return HttpResponseRedirect('/basket/')

    wand = get_object_or_404(Product, slug="cloud-nine-wand")
    trade_wand = get_object_or_404(Product, slug="trade-cloud-nine-wand")

    data['wand'] = wand
    data['trade_wand'] = trade_wand

    return render_to_response('trade/wand.html', data, RequestContext(request))

def bundles(request):

    data = {'pageclass':'bundles'}

    basket = Basket(request)

    #Add all selected products to basket
    if request.method == "POST":
        if int(request.POST['straightening-tool-kit']) > 0:
            product = get_object_or_404(Product, slug="straightening-tool-kit")
            basket.add_item(product, request.POST['straightening-tool-kit'])

        if int(request.POST['volume-tool-kit']) > 0:
            product = get_object_or_404(Product, slug="volume-tool-kit")
            basket.add_item(product, request.POST['volume-tool-kit'])

        if int(request.POST['styling-tool-kit']) > 0:
            product = get_object_or_404(Product, slug="styling-tool-kit")
            basket.add_item(product, request.POST['styling-tool-kit'])

        return HttpResponseRedirect('/basket/')

    straightening_tool_kit = get_object_or_404(Product, slug="straightening-tool-kit")
    volume_tool_kit = get_object_or_404(Product, slug="volume-tool-kit")
    styling_tool_kit = get_object_or_404(Product, slug="styling-tool-kit")

    data['straightening_tool_kit'] = straightening_tool_kit
    data['volume_tool_kit'] = volume_tool_kit
    data['styling_tool_kit'] = styling_tool_kit

    return render_to_response('trade/bundles.html', data, RequestContext(request))

def theo(request):

    data = {'pageclass':'theo'}

    basket = Basket(request)

    #Add all selected products to basket
    if request.method == "POST":
        if int(request.POST['gift-of-volume']) > 0:
            product = get_object_or_404(Product, slug="gift-of-volume")
            basket.add_item(product, request.POST['gift-of-volume'])
        if int(request.POST['roller20']) > 0:
            product = get_object_or_404(Product, slug="roller20")
            basket.add_item(product, request.POST['roller20'])
        if int(request.POST['roller30']) > 0:
            product = get_object_or_404(Product, slug="roller30")
            basket.add_item(product, request.POST['roller30'])
        if int(request.POST['roller40']) > 0:
            product = get_object_or_404(Product, slug="roller40")
            basket.add_item(product, request.POST['roller40'])
        if int(request.POST['roller50']) > 0:
            product = get_object_or_404(Product, slug="roller50")
            basket.add_item(product, request.POST['roller50'])
        if int(request.POST['roller60']) > 0:
            product = get_object_or_404(Product, slug="roller60")
            basket.add_item(product, request.POST['roller60'])
        if int(request.POST['theo-clip-size1']) > 0:
            product = get_object_or_404(Product, slug="theo-clip-size1")
            basket.add_item(product, request.POST['theo-clip-size1'])
        if int(request.POST['theo-clip-size2']) > 0:
            product = get_object_or_404(Product, slug="theo-clip-size2")
            basket.add_item(product, request.POST['theo-clip-size2'])
        if int(request.POST['theo']) > 0:
            product = get_object_or_404(Product, slug="theo")
            basket.add_item(product, request.POST['theo'])
        if int(request.POST['amplify']) > 0:
            product = get_object_or_404(Product, slug="amplify")
            basket.add_item(product, request.POST['amplify'])

        return HttpResponseRedirect('/basket/')

    theo = get_object_or_404(Product, slug="theo")
    roller20 = get_object_or_404(Product, slug="roller20")
    roller30 = get_object_or_404(Product, slug="roller30")
    roller40 = get_object_or_404(Product, slug="roller30")
    roller50 = get_object_or_404(Product, slug="roller50")
    roller60 = get_object_or_404(Product, slug="roller60")
    theo_clip_size1 = get_object_or_404(Product, slug="theo-clip-size1")
    theo_clip_size2 = get_object_or_404(Product, slug="theo-clip-size2")
    gift_of_volume = get_object_or_404(Product, slug="gift-of-volume")
    amplify = get_object_or_404(Product, slug="amplify")

    data['theo'] = theo
    data['roller20'] = roller20
    data['roller30'] = roller30
    data['roller40'] = roller40
    data['roller50'] = roller50
    data['roller60'] = roller60
    data['theo_clip_size1'] = theo_clip_size1
    data['theo_clip_size2'] = theo_clip_size2
    data['gift_of_volume'] = gift_of_volume
    data['amplify'] = amplify

    return render_to_response('trade/theo.html', data, RequestContext(request))

def get_the_look_beach_waves(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-beach-waves.html', data, RequestContext(request))

def get_the_look_the_crimp(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-the-crimp.html', data, RequestContext(request))

def get_the_look_kinky_straight(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-kinky-straight.html', data, RequestContext(request))

def get_the_look_super_sleek(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-super-sleek.html', data, RequestContext(request))

def get_the_look_hollywood_glam(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-hollywood-glam.html', data, RequestContext(request))

def get_the_look_the_shag(request):

    data = {'pageclass':'get-the-look-popup'}

    return render_to_response('trade/gtl-the-shag.html', data, RequestContext(request))

def video_beach_waves(request):

    data = {'pageclass':'video-popup'}

    return render_to_response('trade/video-beach-waves.html', data, RequestContext(request))

def video_the_crimp(request):

    data = {'pageclass':'video-popup'}

    return render_to_response('trade/video-beach-waves.html', data, RequestContext(request))

def video_kinky_straight(request):

    data = {'pageclass':'video-popup'}

    return render_to_response('trade/video-beach-waves.html', data, RequestContext(request))

def terms(request):

    data = {'pageclass':'terms'}

    return render_to_response('trade/terms.html', data, RequestContext(request))

def privacy(request):

    data = {'pageclass':'privacy'}

    return render_to_response('trade/privacy.html', data, RequestContext(request))

def user_logout(request):
    if request.user.is_authenticated():
        logout(request)

    return redirect(settings.LOGIN_URL)

def register(request, state="login"):
    from reg_forms import AddressForm

    data = {}

    data = {'pageclass':'login'}

    data['state'] = state

    # base reg form
    reg_form = None
    terms_form = None
    salon_form = None
    salon_form2 = None
    student_form = None
    freelance_form = None
    salon_owner_form = None
    login_form = None

    if request.method == "POST":

        if 'login_form' in request.POST:
            form = LoginForm(request.POST)

            if form.is_valid():
                logged_in, message = user_login(form.cleaned_data['username'], form.cleaned_data['password'], request)

                if not logged_in:
                    data['login_message'] = message
                else:
                    return redirect("/")
            else:
                data['login_message'] = "Invalid username and/or password"
        else:
            import pdb
            #pdb.set_trace()
            reg_form = RegistrationForm(request.POST)
            terms_form = TermsForm(request.POST)

            form_ok = reg_form.is_valid() and terms_form.is_valid()

            try:
                reg_type = int(request.POST['reg_type'])
            except (ValueError, KeyError,):
                reg_type = None

            if reg_type:
                if reg_type == 1:
                    # salon stylist
                    salon_form = SalonSalonForm(request.POST)
                    salon_form2 = AddressForm(request.POST)

                    form_ok = form_ok and salon_form.is_valid() and salon_form2.is_valid()

                elif reg_type == 2:
                    # salon owner
                    salon_owner_form = SalonOwnerForm(request.POST)

                    form_ok = form_ok and salon_owner_form.is_valid()

                elif reg_type == 3:
                    # freelance
                    freelance_form = FreelanceRegForm(request.POST)

                    form_ok = form_ok and freelance_form.is_valid()

                elif reg_type == 4:
                    # student
                    student_form = StudentRegForm(request.POST)

                    form_ok = form_ok and student_form.is_valid()

                else:
                    raise Exception("invalid reg type %d" % reg_type)


            if form_ok:
                user = User()
                user.username = reg_form.cleaned_data['username']
                user.set_password( reg_form.cleaned_data['password'] )
                user.first_name = reg_form.cleaned_data['first_name']
                user.last_name = reg_form.cleaned_data['last_name']
                user.email = reg_form.cleaned_data['email']
                user.is_active = False
                user.save()

                account = Account_trade()
                account.user = user

                # these fields need to be given default values:
                account.telephone = ''
                account.how_heard = ''
                account.feedback = ''
                account.security_answer = ''

                account.profession = reg_type
                account.opt_in = False
                account.dob = reg_form.cleaned_data['birthdate']
                account.temporary=False

                account.save()

                if reg_type == 1:
                    # salon stylist
                    add1 = create_address( salonform.cleaned_data, account )
                    add1.name = salonform.cleaned_data['name']
                    add1.type = 1
                    add1.save()

                    add2 = create_address( salonform2.cleaned_data, account )
                    add2.type = 2
                    add2.save()
                elif reg_type == 2:
                    # salon owner
                    add1 = create_address( salon_owner_form.cleaned_data, account )
                    add1.type = 1
                    add1.save()
                elif reg_type == 3:
                    # freelance stylist
                    add1 = create_address( freelance_form.cleaned_data, account )
                    add1.type = 1

                    add1.save()
                elif reg_type == 4:
                    # student stylist
                    add1 = create_address( student_form.cleaned_data, account )
                    add1.type = 2
                    add1.save()

                    # add in student stylist fields
                    account.college = student_form.cleaned_data['college']
                    account.course_name = student_form.cleaned_data['course_name']
                    account.qualification = student_form.cleaned_data['qualification']

                #account.default_address = add1
                account.save()

                # dispatch emails
                email_body = "A new registration has been placed on trade.cloudninehair.com for user %s.\n\nPlease review." % user.get_full_name()
                send_mail('New User Registration - Please Review', email_body, 'admin@cloudninehair.com', \
                            ['lyndon@antlyn.com'], fail_silently=False)

                # redirect to /registration/success/
                return redirect('register_success')

    data['reg_form'] = reg_form or RegistrationForm()
    data['student_form'] = student_form or StudentRegForm()
    data['freelance_form'] = freelance_form or FreelanceRegForm()
    data['salon_form'] = salon_form or SalonSalonForm()
    data['salon_personal_form'] = salon_form2 or AddressForm()
    data['salon_owner_form'] = salon_owner_form or SalonOwnerForm()
    data['terms_form'] = terms_form or TermsForm()
    data['login_form'] = login_form or LoginForm()

    return render_to_response('registration.html',data, RequestContext(request))

def create_address( fields, account ):
    """ small helper function to populate the address model """
    address = Address_trade()
    address.line1 = fields['address_1']
    address.line2 = fields['address_2']
    address.line3 = fields['address_3']
    address.city = fields['city']
    address.country = Country.objects.get(pk=fields['country'])
    address.postcode = fields['postcode']
    address.telephone = fields['telephone']
    address.account = account

    return address

def myaccount(request):
    data = {}
    return render_to_response('myaccount.html', data, RequestContext(request))

def myaddresses(request):
    data = {}
    data['addresses'] = Address_trade.objects.filter(account__user=request.user)
    new_address_form = None
    edit_address_form = None

    edit_id = request.GET.get('edit', None)

    if edit_id:
        # load edit form with data for this record
        try:
            edit_id = int(edit_id)
            edit_obj = Address_trade.objects.get(account__user=request.user, pk=edit_id)
        except (ValueError, Address_trade.DoesNotExist):
            edit_id = None
        else:
            initial = {}
            edit_address_form = AddressForm2(initial=initial)


    if request.method == "POST":
        if 'add_new' in request.POST:
            new_address_form = AddressForm2(request.POST)

            if new_address_form.is_valid():
                messages.add_message(request, messages.INFO, 'New Address Saved')
                add = Address_trade()

            else:
                pass

        elif 'edit' in request.POST:
            messages.add_message(request, messages.INFO, 'Address details updated')
        elif 'delete' in request.POST:
            messages.add_message(request, messages.INFO, 'Address details deleted')

    data['edit_id'] = edit_id
    data['edit_address_form'] = edit_address_form or AddressForm2()
    data['new_address_form'] = new_address_form or AddressForm2()
    return render_to_response('myaddresses.html', data, RequestContext(request))


def myorders(request):
    data = {}
    return render_to_response('myorders.html', data, RequestContext(request))

def basket_trade(request):
    """
    Display the current state of the basket and allow the customer to modify
    the discount and quantities of each row of the basket
    """
    data = {}

    basket = Basket(request)
    discount_form = DiscountCodeForm()

    if request.method == "POST":
        if 'update' in request.POST:

            try:
                basket.post_update(request)
            except:
                pass

            discount_form = DiscountCodeForm(request.POST)
            if discount_form.is_valid():

                cleaned_data = discount_form.cleaned_data
                if cleaned_data['discount_code']:
                    try:
                        o = Offer.objects.get(code=cleaned_data['discount_code'])
                    except:
                        data['discount_message'] = "You entered an invalid discount code."
                    else:

                        if o.uses == 0 or Order.objects.filter(offer=o).count() < o.uses:
                            basket.set_discount(o)
                        else:
                            data['discount_message'] = "Coupon has been used too many times or has expired."
                            basket.remove_discount()        #just in case

        if 'delete' in request.POST:

            basket.post_delete(request)

        if 'remove_discount' in request.POST:

            basket.remove_discount()
    else:
        basket = Basket(request)

    data['discount_form'] = discount_form
    #data['logged_in'] = persistent_account(request)
    data['pageclass'] = 'basket'
    data['category'] = Category.objects.root_category()
    category = get_object_or_404(Category, slug='products')
    products = category.products.all().order_by('-weight')
    data['products'] = products.filter(type="standard")
    data['regions'] = Zone.objects.all()
    data['currency'] = Currency.get_default_currency()

    return render_to_response('trade/basket.html', data, RequestContext(request))

def xhr_basket_review(request):
    """ View retrieves the checkout page right side panel basket in json format """

    data = {}

    if request.is_ajax():
        try:
            shipping_country = int( request.GET.get('country_id', None) or request.session.get('country_id', 1) )
        except ValueError:
            shipping_country = 1

        try:
            country = Country.objects.get(pk=shipping_country)
        except Country.DoesNotExist:
            return HttpResponse("We have an invalid country code")
        else:
            request.session['country_id'] = shipping_country

            basket = Basket(request, delivery_country=country.iso_code.lower())

            data['postage'] = str(basket.get_postage_cost())
            data['vat'] = ''
            data['subtotal'] = str(basket.subtotal)
            data['total'] = str(basket.total)

            return HttpResponse(simplejson.dumps(data), 'application/javascript')
    else:
        return HttpResponse(status=400)

def checkout_trade(request):

    payment_options = ('sagepay','eft',)

    import uuid, datetime
    basket = Basket(request)
    data = {}
    data = {'pageclass':'checkout'}
    showdelivery = "False"
    submitted = False
    del_address = False
    mailing = ""
    gender = False

    billing_details_form = None
    billing_form = None
    contact_details_form = None
    delivery_form = None
    terms_form = None
    payment_form = None
    billing_address_form = get_address_form(request)(request.POST or None)
    shipping_address_form = get_address_form(request, 'shipping')(request.POST or None)
    dispatch_customer_form = None

    max_addresses = getattr(settings,'MAX_SAVED_ADDRESSES', None)
    if max_addresses and Address_trade.objects.filter(account=request.user.get_profile()).count() >= max_addresses:
        address_save = False
    else:
        address_save = True

    request.session['payment'] = "sagepay"

    if request.method == 'POST':
        import pdb
        #pdb.set_trace()

        billing_address_form.is_valid()
        shipping_address_form.is_valid()

        billing_address_id = billing_address_form.cleaned_data['address']
        shipping_address_id = shipping_address_form.cleaned_data['address']
        billing_form = None
        delivery_form = None

        forms_valid = True

        if billing_address_id == "enter":
            # is the address form valid?
            billing_form = BillingAddressForm(request.POST, add_save_field=address_save)

            forms_valid = forms_valid and billing_form.is_valid()
        else:
            # sanity check - is the address record owned by this user? If not, and as it's an unlikely scenario and probably evidence of tempering,
            # allow the DoesNotExist or ValueError exception to propogate and break the page
            billing_address_id = int(billing_address_id)
            Address_trade.objects.get(account=request.user.get_profile(), pk=billing_adress_id)

        if shipping_address_id == "same":
            # same as the billing address
            pass
        elif shipping_address_id == "enter":
            delivery_form = ShippingAddressForm(request.POST, add_save_field=address_save)
            forms_valid = forms_valid and shipping_form.is_valid()
        else:
            # another sanity check - make sure the record exists and is owned by the user, otherwise let it break the page
            shipping_address_id = int(shipping_address_id)
            Address_trade.objects.get(account=request.uesr.get_profile(), pk=shipping_address_id)

        payment_form = PaymentForm(request.POST)
        dispatch_customer_form = DispatchToCustomerForm(request.POST)
        terms_form = TermsForm(request.POST)
        billing_details_form = BillingDetailsForm(request.POST)
        contact_details_form = ContactDetailsForm(request.POST)

        forms_valid = forms_valid and payment_form.is_valid() and dispatch_customer_form.is_valid() and terms_form.is_valid() and billing_details_form.is_valid() and contact_details_form.is_valid()

        if forms_valid:

            if 'order_id' in request.session:
                try:
                    order_id = int(request.session['order_id'])
                    order = Order.objects.get(pk=order_id)
                    for item in OrderItem.objects.filter(order=order):
                        item.delete()

                except (Order.DoesNotExist, ValueError):
                    del request.session['order_id']
                    order_id = None
            else:
                order = Order()

            # make the order
            order.billing_dob =
            order.billing_gender =
            order.billing_phone =
            order.email =
            order.billing_first_name =
            order.billing_last_name =
            order.billing_line_1 =
            order.billing_line_2 =
            order.billing_line_3 =
            order.billing_city =
            order.billing_state =
            order.billing_county =
            order.billing_postcode =
            order.billing_country =

            order.delivery_first_name =
            order.delivery_last_name =
            order.delivery_line_1 =
            order.delivery_line_2 =
            order.delivery_line_3
            order.delivery_city =
            order.delivery_state =
            order.delivery_county =
            order.delivery_postcode =
            order.delivery_country =

            order.account = request.user.get_profile()
            order.status = 100  # 100 = not authorised

            order.delivery_address = self.delivery_address
            order.delivery_instructions = self.delivery_instructions
            order.payment = payment
            order.offer = self.discount

            currency = Currency.objects.all()[0]

            order.payment_currency = currency #self.account.gateway_currency
            order.selected_currency = currency #self.account.currency

            order.payment_exchange_rate = 1 #currency #self.account.gateway_currency.exchange_rate
            order.selected_exchange_rate = 1 #currency #self.account.currency.exchange_rate

            order.payment_method = method

            order.raw_total = basket.get_raw_total(False)
            order.subtotal = basket.get_subtotal(False)
            order.postage_cost = basket.get_postage_cost(False)
            order.postage_description = basket.get_postage_description()
            order.total = basket.get_total(False)

            from decimal import Decimal

            tax_mult = 1.0 + (countrysettings.tax_rate / 100)

            subtotal = self.get_subtotal(False)

            order.tax = str(round(order.subtotal - (order.subtotal/(1+(Decimal(repr(countrysettings.tax_rate)) / 100))),2))
            order.tax_rate = repr(countrysettings.tax_rate)

            order.save()

            request.session['order_id'] = order.id

            for item in basket.items:
                order_item = OrderItem()
                order_item.order = order
                order_item.product = item.item
                order_item.quantity = item.quantity
                order_item.product_name = item.item.name
                order_item.price = item.item.price
                #calculate tax on the item level

                order_item.save()

            # add the free gift promotional items separately

            for promo in basket§.promos:
                order_item = OrderItem()
                order_item.order = order
                order_item.product_id = None
                order_item.product_name = promo['free_gift_title']
                order_item.quantity = promo['quantity']
                order_item.price = 0
                order_item.save()

            # take payment

            # get the shipping and billing addresses and pass these in to protx

            # if payment is OK

            payment_processor = PaymentProcessor()

            payment_processor.do_request(payment_form, basket, request)
            if not payment_processor.valid_result:
                messages.add_message(request, messages.ERROR, payment_processor.statusdetail)
            else:
                payment = payment_processor.get_payment_object()
                payment.save()

                order = basket.create_order(payment)

                oc = OrderConfirmation(order)
                oc.send_admin_html()
                oc.send_customer_html()



            return render_to_response('trade/checkout.html', data, RequestContext(request))

    data['showdelivery'] = showdelivery

    data['billing_details_form'] = billing_details_form or BillingDetailsForm()
    data['address_form'] = billing_form or BillingAddressForm(add_save_field=address_save)
    data['delivery_form'] = delivery_form or ShippingAddressForm(add_save_field=address_save)
    data['terms_form'] = terms_form or TermsForm()
    data['payment_form'] = payment_form or PaymentForm()
    data['contact_details_form'] = contact_details_form or ContactDetailsForm()
    data['billing_address_form'] = billing_address_form
    data['shipping_address_form'] = shipping_address_form
    data['dispatch_customer'] = dispatch_customer_form or DispatchToCustomerForm()

    return render_to_response('trade/checkout.html', data, RequestContext(request))