from textwrap import wrap

from django.core.exceptions import ValidationError

from django.db import models

from django.utils.encoding import python_2_unicode_compatible

from django_countries.fields import CountryField

from registrasion import models as rego

@python_2_unicode_compatible

class PastEvent(models.Model):

    ''' This is populated in 0001_initial.py '''

    def __str__(self):

        return self.name

    year = models.IntegerField(unique=True,)

    name = models.CharField(max_length=255, unique=True,)

class AttendeeProfile(rego.AttendeeProfileBase):

    @classmethod

    def name_field(cls):

        ''' This is used to pre-fill the attendee's name from the

        speaker profile. If it's None, that functionality is disabled. '''

        return "name"

    def invoice_recipient(self):

        lines = [

            self.name_per_invoice,

        ]

        if self.company:

            lines.append("C/- " + self.company)

        if self.address_line_1:

            lines.append(self.address_line_1)

        if self.address_line_2:

            lines.append(self.address_line_2)

        if self.address_suburb or self.address_postcode:

            lines.append("%s %s" % (

                self.address_suburb or "",

                self.address_postcode or "",

            ))

        if self.state:

            lines.append(self.state)

        if self.country:

            lines.append(self.country.name)

        return "\n".join(lines)

    def clean(self):

        errors = []

        if self.country == "AU" and not self.state:

            errors.append(

                ("state", "Australians must list their state"),

            )

        if self.address_line_2 and not self.address_line_1:

            errors.append((

                "address_line_1",

                "Please fill in line 1 before filling line 2",

            ))

        if errors:

            raise ValidationError(dict(errors))

    def save(self):

        if not self.name_per_invoice:

            self.name_per_invoice = self.name

        super(AttendeeProfile, self).save()

    # Things that appear on badge

    name = models.CharField(

        verbose_name="Your name (for your conference nametag)",

        max_length=64,

        help_text="Your name, as you'd like it to appear on your badge. ",

    )

    company = models.CharField(

        max_length=64,

        help_text="The name of your company, as you'd like it on your badge",

        blank=True,

    )

    free_text_1 = models.CharField(

        max_length=64,

        verbose_name="Free text line 1",

        help_text="A line of free text that will appear on your badge. Use "

                  "this for your Twitter handle, IRC nick, your preferred "

                  "pronouns or anything else you'd like people to see on "

                  "your badge.",

        blank=True,

    )

    free_text_2 = models.CharField(

        max_length=64,

        verbose_name="Free text line 2",

        blank=True,

    )

    # Other important Information

    name_per_invoice = models.CharField(

        verbose_name="Your legal name (for invoicing purposes)",

        max_length=256,

        help_text="If your legal name is different to the name on your badge, "

                  "fill this in, and we'll put it on your invoice. Otherwise, "

                  "leave it blank.",

        blank=True,

        )

    address_line_1 = models.CharField(

        verbose_name="Address line 1",

        help_text="This address, if provided, will appear on your invoices.",

        max_length=1024,

        blank=True,

    )

    address_line_2 = models.CharField(

        verbose_name="Address line 2",

        max_length=1024,

        blank=True,

    )

    address_suburb = models.CharField(

        verbose_name="City/Town/Suburb",

        max_length=1024,

        blank=True,

    )

    address_postcode = models.CharField(

        verbose_name="Postal/Zip code",

        max_length=1024,

        blank=True,

    )

    country = CountryField(

        default="AU",

    )

    state = models.CharField(

        max_length=256,

        verbose_name="State/Territory/Province",

        help_text="If your Country is Australia, you must list a state.",

        blank=True,

    )

    of_legal_age = models.BooleanField(

        verbose_name="Are you over 18?",

        help_text="Being under 18 will not stop you from attending the "

                  "conference. We need to know whether you are over 18 to "

                  "allow us to cater for you at venues that serve alcohol.",

    )

    dietary_restrictions = models.CharField(

        verbose_name="Food allergies, intolerances, or dietary restrictions",

        max_length=256,

        blank=True,

    )

    accessibility_requirements = models.CharField(

        verbose_name="Accessibility-related requirements",

        max_length=256,

        blank=True,

    )

    gender = models.CharField(

        help_text="Gender data will only be used for demographic purposes.",

        max_length=64,

        blank=True,

    )

    children = models.CharField(

        max_length=256,

        help_text="Linux.conf.au is a family friendly conference and provides "

            "free child-care for pre-school children from 6 months up to 5 years. We "

            "hope to also provide a programme for older children and will let you "

            "know closer to the conference. If you're wanting to bring your children "

            "to LCA, please let us know their age(s) so we can ensure we have "

            "enough spaces available.",

        blank=True

    )

    linux_australia = models.BooleanField(

        verbose_name="Linux Australia membership",

        help_text="Select this field to register for free "

                  "<a href='http://www.linux.org.au/'>Linux Australia</a> "

                  "membership.",

        blank=True,

    )

    lca_announce = models.BooleanField(

        verbose_name="Subscribe to lca-announce list",

        help_text="Select to be subscribed to the low-traffic lca-announce "

                  "mailing list",

        blank=True,

    )

    lca_chat = models.BooleanField(

        verbose_name="Subscribe to the LCA chat list",

        help_text="lca-chat is a high-traffic mailing list used by "

                  "attendees during the week of the conference for general "

                  "discussion.",

        blank=True,

    )

    future_conference = models.BooleanField(

        verbose_name = "Reuse my login for future Linux Australia conferences?",

        help_text="Select to have your login details made available to future "

                  "Linux Australia conferences who share the same Single Sign "

                  "On system.",

        blank=True,

    )

    past_lca = models.ManyToManyField(

        PastEvent,

        verbose_name="Which past linux.conf.au events have you attended?",

        blank=True,

    )

    def first_name(self):

        return wrap(self.name, 15, break_long_words=False)[0]

    def last_name(self):

        names = wrap(self.name, 15, break_long_words=False)

