import csv

import forms

from django.contrib.auth.decorators import user_passes_test

from django.shortcuts import render

from django.core.urlresolvers import reverse

from django.http import HttpResponse

from functools import wraps

from registrasion import views

''' A list of report views objects that can be used to load a list of

reports. '''

_all_report_views = []

class Report(object):

    def __init__(self):

        pass

    def title():

        raise NotImplementedError

    def headings():

        ''' Returns the headings for the report. '''

        raise NotImplementedError

    def rows(content_type):

        '''

        Arguments:

            content_type (str): The content-type for the output format of this

            report.

        Returns:

            An iterator, which yields each row of the data. Each row should

            be an iterable containing the cells, rendered appropriately for

            content_type.

        '''

        raise NotImplementedError

    def _linked_text(self, content_type, address, text):

        '''

        Returns:

            an HTML linked version of text, if the content_type for this report

            is HTMLish, otherwise, the text.

        '''

        if content_type == "text/html":

            return Report._html_link(address, text)

        else:

            return text

    @staticmethod

    def _html_link(address, text):

        return '<a href="%s">%s</a>' % (address, text)

class _ReportTemplateWrapper(object):

    ''' Used internally to pass `Report` objects to templates. They effectively

    are used to specify the content_type for a report. '''

    def __init__(self, content_type, report):

        self.content_type = content_type

        self.report = report

    def title(self):

        return self.report.title()

    def headings(self):

        return self.report.headings()

    def rows(self):

        return self.report.rows(self.content_type)

class BasicReport(Report):

    def __init__(self, title, headings, link_view=None):

        super(BasicReport, self).__init__()

        self._title = title

        self._headings = headings

        self._link_view = link_view

    def title(self):

        ''' Returns the title for this report. '''

        return self._title

    def headings(self):

        ''' Returns the headings for the table. '''

        return self._headings

    def cell_text(self, content_type, index, text):

        if index > 0 or not self._link_view:

            return text

        else:

            address = self.get_link(text)

            return self._linked_text(content_type, address, text)

    def get_link(self, argument):

        return reverse(self._link_view, args=[argument])

class ListReport(BasicReport):

    def __init__(self, title, headings, data, link_view=None):

        super(ListReport, self).__init__(title, headings, link_view=link_view)

        self._data = data

    def rows(self, content_type):

        ''' Returns the data rows for the table. '''

        for row in self._data:

            yield [

                self.cell_text(content_type, i, cell)

                for i, cell in enumerate(row)

            ]

class QuerysetReport(BasicReport):

    def __init__(self, title, attributes, queryset, headings=None,

                 link_view=None):

        super(QuerysetReport, self).__init__(

            title, headings, link_view=link_view

        )

        self._attributes = attributes

        self._queryset = queryset

    def headings(self):

        if self._headings is not None:

            return self._headings

        return [

            " ".join(i.split("_")).capitalize() for i in self._attributes

        ]

    def rows(self, content_type):

        def rgetattr(item, attr):

            for i in attr.split("__"):

                item = getattr(item, i)

            if callable(item):

                try:

                    return item()

                except TypeError:

                    pass

            return item

        for row in self._queryset:

            yield [

                self.cell_text(content_type, i, rgetattr(row, attribute))

                for i, attribute in enumerate(self._attributes)

            ]

class Links(Report):

    def __init__(self, title, links):

        '''

        Arguments:

            links ([tuple, ...]): a list of 2-tuples:

                (url, link_text)

        '''

        self._title = title

        self._links = links

    def title(self):

        return self._title

    def headings(self):

        return []

    def rows(self, content_type):

        print self._links

        for url, link_text in self._links:

            yield [

                self._linked_text(content_type, url, link_text)

            ]

def report_view(title, form_type=None):

    ''' Decorator that converts a report view function into something that

    displays a Report.

    Arguments:

        title (str):

            The title of the report.

        form_type (Optional[forms.Form]):

            A form class that can make this report display things. If not

            supplied, no form will be displayed.

    '''

    # Create & return view

    def _report(view):

        report_view = ReportView(view, title, form_type)

        report_view = user_passes_test(views._staff_only)(report_view)

        report_view = wraps(view)(report_view)

        # Add this report to the list of reports.

        _all_report_views.append(report_view)

        return report_view

    return _report

