from __future__ import annotations

from collections.abc import Callable
from random import randint
from typing import TYPE_CHECKING
from uuid import UUID, uuid4

import pytest

from generalresearch.currency import USDCent
from generalresearch.models.thl.payout import (
    BrokerageProductPayoutEvent,
)

if TYPE_CHECKING:
    from generalresearch.managers.thl.ledger_manager.ledger import LedgerManager
    from generalresearch.managers.thl.ledger_manager.thl_ledger import (
        ThlLedgerManager,
    )
    from generalresearch.managers.thl.payout import (
        BrokerageProductPayoutEventManager,
        BusinessPayoutEventManager,
        UserPayoutEventManager,
    )
    from generalresearch.models.thl.payout import UserPayoutEvent
    from generalresearch.models.thl.product import Product


class TestThlPayoutEventManager:
    def test_get_by_uuid(
        self, brokerage_product_payout_event_manager: BrokerageProductPayoutEventManager
    ):
        """This validates that the method raises an exception if it
        fails. There are plenty of other tests that use this method so
        it seems silly to duplicate it here again
        """

        with pytest.raises(expected_exception=AssertionError) as excinfo:
            brokerage_product_payout_event_manager.get_by_uuid(pe_uuid=uuid4().hex)
        assert "expected 1 result, got 0" in str(excinfo.value)

    def test_filter_by(
        self,
        product_factory: Callable[..., Product],
        usd_cent: USDCent,
        bp_payout_event_factory: Callable[..., BrokerageProductPayoutEvent],
        thl_ledger_manager: ThlLedgerManager,
        brokerage_product_payout_event_manager: BrokerageProductPayoutEventManager,
        create_main_accounts,
    ):
        create_main_accounts()
        N_PRODUCTS = randint(3, 10)
        N_PAYOUT_EVENTS = randint(3, 10)
        amounts = []
        products = []

        for _ in range(N_PRODUCTS):
            product: Product = product_factory()
            thl_ledger_manager.get_account_or_create_bp_wallet(product=product)
            products.append(product)

            for _ in range(N_PAYOUT_EVENTS):
                pe = bp_payout_event_factory(product=product, usd_cent=usd_cent)
                amounts.append(int(usd_cent))
                assert isinstance(pe, BrokerageProductPayoutEvent)

        # We just added Payout Events for Products, now go ahead and
        #   query for them
        accounts = thl_ledger_manager.get_accounts_bp_wallet_for_products(
            product_uuids=[i.uuid for i in products]
        )
        res = brokerage_product_payout_event_manager.filter_by(
            debit_account_uuids=[i.uuid for i in accounts]
        )

        assert len(res) == (N_PRODUCTS * N_PAYOUT_EVENTS)
        assert sum([i.amount for i in res]) == sum(amounts)

    def test_get_bp_payout_events_for_product(
        self,
        product_factory: Callable[..., Product],
        usd_cent: USDCent,
        bp_payout_event_factory: Callable[..., BrokerageProductPayoutEvent],
        brokerage_product_payout_event_manager: BrokerageProductPayoutEventManager,
        thl_ledger_manager: ThlLedgerManager,
    ):

        N_PRODUCTS = randint(3, 10)
        N_PAYOUT_EVENTS = randint(3, 10)
        amounts = []
        products = []

        for _ in range(N_PRODUCTS):
            product: Product = product_factory()
            products.append(product)
            thl_ledger_manager.get_account_or_create_bp_wallet(product=product)

            for _ in range(N_PAYOUT_EVENTS):
                pe = bp_payout_event_factory(product=product, usd_cent=usd_cent)
                amounts.append(usd_cent)
                assert isinstance(pe, BrokerageProductPayoutEvent)

            # We just added 5 Payouts for a specific product: Product, now go
            # ahead and query for them
            res = brokerage_product_payout_event_manager.get_bp_bp_payout_events_for_products(
                product_uuids=[product.id]
            )

            assert len(res) == N_PAYOUT_EVENTS

        # Now that all the Payouts for all the Products have been added, go
        #   ahead and query for them
        res = (
            brokerage_product_payout_event_manager.get_bp_bp_payout_events_for_products(
                product_uuids=[i.uuid for i in products],
            )
        )

        assert len(res) == (N_PRODUCTS * N_PAYOUT_EVENTS)
        assert sum([i.amount for i in res]) == sum(amounts)

    def test_create(
        self,
        user_payout_event_factory: Callable[..., UserPayoutEvent],
        user_payout_event_manager: UserPayoutEventManager,
    ):
        from generalresearch.models.thl.payout import UserPayoutEvent

        # Confirm the creation method returns back an instance.
        pe = user_payout_event_factory()
        assert isinstance(pe, UserPayoutEvent)

        # Now query the DB for that PayoutEvent to confirm it was actually
        #   saved.
        res = user_payout_event_manager.get_by_uuid(pe_uuid=pe.uuid)
        assert isinstance(res, UserPayoutEvent)
        assert UUID(res.uuid)

        # Confirm they're the same
        # assert pe.model_dump_json() == res2.model_dump_json()
        assert res.description is None

    # def test_update(self):
    #     raise NotImplementedError

    def test_create_bp_payout(
        self,
        product: Product,
        delete_ledger_db: Callable[..., None],
        create_main_accounts: Callable[..., None],
        thl_ledger_manager: ThlLedgerManager,
        brokerage_product_payout_event_manager: BrokerageProductPayoutEventManager,
        business_payout_event_manager: BusinessPayoutEventManager,
        ledger_manager: LedgerManager,
    ):

        delete_ledger_db()
        create_main_accounts()

        account_bp_wallet = thl_ledger_manager.get_account_or_create_bp_wallet(
            product=product
        )
        rand_amount = randint(a=99, b=999)

        # Save a Brokerage Product Payout, so we have something in the
        # Payout Event table and the respective ledger TX and Entry rows for it
        bus_pe = business_payout_event_manager.create_bp_payout_event(
            thl_ledger_manager=thl_ledger_manager,
            product=product,
            amount=USDCent(rand_amount),
            ext_ref_id=uuid4().hex
        )
        pe = bus_pe.bp_payouts[0]
        assert isinstance(pe, BrokerageProductPayoutEvent)

        # Now try to query for it!
        res = thl_ledger_manager.get_tx_bp_payouts(
            account_uuids=[account_bp_wallet.uuid]
        )
        assert len(res) == 1
        res = thl_ledger_manager.get_tx_bp_payouts(account_uuids=[uuid4().hex])
        assert len(res) == 0

        # Confirm it added to the user's balance. The amount is negative because
        #   money was sent to the Brokerage product: Product, but they didn't have
        #   any activity that earned them money
        bal = ledger_manager.get_account_balance(account=account_bp_wallet)
        assert rand_amount == bal * -1


