#Django core bits
from django.shortcuts import render, render_to_response, get_object_or_404
from django.template import RequestContext, loader, Context
from django.contrib.auth.decorators import login_required, permission_required
from django.db.models import Q
from django.contrib.sites.models import Site
from django.conf import settings
from django.http import HttpResponseRedirect, Http404, HttpResponse
from django.core.urlresolvers import reverse
from django.contrib import messages
from django.contrib.auth.models import User, Group
from django.template.defaultfilters import slugify
from django.core.mail import EmailMessage
from django.views.decorators.csrf import csrf_exempt

from datetime import datetime,date,time

import pdfcrowd

#models
from modules.pages.models import *
from modules.blocks.models import *
from modules.resources.models import Resource

from modules.payments.models import *
from modules.payments.functions import *

from models import *
from forms import *
from functions import *
from signals import *

from modules.core.functions import *

from modules.blocks.models import *

def register(request):

    if request.user.is_authenticated():
        messages.error(request,'Sorry, you are already logged in.')
        return HttpResponseRedirect(reverse('account_home'))

    try:
        content_block = ContentBlock.objects.get(slug='registration-form-intro')
    except:
        content_block = False

    try:
        country = Country.objects.get(name='United Kingdom')
    except:
        country = False

    registration_form_user = RegistrationFormUser()
    registration_form_password = RegistrationFormPassword()
    registration_form_personal = RegistrationFormPersonal()
    registration_form_member_type = RegistrationFormMemberType()
    registration_form_hospital = RegistrationFormHospital()
    registration_form_personal_address = RegistrationFormPersonalAddress(initial={'country':country})
    registration_form_are_trainee = RegistrationFormAreTrainee()
    registration_form_training = RegistrationFormTraining()
    registration_form_professional = RegistrationFormProfessional()
    registration_form_professional.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)
    registration_form_support = RegistrationFormSupport()
    registration_form_terms = RegistrationFormTerms()

    if request.POST:

        registration_form_user = RegistrationFormUser(request.POST)
        registration_form_password = RegistrationFormPassword(request.POST)
        registration_form_personal = RegistrationFormPersonal(request.POST)
        registration_form_member_type = RegistrationFormMemberType(request.POST)
        registration_form_hospital = RegistrationFormHospital(request.POST)
        registration_form_personal_address = RegistrationFormPersonalAddress(request.POST)
        registration_form_are_trainee = RegistrationFormAreTrainee(request.POST)
        registration_form_training = RegistrationFormTraining(request.POST)
        registration_form_professional = RegistrationFormProfessional(request.POST)
        registration_form_professional.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)
        registration_form_support = RegistrationFormSupport(request.POST, request.FILES)
        registration_form_terms = RegistrationFormTerms(request.POST)

        member = register_member(request,True)
        if member:

            member.unique_key = random_string_unique(100,Member,'unique_key')
            member.membership_number = get_next_membership_number()
            member.save()

            request.session['member_key'] = member.unique_key

            return HttpResponseRedirect(reverse('register_payment'))

    return render(request,'public/registration/register.html',{'content_block':content_block,'registration_form_user':registration_form_user,'registration_form_password':registration_form_password,'registration_form_personal':registration_form_personal,'registration_form_member_type':registration_form_member_type,'registration_form_hospital':registration_form_hospital,'registration_form_personal_address':registration_form_personal_address,'registration_form_are_trainee':registration_form_are_trainee,'registration_form_training':registration_form_training,'registration_form_professional':registration_form_professional,'registration_form_support':registration_form_support,'registration_form_terms':registration_form_terms})