class ReportView(object):

    def __init__(self, inner_view, title, form_type):

        # Consolidate form_type so it has content type and section

        self.inner_view = inner_view

        self.title = title

        self.form_type = form_type

    def __call__(self, request, *a, **k):

        data = ReportViewRequestData(self, request, *a, **k)

        return self.render(data)

    def get_form(self, request):

        # Create a form instance

        if self.form_type is not None:

            form = self.form_type(request.GET)

            # Pre-validate it

            form.is_valid()

        else:

            form = None

        return form

    @classmethod

    def wrap_reports(cls, reports, content_type):

        reports = [

            _ReportTemplateWrapper(content_type, report)

            for report in reports

        ]

        return reports

    def render(self, data):

        renderers = {

            "text/csv": self._render_as_csv,

            "text/html": self._render_as_html,

            None: self._render_as_html,

        }

        render = renderers[data.content_type]

        return render(data)

    def _render_as_html(self, data):

        ctx = {

            "title": self.title,

            "form": data.form,

            "reports": data.reports,

        }

        return render(data.request, "registrasion/report.html", ctx)

    def _render_as_csv(self, data):

        report = data.reports[data.section]

        # Create the HttpResponse object with the appropriate CSV header.

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

        writer = csv.writer(response)

        encode = lambda i: i.encode("utf8") if isinstance(i, unicode) else i

        writer.writerow(list(encode(i) for i in report.headings()))

        for row in report.rows():

            writer.writerow(list(encode(i) for i in row))

        return response

class ReportViewRequestData(object):

    def __init__(self, report_view, request, *a, **k):

        self.report_view = report_view

        self.request = request

        # Calculate other data

        self.form = report_view.get_form(request)

        # Content type and section come from request.GET

        self.content_type = request.GET.get("content_type")

        self.section = request.GET.get("section")

        self.section = int(self.section) if self.section else None

        # Reports come from calling the inner view

        reports = report_view.inner_view(request, self.form, *a, **k)

        # Normalise to a list

        if isinstance(reports, Report):

            reports = [reports]

        # Wrap them in appropriate format

        reports = ReportView.wrap_reports(reports, self.content_type)

        self.reports = reports

def get_all_reports():

    ''' Returns all the views that have been registered with @report '''

    return list(_all_report_views)

import forms

import collections

import datetime

import itertools

from django.conf import settings

from django.contrib.auth.decorators import user_passes_test

from django.contrib.auth.models import User

from django.core.urlresolvers import reverse

from django.db import models

from django.db.models import F, Q

from django.db.models import Count, Max, Sum

from django.db.models import Case, When, Value

from django.db.models.fields.related import RelatedField

from django.shortcuts import render

from registrasion.controllers.cart import CartController

from registrasion.controllers.item import ItemController

from registrasion.models import commerce

from registrasion.models import people

from registrasion import util

from registrasion import views

from symposion.schedule import models as schedule_models

from reports import get_all_reports

from reports import Links

from reports import ListReport

from reports import QuerysetReport

from reports import report_view

def CURRENCY():

    return models.DecimalField(decimal_places=2)

AttendeeProfile = util.get_object_from_name(settings.ATTENDEE_PROFILE_MODEL)

@user_passes_test(views._staff_only)

def reports_list(request):

    ''' Lists all of the reports currently available. '''

    reports = []

    for report in get_all_reports():

        reports.append({

            "name": report.__name__,

            "url": reverse(report),

            "description": report.__doc__,

        })

    reports.sort(key=lambda report: report["name"])

    ctx = {

        "reports": reports,

    }

    return render(request, "registrasion/reports_list.html", ctx)

# Report functions

@report_view("Reconcilitation")

def reconciliation(request, form):

    ''' Shows the summary of sales, and the full history of payments and

    refunds into the system. '''

    return [

        sales_payment_summary(),

        items_sold(),

        payments(),

        credit_note_refunds(),

    ]

def items_sold():

    ''' Summarises the items sold and discounts granted for a given set of

    products, or products from categories. '''

    data = None

    headings = None

    line_items = commerce.LineItem.objects.filter(

        invoice__status=commerce.Invoice.STATUS_PAID,

    ).select_related("invoice")

    line_items = line_items.order_by(

        # sqlite requires an order_by for .values() to work

        "-price", "description",

    ).values(

        "price", "description",

    ).annotate(

        total_quantity=Sum("quantity"),

    )

    print line_items

    headings = ["Description", "Quantity", "Price", "Total"]

    data = []

    total_income = 0

    for line in line_items:

        cost = line["total_quantity"] * line["price"]

        data.append([

            line["description"], line["total_quantity"],

            line["price"], cost,

        ])

        total_income += cost

    data.append([

        "(TOTAL)", "--", "--", total_income,

    ])

    return ListReport("Items sold", headings, data)