class TestBPPayoutEvent:
    def test_get_bp_bp_payout_events_for_products(
        self,
        product_factory: Callable[..., Product],
        bp_payout_event_factory: Callable[..., BrokerageProductPayoutEvent],
        usd_cent: USDCent,
        delete_ledger_db: Callable[..., None],
        create_main_accounts: Callable[..., None],
        brokerage_product_payout_event_manager: BrokerageProductPayoutEventManager,
        thl_ledger_manager: ThlLedgerManager,
    ):
        delete_ledger_db()
        create_main_accounts()

        N_PAYOUT_EVENTS = randint(3, 10)
        amounts = []

        product: Product = product_factory()
        thl_ledger_manager.get_account_or_create_bp_wallet(product=product)

        for _ in range(N_PAYOUT_EVENTS):
            bp_payout_event_factory(product=product, usd_cent=usd_cent)
            amounts.append(usd_cent)

        # Fetch using the _bp_bp_ approach, so we have an
        #   array of BPPayoutEvents
        bp_bp_res = (
            brokerage_product_payout_event_manager.get_bp_bp_payout_events_for_products(
                product_uuids=[product.uuid]
            )
        )
        assert isinstance(bp_bp_res, list)
        assert sum(amounts) == sum([i.amount for i in bp_bp_res])
        for i in bp_bp_res:
            assert isinstance(i, BrokerageProductPayoutEvent)
            assert isinstance(i.amount, int)
            assert isinstance(i.amount_usd, USDCent)
            assert isinstance(i.amount_usd_str, str)
            assert i.amount_usd_str[0] == "$"