def register_payment(request):

    member = False
    if request.session.get('member_key',False):
        try:
            member = Member.objects.get(unique_key=request.session['member_key'])
        except Member.DoesNotExist():
            pass

    if not member:
        messages.error(request,'Sorry, could not find the current applicant.')
        return HttpResponseRedirect(reverse('register'))

    if member.complete:
        del request.session['member_key']
        messages.warning(request,'You have already completed your membership application')
        return HttpResponseRedirect(reverse('register'))

    try:
        content_block  = ContentBlock.objects.get(slug='registration-payment')
    except:
        content_block = False

    payment_amount = member.get_registration_fee()

    payment = Payment(member=member,type='registration')
    payment.save()

    if settings.DEVELOPMENT:
        payment.invoice = "%s_Member_Registration_%s_DEV" % (settings.WEBSITE_CODE,payment.id)
    else :
        payment.invoice = "%s_Member_Registration_%s" % (settings.WEBSITE_CODE,payment.id)
    payment.save()

    secret_key = settings.WORLD_PAY_SECRET_KEY
    installation_id = settings.WORLD_PAY_INSTALLATION_ID
    redirect_url = "%s%s" % (settings.PAYMENT_URL,reverse('register_payment_process'))
    string = "%s:%s:%s:GBP:%s:%s" % (secret_key,installation_id,payment_amount,payment.invoice,redirect_url)
    import hashlib
    encrypted_string = hashlib.md5(string).hexdigest()

    """
    if request.POST:
        #process other payments
        if request.POST.get('payment_method'):
            payment_method = request.POST['payment_method']
            member.payment_type = payment_method
            member.complete = True
            member.save()

            #create
            registration_completed.send(sender=None,request=request,member=member)
            if member.referrer_key:
                registration_member_referrers.send(sender=None,request=request,member=member)

            return HttpResponseRedirect(reverse('register_complete'))"""

    return render_to_response('public/registration/payment.html',{'member':member,'content_block':content_block,'payment':payment,'payment_amount':payment_amount,'redirect_url':redirect_url,'encrypted_string':encrypted_string},context_instance=RequestContext(request))

@csrf_exempt
def register_payment_process(request):

    if not request.POST:
        raise Http404

    callbackPW                              = request.POST.get('callbackPW', '')
    transStatus                             = request.POST.get('transStatus', '')
    authAmount                              = request.POST.get('authAmount', '')
    cartId                                  = request.POST.get('cartId', '')

    payment = get_object_or_404(Payment,invoice=cartId)

    errors = []
    error = False

    if not callbackPW or not transStatus or not authAmount or not cartId:
        error = True
        errors.append('Missing a Required Variable')

    if callbackPW != settings.WORLD_PAY_PASSWORD:
        error = True
        errors.append('World Pay Password Incorrect')

    if not errors:
        if transStatus == 'Y':

            if payment.status == 'pending':

                payment.status = 'complete'
                payment.amount = authAmount
                payment.save()

                #process payment
                today = date.today()
                year = today.year
                expiry_date  = date(year+1,today.month,today.day)

                member = payment.member
                member.paid = True
                member.complete = True
                member.save()

                receipt_name = '%s Membership Subscription (%s)' % (settings.WEBSITE_NAME,today.strftime('%B %Y'))
                receipt = Receipt(member=member,name=receipt_name,start_date=today,amount_paid=payment.amount,payment_type='Credit Card')
                receipt.unique_key = random_string_unique(20,Receipt,'unique_key')
                receipt.save()

                try:
                    client = pdfcrowd.Client("calmdigital", "dc33e7c4525620565185d0a00d90b8f0")
                    client.setPageMargins('50','50','0','50')
                    client.setFooterHtml('<p style="font-size:12px; text-align:center;">The Society for Vascular Technology of Great Britain and Ireland %s</p>' % (date.today().strftime('%d/%m/%Y')))
                    output_file = open(os.path.join(settings.MEDIA_ROOT, 'members/receipts/membership_payment_%s.pdf' % (receipt.id)), 'wb')
                    html = render_to_string('members/receipts/view-receipt-pdf.html',{'receipt':receipt})
                    client.convertHtml(html,output_file)
                    output_file.close()

                    receipt.file = 'members/receipts/membership_payment_%s.pdf' % (receipt.id)
                    receipt.save()
                except:
                    pass

                registration_payment_completed.send(sender=None,member=member,receipt=receipt,payment=payment)
                if member.referrer_key:
                    registration_member_referrers.send(sender=None,member=member)

                notification = UserActivity(member=member,type='account-notification',title='Membership Payment Complete',text='You have succesfully paid for your membership registration. <br/>Visit <a href="%s">My Receipts</a> to view your receipt.' % (reverse('my_receipts')))
                notification.save()

            next = "%s%s" % (settings.URL,reverse('register_payment_complete'))
        else:
            payment.status = 'rejected'
            payment.save()
            next = "%s%s" % (settings.URL,reverse('register_payment_failure'))
    else:
        payment.status = 'rejected'
        payment.save()
        next = "%s%s" % (settings.URL,reverse('register_payment_failure'))

    return render(request,'public/registration/payment-redirect.html',{'next':next})

