"""Tests for account model."""
from decimal import Decimal

from abacus_common_logic.connectors.database import db
import pytest

from abacus_account.constants.constants import BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES
from abacus_account.models.account import Account
from abacus_account.models.account_payee import AccountPayee
from tests.utils.factories import (
    AccountFactory, AccountPayeeFactory, AccountPaymentTermFactory,
    ReferencePaymentTypeFactory
)


def test_get_account_by_id():
    """Test getting an account by account id."""
    account = AccountFactory.create()
    account_info = Account.get_by_id(account.account_id)
    assert account_info.account_name == account.account_name
    assert account_info.account_id == account.account_id
    assert account_info.created_by == account.created_by
    assert account_info.sap_created_at == account.sap_created_at


def test_get_eligible_for_payment(account_payment_eligible):
    """Get accounts eligible for payment."""
    accounts = Account.get_eligible_for_payment(123)
    assert len(accounts) == 1

    accounts_2 = Account.get_eligible_for_payment(1)
    assert len(accounts_2) == 0


@pytest.mark.parametrize(
    'reference_payment_type_id', BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES.values()
)
def test_get_eligible_for_payment_via_closing_balance(
    account_payment_eligible_via_closing_balance,
    reference_payment_type_id
):
    """Get accounts eligible for payment via closing balance."""
    [ReferencePaymentTypeFactory.create(
        reference_payment_type_id=payment_type_id
    ) for payment_type_id in [8,11,12]]
    db.session.query(AccountPayee).update(
        {AccountPayee.reference_payment_type_id: reference_payment_type_id}
    )
    db.session.commit()
    accounts = Account.get_eligible_for_payment_via_closing_balance(123)
    assert len(accounts) == 1


def test_get_eligible_for_payment_when_ff_is_enabled(account_payment_eligible):
    """Get accounts eligible for payment."""
    accounts = Account.get_eligible_for_payment(123)
    assert len(accounts) == 1

    accounts_2 = Account.get_eligible_for_payment(1)
    assert len(accounts_2) == 0


def test_get_eligible_for_payment_multiple_contracts(
        account_payment_multiple_contract_balances):
    """Get accounts eligible for payment with multiple contract balances."""
    accounts = Account.get_eligible_for_payment(123)
    assert len(accounts) == 1
    assert accounts[0]['current_balance'] == Decimal('425.86')
    assert accounts[0]['contracts_payable'] == '[{"contract_id": 111, "currency_code": "GBP", "current_balance": 100.00}, {"contract_id": 333, "currency_code": "GBP", "current_balance": 325.86}]'  # noqa: E501


def test_get_eligible_for_payment_multiple_contracts_via_closing_balance(
    account_payment_multiple_contract_balances_via_closing_balance
):
    """Get accounts eligible for payment with multiple contract balances."""
    accounts = Account.get_eligible_for_payment_via_closing_balance(123)
    assert len(accounts) == 1
    assert accounts[0]['contracts'] == '[111, 222, 333]'


def test_get_eligible_for_payment_via_closing_balance_with_account_ids(
    account_payment_eligible_via_closing_balance_with_account_ids
):
    """Get accounts eligible for payment via closing balance."""
    accounts_multi = Account.get_eligible_for_payment_via_closing_balance(124)  # noqa: E501
    assert len(accounts_multi) == 3
    account_ids = [acc['account_id'] for acc in accounts_multi]
    assert 1000 not in account_ids
    assert 1001 in account_ids
    assert 1002 in account_ids
    assert 1003 in account_ids


def test_get_filtered_query(reference_payment_entity_fixture):
    """Get accounts by request parameters."""
    test_account = AccountFactory.create(account_name='Test Account')
    AccountFactory.create(account_name='Account Test')

    accounts = Account.get_filtered_query(
        account_name='account'
    ).all()

    assert len(accounts) == 2

    accounts = Account.get_filtered_query(
        account_name='test account'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'Test Account'

    # A account name having '\' character
    AccountFactory.create(account_name='A1 LaFlare\\Amigo Records, LLC')
    accounts = Account.get_filtered_query(
        account_name='A1 LaFlare\\Amigo'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'A1 LaFlare\\Amigo Records, LLC'

    # A account name having '%' character
    AccountFactory.create(account_name='Dylan Bukov 100% t/a Dybbukk')
    accounts = Account.get_filtered_query(
        account_name='%'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'Dylan Bukov 100% t/a Dybbukk'

    assert not Account.get_filtered_query(payment_entity_id=5).all()
    AccountPaymentTermFactory.create(
        account=test_account, payment_entity_id=5
    )
    accounts = Account.get_filtered_query(payment_entity_id=5)
    assert accounts.count() == 1
    assert accounts[0].account_name == test_account.account_name

    assert not Account.get_filtered_query(agreement_type_ids=[999]).all()
    accounts = Account.get_filtered_query(agreement_type_ids=[1])
    assert accounts.count() == 1
    assert accounts[0].account_name == test_account.account_name

    assert not Account.get_filtered_query(reference_payment_type_id=7).all()
    AccountPayeeFactory.create(
        account=test_account, reference_payment_type_id=7
    )
    accounts = Account.get_filtered_query(reference_payment_type_id=7)
    assert accounts.count() == 1
    assert accounts[0].account_name == test_account.account_name


def test_get_filtered_query_with_term_field():
    """Get accounts by search term."""
    AccountFactory.create(account_name='Test Account', account_id=78697)
    AccountFactory.create(account_name='2023 Music', account_id=97182)

    # Get accounts that contain the text "account"
    accounts = Account.get_filtered_query(
        search_term='Music'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == '2023 Music'

    # Get "Test Account"
    accounts = Account.get_filtered_query(
        search_term='test account'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'Test Account'

    # Get accounts by account_id
    accounts = Account.get_filtered_query(
        search_term='97'
    ).all()

    assert len(accounts) == 2
    assert [account.account_id for account in accounts] == [97182, 78697]

    # Get accounts with a '\' character in the account name
    AccountFactory.create(account_name='A1 LaFlare\\Amigo Records, LLC')
    accounts = Account.get_filtered_query(
        search_term='A1 LaFlare\\Amigo'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'A1 LaFlare\\Amigo Records, LLC'

    # Get accounts with a '%' character in the account name
    AccountFactory.create(account_name='Dylan Bukov 100% t/a Dybbukk')
    accounts = Account.get_filtered_query(
        search_term='%'
    ).all()

    assert len(accounts) == 1
    assert accounts[0].account_name == 'Dylan Bukov 100% t/a Dybbukk'