{% extends "site_base.html" %}

{% load bootstrap %}

{% load registrasion_tags %}

{% block page_title %}Registration report{% endblock %}

{% block head_title %}Registration report - {{ title }}{% endblock %}

{% block content %}

  <h2>{{ title }}</h2>

  <p><a href="{% url 'reports_list' %}">Return to reports list</a></p>

  {% if form %}

    <form class="form-horizontal" method="GET">

      {{ form | bootstrap}}

      <br/>

      <input class="btn btn-primary" type="submit">

    </form>

  {% endif %}

<hr />

{% for report in reports %}

<h3>{{ report.title }}</h3>

{% if report.headings %}

<table class="table table-striped table-reportdata">

{% else %}

<table class="table table-striped">

{% endif %}

<hr class="my-5" />

{% endfor %}

{% endblock %}

{% block extra_script %}

<link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/v/bs4/jszip-2.5.0/dt-1.10.20/b-1.6.0/b-colvis-1.6.0/b-html5-1.6.0/b-print-1.6.0/cr-1.5.2/fc-3.3.0/fh-3.1.6/r-2.2.3/rg-1.1.1/datatables.min.css"/>

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/pdfmake.min.js"></script>

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/vfs_fonts.js"></script>

<script type="text/javascript" src="https://cdn.datatables.net/v/bs4/jszip-2.5.0/dt-1.10.20/b-1.6.0/b-colvis-1.6.0/b-html5-1.6.0/b-print-1.6.0/cr-1.5.2/fc-3.3.0/fh-3.1.6/r-2.2.3/rg-1.1.1/datatables.min.js"></script>

<script type="text/javascript">

  $("table.table-reportdata").dataTable({

    "dom":

      "<'row'<'col-sm-12 col-md-3'l><'col-sm-12 col-md-5'B><'col-sm-12 col-md-4'f>>" +

      "<'row'<'col-sm-12'tr>>" +

      "<'row'<'col-sm-12 col-md-5'i><'col-sm-12 col-md-7'p>>",

    "stateSave": true,

    "lengthMenu": [[10, 50, 100, -1], [10, 50, 100, "All"]],

    "pageLength": 100,

    "buttons": [

      "csv",

      "print",

      {

        extend: 'copy',

        text: 'Copy',

        exportOptions: {

          columns: ':visible'

        }

      },

      {

        extend: 'collection',

        text: 'Columns',

        buttons: [ 'columnsToggle']

      }

    ]

  });

</script>

{% endblock %}

        data,

    )

@report_view("Credit notes")

def credit_notes(request, form):

    ''' Shows all of the credit notes in the system. '''

    notes = commerce.CreditNote.objects.all().select_related(

        "creditnoterefund",

        "creditnoteapplication",

        "invoice",

        "invoice__user__attendee__attendeeprofilebase",

    )

    return QuerysetReport(

        "Credit Notes",

        ["id",

         "invoice__user__attendee__attendeeprofilebase__invoice_recipient",

         "status", "value"],

        notes,

        headings=["id", "Owner", "Status", "Value"],

        link_view=views.credit_note,

    )

@report_view("Invoices")

def invoices(request, form):

    ''' Shows all of the invoices in the system. '''

    invoices = commerce.Invoice.objects.all().order_by("status", "id")

    return QuerysetReport(

        "Invoices",

        ["id", "recipient", "value", "get_status_display"],

        invoices,

        headings=["id", "Recipient", "Value", "Status"],

        link_view=views.invoice,

    )

class AttendeeListReport(ListReport):

    def get_link(self, argument):

        return reverse(self._link_view) + "?user=%d" % int(argument)