@csrf_exempt
def register_payment_complete(request):

    try:
        content_block  = ContentBlock.objects.get(slug='registration-payment-complete')
    except:
        content_block = False

    return render_to_response('public/registration/payment-complete.html',{'content_block':content_block},context_instance=RequestContext(request))

@csrf_exempt
def register_payment_failure(request):

    try:
        content_block = ContentBlock.objects.get(slug='registration-payment-failure')
    except:
        content_block = False

    return render_to_response('public/registration/payment-failure.html',{'content_block':content_block},context_instance=RequestContext(request))


def payment_invoice(request):

    member = False
    if request.session.get('member_key',False):
        try:
            member = Member.objects.get(unique_key=request.session['member_key'])
        except Member.DoesNotExist():
            pass

    if not member:
        messages.error(request,'Sorry, could not find the current applicant.')
        return HttpResponseRedirect(reverse('register'))

    if member.complete:
        messages.warning(request,'Your details have already been sent for approval.')
        return HttpResponseRedirect(reverse('register'))

    try:
        content_block  = ContentBlock.objects.get(slug='registration-invoice')
    except:
        content_block = False

    invoice_form = RegistrationFormInvoice(instance=member)

    if request.POST:

        invoice_form = RegistrationFormInvoice(request.POST,instance=member)

        if invoice_form.is_valid():

            #try:
            invoice_form.save()
            member.complete = True
            member.payment_type = 'Invoice'
            member.save()

            #signal to confirm invoice
            registration_invoice_completed.send(sender=None,request=request,member=member)
            if member.referrer_key:
                registration_member_referrers.send(sender=None,request=request,member=member)

            return HttpResponseRedirect(reverse('register_payment_invoice_complete'))

            #except:
            #messages.error(request,'Could not process the form, please try again')

    return render_to_response('public/registration/payment-invoice.html',{'content_block':content_block,'invoice_form':invoice_form},context_instance=RequestContext(request))

def payment_invoice_complete(request):

    member = False
    if request.session.get('member_key',False):
        try:
            member = Member.objects.get(unique_key=request.session['member_key'])
        except Member.DoesNotExist():
            pass

    if not member:
        messages.error(request,'Sorry, could not find the current applicant.')
        return HttpResponseRedirect(reverse('register'))

    try:
        content_block  = ContentBlock.objects.get(slug='registration-invoice-complete')
    except:
        content_block = False

    return render_to_response('public/registration/payment-invoice-complete.html',{'content_block':content_block},context_instance=RequestContext(request))


def register_complete(request):

    member = False
    if request.session.get('member_key',False):
        try:
            member = Member.objects.get(unique_key=request.session['member_key'],complete=True)
        except Member.DoesNotExist():
            pass

    if not member:
        messages.error(request,'Sorry, could not find the current applicant.')
        return HttpResponseRedirect(reverse('register'))

    try:
        content_block  = ContentBlock.objects.get(slug='registration-complete')
    except:
        content_block = False

    return render_to_response('public/registration/registration-complete.html',{'content_block':content_block},context_instance=RequestContext(request))

def referrer_confirm(request,referrer_key):

    try:
        content_block = ContentBlock.objects.get(slug='registration-referrer-confirm')
    except:
        content_block = False

    slot = False
    member = False

    try:
        member = Member.objects.get(referrer_key=referrer_key)
        member.referrer_approved = True
        member.save()
    except Member.DoesNotExist:
        try:
            member = Member.objects.get(referrer2_key=referrer_key)
            member.referrer2_approved = True
            member.save()

        except Member.DoesNotExist:
            #second approver
            return render_to_response('public/registration/referrer-not-found.html',{},context_instance=RequestContext(request))

    return render_to_response('public/registration/referrer-confirm.html',{'content_block':content_block},context_instance=RequestContext(request))