def sales_payment_summary():

    ''' Summarises paid items and payments. '''

    def value_or_zero(aggregate, key):

        return aggregate[key] or 0

    def sum_amount(payment_set):

        a = payment_set.values("amount").aggregate(total=Sum("amount"))

        return value_or_zero(a, "total")

    headings = ["Category", "Total"]

    data = []

    # Summarise all sales made (= income.)

    sales = commerce.LineItem.objects.filter(

        invoice__status=commerce.Invoice.STATUS_PAID,

    ).values(

        "price", "quantity"

    ).aggregate(

        total=Sum(F("price") * F("quantity"), output_field=CURRENCY()),

    )

    sales = value_or_zero(sales, "total")

    all_payments = sum_amount(commerce.PaymentBase.objects.all())

    # Manual payments

    # Credit notes generated (total)

    # Payments made by credit note

    # Claimed credit notes

    all_credit_notes = 0 - sum_amount(commerce.CreditNote.objects.all())

    unclaimed_credit_notes = 0 - sum_amount(commerce.CreditNote.unclaimed())

    claimed_credit_notes = sum_amount(

        commerce.CreditNoteApplication.objects.all()

    )

    refunded_credit_notes = 0 - sum_amount(commerce.CreditNote.refunded())

    data.append(["Items on paid invoices", sales])

    data.append(["All payments", all_payments])

    data.append(["Sales - Payments ", sales - all_payments])

    data.append(["All credit notes", all_credit_notes])

    data.append(["Credit notes paid on invoices", claimed_credit_notes])

    data.append(["Credit notes refunded", refunded_credit_notes])

    data.append(["Unclaimed credit notes", unclaimed_credit_notes])

    data.append([

        "Credit notes - (claimed credit notes + unclaimed credit notes)",

        all_credit_notes - claimed_credit_notes -

            refunded_credit_notes - unclaimed_credit_notes,

    ])

    return ListReport("Sales and Payments Summary", headings, data)

def payments():

    ''' Shows the history of payments into the system '''

    payments = commerce.PaymentBase.objects.all()

    return QuerysetReport(

        "Payments",

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

        payments,

        link_view=views.invoice,

    )

def credit_note_refunds():

    ''' Shows all of the credit notes that have been generated. '''

    notes_refunded = commerce.CreditNote.refunded()

    return QuerysetReport(

        "Credit note refunds",

        ["id", "creditnoterefund__reference", "amount"],

        notes_refunded,

        link_view=views.credit_note,

    )

def group_by_cart_status(queryset, order, values):

    queryset = queryset.annotate(

        is_reserved=Case(

            When(cart__in=commerce.Cart.reserved_carts(), then=Value(True)),

            default=Value(False),

            output_field=models.BooleanField(),

        ),

    )

    values = queryset.order_by(*order).values(*values)

    values = values.annotate(

        total_paid=Sum(Case(

            When(

                cart__status=commerce.Cart.STATUS_PAID,

                then=F("quantity"),

            ),

            default=Value(0),

        )),

        total_refunded=Sum(Case(

            When(

                cart__status=commerce.Cart.STATUS_RELEASED,

                then=F("quantity"),

            ),

            default=Value(0),

        )),

        total_unreserved=Sum(Case(

            When(

                (

                    Q(cart__status=commerce.Cart.STATUS_ACTIVE) &

                    Q(is_reserved=False)

                ),

                then=F("quantity"),

            ),

            default=Value(0),

        )),

        total_reserved=Sum(Case(

            When(

                (

                    Q(cart__status=commerce.Cart.STATUS_ACTIVE) &

                    Q(is_reserved=True)

                ),

                then=F("quantity"),

            ),

            default=Value(0),

        )),

    )

    return values

@report_view("Product status", form_type=forms.ProductAndCategoryForm)

