# -*- coding: utf-8 -*-

from __future__ import absolute_import

import cStringIO as StringIO

import csv

# django

from django.conf import settings

from django.shortcuts import render_to_response

from django.template.loader import render_to_string

from django.shortcuts import get_object_or_404

from django.template import RequestContext

from django.core.urlresolvers import reverse

from django.http import HttpResponse

from django.contrib.auth.decorators import login_required

from django.contrib.auth.forms import AuthenticationForm

from django.contrib.auth.models import User

from django.core.exceptions import ObjectDoesNotExist

#kiwipycon

from project.kiwipycon.utils import set_message_cookie

from project.kiwipycon.utils import slugify

from project.kiwipycon.user.models import UserProfile

from project.kiwipycon.user.utils import kiwipycon_createregistrant

from project.kiwipycon.user.forms import RegistrantForm

from project.kiwipycon.sponsor.models import Sponsor

from project.kiwipycon.talk.models import Talk

from .models import Registration

from .models import Wifi

from .forms import RegistrationSubmitForm

from .forms import RegistrationEditForm

from .forms import RegistrationAdminSelectForm

from .forms import WifiForm

from .utils import send_confirmation

from .forms import IC

REG_TOTAL = 1000

@login_required

def download_csv(request,

        template_name = 'registration/download-csv.html'):

    """

    """

    if not request.user.is_staff:

        redirect_to = reverse('kiwipycon_login')

    if request.method == "POST":

        form = RegistrationAdminSelectForm(request.POST)

        if form.is_valid():

            conference = form.cleaned_data['by_conference']

            tutorial = form.cleaned_data['by_tutorial']

            sprint = form.cleaned_data['by_sprint']

            amount = form.cleaned_data['by_amount']

            tshirt = form.cleaned_data['by_tshirt']

            order_by = form.cleaned_data['order_by']

            include = form.cleaned_data['include']

            q = Registration.objects.all()

            if conference == 'conference':

                q = q.filter(conference=True)

            elif conference == 'no conference':

                q = q.filter(conference=False)

            elif tutorial == 'tutorial':

                q = q.filter(tutorial=True)

            elif tutorial == 'no tutorial':

                q = q.filter(tutorial=False)

            if sprint == 'sprint':

                q = q.filter(sprint=True)

            if sprint == 'no sprint':

                q = q.filter(sprint=False)

            elif tshirt != 'all':

                q = q.filter(tshirt=tshirt)

            q = q.order_by('registrant__email')

            query = q.query

            results = list(q)

            if include == []:

                # default to include all fields

                include = [i[0] for i in IC]

            if results:

                response = HttpResponse(mimetype='text/csv')

                response['Content-Disposition'] = 'attachment; filename=registrations.csv'

                output = csv.writer(response)

                output.writerow([h for h in include])

                for row in results:

                    conference = row.conference == True and 'yes' or 'no'

                    tutorial = row.tutorial == True and 'yes' or 'no'

                    sprint = row.sprint == True and 'yes' or 'no'

                    wrow = []

                    if 'Name' in include:

                        wrow.append(

                            row.registrant.get_full_name().encode('utf-8'))

                    if 'Email' in include:

                        wrow.append(row.registrant.email.encode('utf-8'))

                    if 'Organisation' in include:

                        wrow.append(row.organisation.encode('utf-8'))

                    if 'Conference' in include:

                        wrow.append(conference)

                    if 'Tutorial' in include:

                        wrow.append(tutorial)

                    if 'Sprint' in include:

                        wrow.append(sprint)

                    if 'T-size' in include:

                        wrow.append(row.tshirt)

                    output.writerow(wrow)

                return response

            else:

                no_results = u'No results found for the query'

    else:

        form = RegistrationAdminSelectForm()

    return render_to_response(template_name, RequestContext(request,

        locals()))

# NOT REQUIRED FOR SciPy.in

@login_required

def invoice(request, template_name='registration/invoice.html'):

    user = request.user

    registration = get_object_or_404(Registration, registrant=user)

    if registration.sponsor:

        redirect_to = reverse('kiwipycon_account')

        return set_message_cookie(redirect_to,

                msg = u'You are a sponsored guest, no payment required.')

    return render_to_response(template_name, RequestContext(request,

        {'registration' : registration, 'user': user}))

@login_required

def pdf_invoice(request, template_name='registration/invoice.html'):

    user = request.user

    registration = get_object_or_404(Registration, registrant=user)

    if registration.sponsor:

        redirect_to = reverse('kiwipycon_account')

        return set_message_cookie(redirect_to,

                msg = u'You are a sponsored guest, no payment required.')

    content = render_to_string(template_name,

        {'registration' : registration, 'user': user})

    result = StringIO.StringIO()

    import ho.pisa

    pdf = ho.pisa.pisaDocument(StringIO.StringIO(content.encode("UTF-8")),result)

    if not pdf.err:

        return HttpResponse(result.getvalue(), mimetype='application/pdf')

    return HttpResponse("Gremlins ate your invoice, please try html" \

        " version")

def registrations(request,

        template_name='registration/registrations.html'):

    """Simple page to count registrations"""

    #registrations = Registration.objects.filter(payment=True).count()

    registrations = Registration.objects.all().count()

    return render_to_response(template_name, RequestContext(request,

        {

        'over_reg' : registrations >= REG_TOTAL and True or False,

            'registrations' : registrations}))

@login_required

