from typing import Optional
from lbry.testcase import CommandTestCase
from lbry.schema.purchase import Purchase
from lbry.wallet.transaction import Transaction
from lbry.wallet.dewies import lbc_to_dewies, dewies_to_lbc


class PurchaseCommandTests(CommandTestCase):

    async def asyncSetUp(self):
        await super().asyncSetUp()
        self.merchant_address = await self.blockchain.get_raw_change_address()

    async def priced_stream(
        self, name='stream', price: Optional[str] = '0.2', currency='LBC', mine=False
    ) -> Transaction:
        kwargs = {}
        if price and currency:
            kwargs = {
                'fee_amount': price,
                'fee_currency': currency,
                'fee_address': self.merchant_address
            }
        if not mine:
            kwargs['claim_address'] = self.merchant_address
        file_path = self.create_upload_file(data=b'high value content')
        tx = await self.daemon.jsonrpc_stream_create(
            name, '0.01', file_path=file_path, **kwargs
        )
        await self.ledger.wait(tx)
        await self.generate(1)
        await self.ledger.wait(tx)
        await self.daemon.jsonrpc_file_delete(claim_name=name)
        return tx

    async def create_purchase(self, name, price):
        stream = await self.priced_stream(name, price)
        claim_id = stream.outputs[0].claim_id
        purchase = await self.daemon.jsonrpc_purchase_create(claim_id)
        await self.ledger.wait(purchase)
        return claim_id

    async def assertStreamPurchased(self, stream: Transaction, operation):

        await self.account.release_all_outputs()
        buyer_balance = await self.account.get_balance()
        merchant_balance = lbc_to_dewies(await self.blockchain.get_balance())
        pre_purchase_count = (await self.daemon.jsonrpc_purchase_list())['total_items']
        purchase = await operation()
        stream_txo, purchase_txo = stream.outputs[0], purchase.outputs[0]
        stream_fee = stream_txo.claim.stream.fee
        self.assertEqual(stream_fee.dewies, purchase_txo.amount)
        self.assertEqual(stream_fee.address, purchase_txo.get_address(self.ledger))

        await self.ledger.wait(purchase)
        await self.generate(1)
        merchant_balance += lbc_to_dewies('1.0')  # block reward
        await self.ledger.wait(purchase)

        self.assertEqual(
            await self.account.get_balance(), buyer_balance - (purchase.input_sum-purchase.outputs[2].amount))
        self.assertEqual(
            str(float(await self.blockchain.get_balance())),
            dewies_to_lbc(merchant_balance + purchase_txo.amount)
        )

        purchases = await self.daemon.jsonrpc_purchase_list()
        self.assertEqual(purchases['total_items'], pre_purchase_count+1)

        tx = purchases['items'][0].tx_ref.tx
        self.assertEqual(len(tx.outputs), 3)  # purchase txo, purchase data, change

        txo0 = tx.outputs[0]
        txo1 = tx.outputs[1]
        self.assertEqual(txo0.purchase, txo1)  # purchase txo has reference to purchase data
        self.assertTrue(txo1.is_purchase_data)
        self.assertTrue(txo1.can_decode_purchase_data)
        self.assertIsInstance(txo1.purchase_data, Purchase)
        self.assertEqual(txo1.purchase_data.claim_id, stream_txo.claim_id)

    async def test_purchasing(self):
        stream = await self.priced_stream()
        claim_id = stream.outputs[0].claim_id

        # explicit purchase of claim
        await self.assertStreamPurchased(stream, lambda: self.daemon.jsonrpc_purchase_create(claim_id))

        # check that `get` doesn't purchase it again
        balance = await self.account.get_balance()
        response = await self.daemon.jsonrpc_get('lbry://stream')
        self.assertIsNone(response.content_fee)
        self.assertEqual(await self.account.get_balance(), balance)
        self.assertItemCount(await self.daemon.jsonrpc_purchase_list(), 1)

        # `get` does purchase a stream we don't have yet
        another_stream = await self.priced_stream('another')

        async def imagine_its_a_lambda():
            response = await self.daemon.jsonrpc_get('lbry://another')
            return response.content_fee

        await self.assertStreamPurchased(another_stream, imagine_its_a_lambda)

        # purchase non-existent claim fails
        with self.assertRaisesRegex(Exception, "Could not find claim with claim_id"):
            await self.daemon.jsonrpc_purchase_create('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')

        # purchase stream with no price fails
        no_price_stream = await self.priced_stream('no_price_stream', price=None)
        with self.assertRaisesRegex(Exception, "does not have a purchase price"):
            await self.daemon.jsonrpc_purchase_create(no_price_stream.outputs[0].claim_id)

        # purchase claim you already own fails
        with self.assertRaisesRegex(Exception, "You already have a purchase for claim_id"):
            await self.daemon.jsonrpc_purchase_create(claim_id)

        # force purchasing claim you already own
        await self.assertStreamPurchased(
            stream, lambda: self.daemon.jsonrpc_purchase_create(claim_id, allow_duplicate_purchase=True)
        )

        # purchase by uri
        abc_stream = await self.priced_stream('abc')
        await self.assertStreamPurchased(abc_stream, lambda: self.daemon.jsonrpc_purchase_create(url='lbry://abc'))

        # purchase without valid exchange rate fails
        erm = self.daemon.component_manager.get_component('exchange_rate_manager')
        for feed in erm.market_feeds:
            feed.last_check -= 10_000
        with self.assertRaisesRegex(Exception, "Unable to convert 50 from USD to LBC"):
            await self.daemon.jsonrpc_purchase_create(claim_id, allow_duplicate_purchase=True)

    async def test_purchase_and_transaction_list(self):
        self.assertItemCount(await self.daemon.jsonrpc_purchase_list(), 0)
        self.assertItemCount(await self.daemon.jsonrpc_transaction_list(), 1)

        claim_id1 = await self.create_purchase('a', '1.0')
        claim_id2 = await self.create_purchase('b', '1.0')

        result = await self.out(self.daemon.jsonrpc_purchase_list())
        self.assertItemCount(await self.daemon.jsonrpc_transaction_list(), 5)
        self.assertItemCount(result, 2)
        self.assertEqual(result['items'][0]['type'], 'purchase')
        self.assertEqual(result['items'][0]['claim_id'], claim_id2)
        self.assertNotIn('claim', result['items'][0])
        self.assertEqual(result['items'][1]['type'], 'purchase')
        self.assertEqual(result['items'][1]['claim_id'], claim_id1)
        self.assertNotIn('claim', result['items'][1])

        result = await self.out(self.daemon.jsonrpc_purchase_list(resolve=True))
        self.assertEqual(result['items'][0]['claim']['name'], 'b')
        self.assertEqual(result['items'][1]['claim']['name'], 'a')

        result = await self.daemon.jsonrpc_transaction_list()
        self.assertEqual(result['items'][0]['purchase_info'][0]['claim_id'], claim_id2)
        self.assertEqual(result['items'][2]['purchase_info'][0]['claim_id'], claim_id1)

        result = await self.claim_search(include_purchase_receipt=True)
        self.assertEqual(result[0]['claim_id'], result[0]['purchase_receipt']['claim_id'])
        self.assertEqual(result[1]['claim_id'], result[1]['purchase_receipt']['claim_id'])

        url = result[0]['canonical_url']
        resolve = await self.resolve(url, include_purchase_receipt=True)
        self.assertEqual(result[0]['claim_id'], resolve['purchase_receipt']['claim_id'])

        self.assertItemCount(await self.daemon.jsonrpc_file_list(), 0)
        await self.daemon.jsonrpc_get('lbry://a')
        await self.daemon.jsonrpc_get('lbry://b')
        files = await self.file_list()
        self.assertEqual(files[0]['claim_id'], files[0]['purchase_receipt']['claim_id'])
        self.assertEqual(files[1]['claim_id'], files[1]['purchase_receipt']['claim_id'])

    async def test_seller_can_spend_received_purchase_funds(self):
        self.merchant_address = await self.account.receiving.get_or_create_usable_address()
        daemon2 = await self.add_daemon()
        address2 = await daemon2.wallet_manager.default_account.receiving.get_or_create_usable_address()
        await self.send_to_address_and_wait(address2, 2, 1, ledger=daemon2.ledger)

        stream = await self.priced_stream('a', '1.0')
        await self.assertBalance(self.account, '9.987893')
        self.assertItemCount(await self.daemon.jsonrpc_utxo_list(), 1)

        purchase = await daemon2.jsonrpc_purchase_create(stream.outputs[0].claim_id)
        await self.ledger.wait(purchase)
        await self.generate(1)
        await self.ledger.wait(purchase)

        # confirm that available and reserved take into account purchase received
        self.assertEqual(await self.account.get_detailed_balance(), {
            'total': 1099789300,
            'available': 1098789300,
            'reserved': 1000000,
            'reserved_subtotals': {'claims': 1000000, 'supports': 0, 'tips': 0}
        })
        self.assertItemCount(await self.daemon.jsonrpc_utxo_list(), 2)

        spend = await self.daemon.jsonrpc_wallet_send('10.5', address2)
        await self.ledger.wait(spend)
        await self.generate(1)
        await self.ledger.wait(spend)
        await self.assertBalance(self.account, '0.487695')
        self.assertItemCount(await self.daemon.jsonrpc_utxo_list(), 1)

    async def test_owner_not_required_purchase_own_content(self):
        await self.priced_stream(mine=True)
        # check that `get` doesn't purchase own claim
        balance = await self.account.get_balance()
        response = await self.daemon.jsonrpc_get('lbry://stream')
        self.assertIsNone(response.content_fee)
        self.assertEqual(await self.account.get_balance(), balance)
        self.assertItemCount(await self.daemon.jsonrpc_purchase_list(), 0)