from django.db import transaction

from django.db.models import Sum

from django.utils import timezone

from registrasion.models import commerce

from registrasion.models import conditions

from registrasion.models import people

from cart import CartController

from credit_note import CreditNoteController

from for_id import ForId

class InvoiceController(ForId, object):

    __MODEL__ = commerce.Invoice

    def __init__(self, invoice):

        self.invoice = invoice

        self.update_status()

        self.update_validity()  # Make sure this invoice is up-to-date

    @classmethod

    def for_cart(cls, cart):

        ''' Returns an invoice object for a given cart at its current revision.

        total_paid = self.total_payments()

        num_payments = commerce.PaymentBase.objects.filter(

            invoice=self.invoice,

        ).count()

        remainder = self.invoice.value - total_paid

        if old_status == commerce.Invoice.STATUS_UNPAID:

            # Invoice had an amount owing

            if remainder <= 0:

                # Invoice no longer has amount owing

                self._mark_paid()

            elif total_paid == 0 and num_payments > 0:

                # Invoice has multiple payments totalling zero

                self._mark_void()

        elif old_status == commerce.Invoice.STATUS_PAID:

            if remainder > 0:

                # Invoice went from having a remainder of zero or less

                # to having a positive remainder -- must be a refund

                self._mark_refunded()

        elif old_status == commerce.Invoice.STATUS_REFUNDED:

            # Should not ever change from here

            pass

        elif old_status == commerce.Invoice.STATUS_VOID:

            # Should not ever change from here

            pass

    def _mark_paid(self):

        ''' Marks the invoice as paid, and updates the attached cart if

        necessary. '''

        cart = self.invoice.cart

        if cart:

            cart.active = False

            cart.save()

        self.invoice.status = commerce.Invoice.STATUS_PAID

        self.invoice.save()

    def _mark_refunded(self):

        ''' Marks the invoice as refunded, and updates the attached cart if

            old_quantity = product_item.quantity

        except ObjectDoesNotExist:

            old_quantity = 0

        self.set_quantity(product, old_quantity + quantity)

    def next_cart(self):

        self.cart.active = False

        self.cart.save()

class TestingInvoiceController(InvoiceController):

        ''' Testing method for simulating an invoice paymenht by the given

        amount. '''

        ''' Adds a payment '''

        commerce.ManualPayment.objects.create(

            invoice=self.invoice,

            reference=reference,

            amount=amount,

        )

        self.update_status()

class TestingCreditNoteController(CreditNoteController):

UTC = pytz.timezone('UTC')

class InvoiceTestCase(RegistrationCartTestCase):

    def _invoice_containing_prod_1(self, qty=1):

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, qty)

        return TestingInvoiceController.for_cart(self.reget(cart.cart))

    def test_create_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)

        # That invoice should have a single line item

        line_items = commerce.LineItem.objects.filter(

            invoice=invoice_1.invoice,

        )

        self.assertEqual(1, len(line_items))

        # That invoice should have a value equal to cost of PROD_1

        self.assertEqual(to_pay, credit_notes[0].value)

    def test_apply_credit_note_pays_invoice(self):

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        # There should be one credit note generated out of the invoice.

        # That credit note should be in the unclaimed pile

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        # Create a new (identical) cart with invoice

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice2 = TestingInvoiceController.for_cart(self.reget(cart.cart))

        cn.apply_to_invoice(invoice2.invoice)

        self.assertTrue(invoice2.invoice.is_paid)

        self.assertEquals(0, commerce.CreditNote.unclaimed().count())

    def test_apply_credit_note_generates_new_credit_note_if_overpaying(self):

        invoice = self._invoice_containing_prod_1(2)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        # There should be one credit note generated out of the invoice.

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        # Create a new cart (of half value of inv 1) and get invoice

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice2 = TestingInvoiceController.for_cart(self.reget(cart.cart))

        cn.apply_to_invoice(invoice2.invoice)

        self.assertTrue(invoice2.invoice.is_paid)

        )

    def test_cannot_apply_credit_note_on_invalid_invoices(self):

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        # There should be one credit note generated out of the invoice.

        # Create a new cart with invoice, pay it

        invoice_2 = self._invoice_containing_prod_1(1)

        invoice_2.pay("LOL", invoice_2.invoice.value)

        # Cannot pay paid invoice

        with self.assertRaises(ValidationError):

            cn.apply_to_invoice(invoice_2.invoice)

        invoice_2.refund()

        # Cannot pay refunded invoice

        with self.assertRaises(ValidationError):

    def test_cannot_apply_a_refunded_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        cn.refund()

        # Refunding a credit note should mark it as claimed

        self.assertEquals(0, commerce.CreditNote.unclaimed().count())

        # Create a new cart with invoice

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart))

        # Cannot pay with this credit note.

    def test_cannot_refund_an_applied_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        # Create a new cart with invoice

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart))

        cn.apply_to_invoice(invoice_2.invoice)

        self.assertEquals(0, commerce.CreditNote.unclaimed().count())

        # Cannot refund this credit note as it is already applied.

        with self.assertRaises(ValidationError):

            cn.refund()