def product_status(request, form):

    ''' Summarises the inventory status of the given items, grouping by

    invoice status. '''

    products = form.cleaned_data["product"]

    categories = form.cleaned_data["category"]

    items = commerce.ProductItem.objects.filter(

        Q(product__in=products) | Q(product__category__in=categories),

    ).select_related("cart", "product")

    items = group_by_cart_status(

        items,

        ["product__category__order", "product__order"],

        ["product", "product__category__name", "product__name"],

    )

    headings = [

        "Product", "Paid", "Reserved", "Unreserved", "Refunded",

    ]

    data = []

    for item in items:

        data.append([

            "%s - %s" % (

                item["product__category__name"], item["product__name"]

            ),

            item["total_paid"],

            item["total_reserved"],

            item["total_unreserved"],

            item["total_refunded"],

        ])

    return ListReport("Inventory", headings, data)

@report_view("Product status", form_type=forms.DiscountForm)

def discount_status(request, form):

    ''' Summarises the usage of a given discount. '''

    discounts = form.cleaned_data["discount"]

    items = commerce.DiscountItem.objects.filter(

        Q(discount__in=discounts),

    ).select_related("cart", "product", "product__category")

    items = group_by_cart_status(

        items,

        ["discount",],

        ["discount", "discount__description",],

    )

    headings = [

        "Discount", "Paid", "Reserved", "Unreserved", "Refunded",

    ]

    data = []

    for item in items:

        data.append([

            item["discount__description"],

            item["total_paid"],

            item["total_reserved"],

            item["total_unreserved"],

            item["total_refunded"],

        ])

    return ListReport("Usage by item", headings, data)

@report_view("Paid invoices by date", form_type=forms.ProductAndCategoryForm)

def paid_invoices_by_date(request, form):

    ''' Shows the number of paid invoices containing given products or

    categories per day. '''

    products = form.cleaned_data["product"]

    categories = form.cleaned_data["category"]

    invoices = commerce.Invoice.objects.filter(

        (

            Q(lineitem__product__in=products) |

            Q(lineitem__product__category__in=categories)

        ),

        status=commerce.Invoice.STATUS_PAID,

    )

    # Invoices with payments will be paid at the time of their latest payment

    payments = commerce.PaymentBase.objects.all()

    payments = payments.filter(

        invoice__in=invoices,

    )

    payments = payments.order_by("invoice")

    invoice_max_time = payments.values("invoice").annotate(

        max_time=Max("time")

    )

    # Zero-value invoices will have no payments, so they're paid at issue time

    zero_value_invoices = invoices.filter(value=0)

    times = itertools.chain(

        (line["max_time"] for line in invoice_max_time),

        (invoice.issue_time for invoice in zero_value_invoices),

    )

    by_date = collections.defaultdict(int)

    for time in times:

        date = datetime.datetime(

            year=time.year, month=time.month, day=time.day

        )

        by_date[date] += 1

    data = [(date, count) for date, count in sorted(by_date.items())]

    data = [(date.strftime("%Y-%m-%d"), count) for date, count in data]

    return ListReport(

        "Paid Invoices By Date",

        ["date", "count"],

        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"],  # NOQA

        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")

    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:

        return attendee_list(request)

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

    name = attendee.attendeeprofilebase.attendee_name()

    reports = []

    profile_data = []

    try:

        profile = people.AttendeeProfileBase.objects.get_subclass(

            attendee=attendee

        )

        fields = profile._meta.get_fields()

    except people.AttendeeProfileBase.DoesNotExist:

        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())

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

    cart = CartController.for_user(attendee.user)

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

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

    reports.append(ListReport("Profile", ["", ""], profile_data))

    links = []

    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

    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()],

    ))

    # Invoices

    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,

    ))

    # Credit Notes

    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,

    ))

    # All payments

    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,

    ))

    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)

    attendees = attendees.annotate(

        has_registered=Count(

            Q(user__invoice__status=commerce.Invoice.STATUS_PAID)

        ),

    )

    headings = [

        "User ID", "Name", "Email", "Has registered",

    ]

    data = []

    for a in attendees:

        data.append([

            a.user.id,

            (profiles_by_attendee[a].attendee_name()

                if a in profiles_by_attendee else ""),

            a.user.email,

            a.has_registered > 0,

        ])

    # Sort by whether they've registered, then ID.

    data.sort(key=lambda a: (-a[3], a[0]))

    return AttendeeListReport("Attendees", headings, data, link_view=attendee)