@report_view("Attendee", form_type=forms.UserIdForm)

def attendee(request, form, user_id=None):

    ''' Returns a list of all manifested attendees if no attendee is specified,

    else displays the attendee manifest. '''

    if user_id is None and form.cleaned_data["user"] is not None:

        user_id = form.cleaned_data["user"]

    if user_id is None:

        return attendee_list(request)

    reports = []

    try:

        attendee = people.Attendee.objects.get(user__id=user_id)

    except people.DoesNotExist:

        return reports

    profile_data = []

    try:

        name = attendee.attendeeprofilebase.attendee_name()

        profile = people.AttendeeProfileBase.objects.get_subclass(

            attendee=attendee

        )

        fields = profile._meta.get_fields()

    except people.AttendeeProfileBase.DoesNotExist:

        name = attendee.user.username

        fields = []

    exclude = set(["attendeeprofilebase_ptr", "id"])

    for field in fields:

        if field.name in exclude:

            # Not actually important

            continue

        if not hasattr(field, "verbose_name"):

            continue  # Not a publicly visible field

        value = getattr(profile, field.name)

        if isinstance(field, models.ManyToManyField):

            value = ", ".join(str(i) for i in value.all())

        elif isinstance(field, CharField):

            try:

                value = bleach.clean(str(value))

            except TypeError:

                value = "Bad value for %s" % field.name

        profile_data.append((field.verbose_name, value))

    cart = CartController.for_user(attendee.user)

    try:

        reservation = cart.cart.reservation_duration + cart.cart.time_last_updated

    except AttributeError:  # No reservation_duration set -- default to 24h

        reservation = datetime.datetime.now() + datetime.timedelta(hours=24)

    profile_data.append(("Current cart reserved until", reservation))

    links = []

    links.append((

        reverse(views.badge, args=[user_id]),

        "View badge",

    ))

    links.append((

        reverse(views.amend_registration, args=[user_id]),

        "Amend current cart",

    ))

    links.append((

        reverse(views.extend_reservation, args=[user_id]),

        "Extend reservation",

    ))

    reports.append(Links("Actions for " + name, links))

    # Paid and pending  products

    try:

        ic = ItemController(attendee.user)

        reports.append(ListReport(

            "Paid Products",

            ["Product", "Quantity"],

            [(pq.product, pq.quantity) for pq in ic.items_purchased()],

        ))

        reports.append(ListReport(

            "Unpaid Products",

            ["Product", "Quantity"],

            [(pq.product, pq.quantity) for pq in ic.items_pending()],

        ))

    except AttributeError:

        pass

    # Invoices

    try:

        invoices = commerce.Invoice.objects.filter(

            user=attendee.user,

        )

        reports.append(QuerysetReport(

            "Invoices",

            ["id", "get_status_display", "value"],

            invoices,

            headings=["Invoice ID", "Status", "Value"],

            link_view=views.invoice,

        ))

    except AttrbuteError:

        pass

    # Credit Notes

    try:

        credit_notes = commerce.CreditNote.objects.filter(

            invoice__user=attendee.user,

        ).select_related("invoice", "creditnoteapplication", "creditnoterefund")

        reports.append(QuerysetReport(

            "Credit Notes",

            ["id", "status", "value"],

            credit_notes,

            link_view=views.credit_note,

        ))

    except AttributeError:

        pass

    # All payments

    try:

        payments = commerce.PaymentBase.objects.filter(

            invoice__user=attendee.user,

        ).select_related("invoice")

        reports.append(QuerysetReport(

            "Payments",

            ["invoice__id", "id", "reference", "amount"],

            payments,

            link_view=views.invoice,

        ))

    except AttributeError:

        pass

    return reports