def edit_registration(request, id,

        template_name='registration/edit-registration.html'):

    '''Allows users that submitted a registration to edit it.

    '''

    reg = Registration.objects.get(pk=id)

    if reg.registrant != request.user:

        redirect_to = reverse('kiwipycon_account')

        return set_message_cookie(redirect_to,

                msg = u'Redirected because the registration you selected' \

                      + ' is not your own.')

    if request.method == 'POST':

        form = RegistrationEditForm(data=request.POST)

        if form.is_valid():

            reg.organisation = form.data.get('organisation')

            reg.occupation = form.data.get('occupation')

            reg.city = form.data.get('city')

            reg.tshirt = form.data.get('tshirt')

            reg.allow_contact = form.data.get('allow_contact') and True or False

            reg.conference = form.data.get('conference') and True or False

            reg.tutorial = form.data.get('tutorial') and True or False

            reg.sprint = form.data.get('sprint') and True or False

            reg.save()

            # Saved.. redirect

            redirect_to = reverse('kiwipycon_account')

            return set_message_cookie(redirect_to,

                    msg = u'Your changes have been saved.')

    else:

        form = RegistrationEditForm(initial={

                                    'id' : id,

                                    'organisation' : reg.organisation,

                                    'occupation' : reg.occupation,

                                    'city' : reg.city,

                                    'tshirt' : reg.tshirt,

                                    'conference': reg.conference,

                                    'tutorial': reg.tutorial,

                                    'postcode' : reg.postcode,

                                    'sprint' : reg.sprint,

                                    'allow_contact' : reg.allow_contact,

            })

    return render_to_response(template_name, RequestContext(request, locals()))

def submit_registration(request,

        template_name='registration/submit-registration.html'):

    '''Allows user to edit registration

    '''

    user = request.user

    reg_count = Registration.objects.all().count()

    if user.is_authenticated():

        try:

            profile = user.get_profile()

        except:

            profile, new = UserProfile.objects.get_or_create(user=user)

            if new:

                profile.save()

        try:

            registration = Registration.objects.get(registrant=user)

            if registration:

                redirect_to = reverse('kiwipycon_account')

                return set_message_cookie(redirect_to,

                        msg = u'You have already been registered.')

        except ObjectDoesNotExist:

            pass

    message = None

    if request.method == 'POST':

        registration_form = RegistrationSubmitForm(data=request.POST)

        registrant_form = RegistrantForm(data=request.POST)

        wifi_form = WifiForm(data=request.POST)

        if request.POST.get('action', None) == 'login':

            login_form = AuthenticationForm(data=request.POST)

            if login_form.is_valid():

                from django.contrib.auth import login

                login(request, login_form.get_user())

                redirect_to = reverse('kiwipycon_submit_registration')

                return set_message_cookie(redirect_to,

                        msg = u'You have been logged in please continue' + \

                               'with registration.')

        newuser = None

        passwd = None

        if not user.is_authenticated():

            if registrant_form.is_valid():

                newuser = kiwipycon_createregistrant(request, registrant_form.data)

                # Log in user

                passwd = User.objects.make_random_password()

                newuser.set_password(passwd)

                newuser.save()

                from django.contrib.auth import authenticate

                user = authenticate(username=newuser.username, password=passwd)

                from django.contrib.auth import login

                login(request, user)

                newuser = user

        else:

            newuser = user

        if registration_form.is_valid() and newuser:

            allow_contact = registration_form.data.get('allow_contact') and \

                                        True or False

            conference = registration_form.data.get('conference') and \

                                        True or False

            tutorial = registration_form.data.get('tutorial') and \

                                        True or False

            sprint = registration_form.data.get('sprint') and \

                                        True or False

            registrant = User.objects.get(pk=newuser.id)

            presenter = None

            talks = Talk.objects.filter(

                    speaker=registrant).filter(approved=True)

            if talks:

                for talk in talks:

                    if talk.duration == '30':

                        presenter = True

                    elif talk.duration == '60':

                        presenter = True

            reg = Registration(

                    #     slug = newuser.username,

                registrant = registrant,

                organisation = registration_form.data.get('organisation'),

                occupation = registration_form.data.get('occupation'),

                city = registration_form.data.get('city'),

                tshirt = registration_form.data.get('tshirt'),

                postcode = registration_form.cleaned_data.get('postcode'),

                allow_contact = allow_contact,

                conference = conference,

                tutorial = tutorial,

                sprint = sprint)

            reg.save() 

            # get id and use as slug and invoice number

            id = reg.id

            slug = 'KPC09%03d' % id

            reg.slug = slug

            reg.save()

            # additional tasks:

            if wifi_form.is_valid():

                wifi = wifi_form.save(registrant)

            # 1. include random password if we are a new user

            if passwd:

                send_confirmation(registrant, slug, password=passwd)

            else:

            # 2. send user email with registration id

                send_confirmation(registrant, slug)

            redirect_to = reverse('kiwipycon_registrations')

            return set_message_cookie(redirect_to,

                    msg = u'Thank you, your registration has been submitted '\

                           'and an email has been sent with payment details.')

    else:

        registration_form = RegistrationSubmitForm()

        registrant_form = RegistrantForm()

        wifi_form = WifiForm()

    login_form = AuthenticationForm()

    return render_to_response(template_name, RequestContext(request, {

        'registration_form': registration_form,

        'registrant_form' : registrant_form,

        'over_reg' : reg_count >= REG_TOTAL and True or False,

        'wifi_form' : wifi_form,

        'message' : message,

        'login_form' : login_form

    }))