from django.test import TestCase
from trading.models import User, Commodity, Tx, TxRequest, BalanceError


class TestTransactions(TestCase):
    def test_user_balances(self):
        # Create users
        user1 = User.objects.create_user(username="test1", email="test1@test.test")
        user2 = User.objects.create_user(username="test2", email="test2@test.test")

        # Create test commodity
        commodity = Commodity(created_by=user1, in_circulation=1000, name="commodity")
        commodity.save()

        # Confirm balances
        self.assertEqual(user1.balances(), {commodity: 1000})
        self.assertEqual(user1.balance_of(commodity), 1000)
        self.assertEqual(user2.balances(), {})
        self.assertEqual(user2.balance_of(commodity), 0)

        # Create transaction
        Tx(source=user1, dest=user2, amount=100, commodity=commodity).save()

        # Confirm balances
        self.assertEqual(user1.balances(), {commodity: 900})
        self.assertEqual(user2.balances(), {commodity: 100})

        # Ensure we can't trade when there's missing balance
        with self.assertRaises(BalanceError):
            Tx(source=user2, dest=user1, amount=1000, commodity=commodity).save()

        # Confirm balances
        self.assertEqual(user1.balances(), {commodity: 900})
        self.assertEqual(user2.balances(), {commodity: 100})

    def test_tx_requests(self):
        # Create users
        user1 = User.objects.create_user(username="test1", email="test1@test.test")
        user2 = User.objects.create_user(username="test2", email="test2@test.test")

        # Create test commodity for user1
        com1 = Commodity(created_by=user1, in_circulation=1000, name="test1")
        com1.save()

        # Create test commodity for user2
        com2 = Commodity(created_by=user2, in_circulation=1000, name="test2")
        com2.save()

        # Create TX request
        req1 = TxRequest.open(user1, user2, com1, com2, 10, 10)

        # Confirm balances
        self.assertEqual(user1.balance_of(com1), 990)
        self.assertEqual(user1.balance_of(com2), 0)
        self.assertEqual(user2.balance_of(com1), 0)
        self.assertEqual(user2.balance_of(com2), 1000)

        # Accept TX request
        req1.accept()

        # Confirm balances
        self.assertEqual(user1.balance_of(com1), 990)
        self.assertEqual(user1.balance_of(com2), 10)
        self.assertEqual(user2.balance_of(com1), 10)
        self.assertEqual(user2.balance_of(com2), 990)

        # Create TX request 
        req2 = TxRequest.open(user2, user1, com2, com1, 10, 10)

        # Confirm balances
        self.assertEqual(user1.balance_of(com1), 990)
        self.assertEqual(user1.balance_of(com2), 10)
        self.assertEqual(user2.balance_of(com1), 10)
        self.assertEqual(user2.balance_of(com2), 980)

        # Decline TX request
        req2.decline()

        # Confirm balances
        self.assertEqual(user1.balance_of(com1), 990)
        self.assertEqual(user1.balance_of(com2), 10)
        self.assertEqual(user2.balance_of(com1), 10)
        self.assertEqual(user2.balance_of(com2), 990)

        # Ensure assertions on already created TXs
        with self.assertRaises(AssertionError):
            req1.accept()
        with self.assertRaises(AssertionError):
            req1.decline()
        with self.assertRaises(AssertionError):
            req2.accept()
        with self.assertRaises(AssertionError):
            req2.decline()

        # Balance checking
        # Ensure whoever opens the request has the balance available
        with self.assertRaises(BalanceError):
            TxRequest.open(user1, user2, com2, com1, 100, 100)

        # Ensure whoever tries to accept the request has the balance available
        req3 = TxRequest.open(user1, user2, com2, com1, 10, 100)
        with self.assertRaises(BalanceError):
            req3.accept()

        # And make sure you can still decline it after failing to accept it.
        req3.decline()