def attendee_list(request):

    ''' Returns a list of all attendees. '''

    attendees = people.Attendee.objects.select_related(

        "attendeeprofilebase",

        "user",

    )

    profiles = AttendeeProfile.objects.filter(

        attendee__in=attendees

    ).select_related(

        "attendee", "attendee__user",

    )

    profiles_by_attendee = dict((i.attendee, i) for i in profiles)

        by_user[profile.attendee.user] = profile

    cart = "attendee__user__cart"

    cart_status = cart + "__status"  # noqa

    product = cart + "__productitem__product"

    product_name = product + "__name"

    category = product + "__category"

    category_name = category + "__name"

    if by_category:

        grouping_fields = (category, category_name)

        order_by = (category, )

        first_column = "Category"

        group_name = lambda i: "%s" % (i[category_name], )  # noqa

    else:

        grouping_fields = (product, product_name, category_name)

        order_by = (category, )

        first_column = "Product"

        group_name = lambda i: "%s - %s" % (i[category_name], i[product_name])  # noqa

    # Group the responses per-field.

    for field in fields:

        concrete_field = AttendeeProfile._meta.get_field(field)

        field_verbose = concrete_field.verbose_name

        # Render the correct values for related fields

        if field in related_fields:

            # Get all of the IDs that will appear

            all_ids = profiles.order_by(field).values(field)

            all_ids = [i[field] for i in all_ids if i[field] is not None]

            # Get all of the concrete objects for those IDs

            model = concrete_field.related_model

            all_objects = model.objects.filter(id__in=all_ids)

            all_objects_by_id = dict((i.id, i) for i in all_objects)

            # Define a function to render those IDs.

            def display_field(value):

                if value in all_objects_by_id:

                    return all_objects_by_id[value]

                else:

                    return None

        else:

            def display_field(value):

                return bleach.clean(str(value))

        status_count = lambda status: Case(When(  # noqa

                attendee__user__cart__status=status,

                then=Value(1),

            ),

            default=Value(0),

            output_field=models.fields.IntegerField(),

        )

        paid_count = status_count(commerce.Cart.STATUS_PAID)

        unpaid_count = status_count(commerce.Cart.STATUS_ACTIVE)

        groups = profiles.order_by(

            *(order_by + (field, ))

        ).values(

            *(grouping_fields + (field, ))

        ).annotate(

            paid_count=Sum(paid_count),

            unpaid_count=Sum(unpaid_count),

        )

        output.append(ListReport(

            "Grouped by %s" % field_verbose,

            [first_column, field_verbose, "paid", "unpaid"],

            [

                (

                    group_name(group),

                    display_field(group[field]),

                    group["paid_count"] or 0,

                    group["unpaid_count"] or 0,

                )

                for group in groups

            ],

        ))

    # DO the report for individual attendees

    field_names = [

        AttendeeProfile._meta.get_field(field).verbose_name for field in fields

    ]

    def display_field(profile, field):

        field_type = AttendeeProfile._meta.get_field(field)

        attr = getattr(profile, field)

        if isinstance(field_type, models.ManyToManyField):

            return [str(i) for i in attr.all()] or ""

        else:

            try:

                return bleach.clean(str(attr))

            except TypeError:

                return "Bad value found for %s" % attr

    headings.extend(field_names)

    data = []

    for item in items:

        profile = by_user[item.cart.user]

        line = [

            item.cart.user.id,

            getattr(profile, name_field),

            profile.attendee.user.email,

            item.product,

            status_display[item.cart.status],

        ] + [

            display_field(profile, field) for field in fields

        ]

        data.append(line)

    output.append(AttendeeListReport(

        "Attendees by item with profile data", headings, data,

        link_view=attendee

    ))

    return output

@report_view(

    "Speaker Registration Status",

    form_type=forms.ProposalKindForm,

)

def speaker_registrations(request, form):

    ''' Shows registration status for speakers with a given proposal kind. '''

    kinds = form.cleaned_data["kind"]

    presentations = schedule_models.Presentation.objects.filter(

        proposal_base__kind__in=kinds,

    ).exclude(

        cancelled=True,

    )

    users = User.objects.filter(

        Q(speaker_profile__presentations__in=presentations) |

        Q(speaker_profile__copresentations__in=presentations)

    )

    paid_carts = commerce.Cart.objects.filter(status=commerce.Cart.STATUS_PAID)

    paid_carts = Case(

        When(cart__in=paid_carts, then=Value(1)),

        default=Value(0),

        output_field=models.IntegerField(),

    )

    users = users.annotate(paid_carts=Sum(paid_carts))

    users = users.order_by("paid_carts")

    return QuerysetReport(

        "Speaker Registration Status",

        ["id", "speaker_profile__name", "email", "paid_carts"],

        users,

        link_view=attendee,

    )

    return []

@report_view(

    "Manifest",

    forms.ProductAndCategoryForm,

)

def manifest(request, form):

    '''

    Produces the registration manifest for people with the given product

    type.

    '''

    products = form.cleaned_data["product"]

    categories = form.cleaned_data["category"]

    line_items = (

        Q(lineitem__product__in=products) |

        Q(lineitem__product__category__in=categories)

    )

    invoices = commerce.Invoice.objects.filter(

        line_items,

        status=commerce.Invoice.STATUS_PAID,

    ).select_related(

        "cart",

        "user",

        "user__attendee",

        "user__attendee__attendeeprofilebase"

    )

    users = set(i.user for i in invoices)

    carts = commerce.Cart.objects.filter(

        user__in=users

    )

    items = commerce.ProductItem.objects.filter(

        cart__in=carts

    ).select_related(

        "product",

        "product__category",

        "cart",

        "cart__user",

        "cart__user__attendee",

        "cart__user__attendee__attendeeprofilebase"