"""Ledger_account_contract model tests."""

from datetime import datetime, timedelta
from decimal import Decimal

import pytest

from ledger.models.ledger_account_contract import LedgerAccountContract
from ledger.schemas.ledger_account_contract import LedgerAccountContractListSchema

from tests.conftest import mock_account, mock_contract
from tests.utils.factories import LedgerAccountContractFactory


def test_create_ledger_account_contract(mock_event_fixtures):
    """Create a ledger account contract."""
    LedgerAccountContract.create(
        account_id=1,
        abacus_event_id=1,
        contract_id=1,
        currency_code='USD',
        currency_amount=5050.50,
        previous_balance=10000,
        current_balance=-2020.20,
        note='credit ledger item',
    )
    ledgers = LedgerAccountContract.query.all()
    assert len(ledgers) == 1
    ledger_entry = ledgers[0]
    assert ledger_entry.account_id == 1
    assert ledger_entry.abacus_event_id == 1
    assert ledger_entry.contract_id == 1
    assert ledger_entry.currency_code == 'USD'
    assert ledger_entry.currency_amount == Decimal('5050.50')
    assert ledger_entry.previous_balance == Decimal('10000')
    assert ledger_entry.current_balance == Decimal('-2020.20')
    assert ledger_entry.note == 'credit ledger item'


def test_create_ledger_account_contract_requires_contract(mock_event_fixtures):
    """Create a ledger account contract without contract_id raises exception."""
    with pytest.raises(Exception, match="Column 'contract_id' cannot be null"):
        LedgerAccountContract.create(
            account_id=1,
            abacus_event_id=1,
            contract_id=None,
            currency_code='USD',
            currency_amount=5050.50,
            previous_balance=10000,
            current_balance=-2020.20,
            note='credit ledger item',
        )


def test_get_by_account_id(mock_event_fixtures):
    """Test getting ledger account contract entries by account_id ordered by most recent."""
    account_id = 1
    yesterday = datetime.now() - timedelta(days=1)

    entry_1 = LedgerAccountContractFactory.create(
        account_id=account_id, created_at=yesterday
    )
    LedgerAccountContractFactory.create(account_id=50)

    account_contract_ledgers = LedgerAccountContract.get_by_account_id(account_id).all()
    assert account_contract_ledgers[0] == entry_1


def test_get_ledger_account_contract_balance_by_account(mock_event_fixtures):
    """Test to get most recent current balances by account."""
    account_id = 2
    mock_account(account_id)
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=3,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    contract_1_balance = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=63.4,
        previous_balance=78.0,
        current_balance=141.4,
        note='credit ledger item',
    )

    contract_3_balance = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=3,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=3230,
        previous_balance=100.0,
        current_balance=3330.0,
        note='credit ledger item',
    )

    account_contract_ledgers = (
        LedgerAccountContract.get_ledger_account_contract_balance_by_account(
            account_id
        ).all()
    )
    assert (
        account_contract_ledgers[0].ledger_account_contract_id
        == contract_3_balance.ledger_account_contract_id
    )
    assert (
        account_contract_ledgers[0].current_balance
        == contract_3_balance.current_balance
    )
    assert (
        account_contract_ledgers[1].ledger_account_contract_id
        == contract_1_balance.ledger_account_contract_id
    )
    assert (
        account_contract_ledgers[1].current_balance
        == contract_1_balance.current_balance
    )
    assert len(account_contract_ledgers) == 2


def test_get_ledger_account_contract_balance_by_contract(mock_event_fixtures):
    """Test to get most recent current balance by contract."""
    account_id = 2
    mock_account(account_id)
    contract_id = 3
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=63.4,
        previous_balance=78.0,
        current_balance=141.4,
        note='credit ledger item',
    )

    contract_3_balance = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=3230,
        previous_balance=100.0,
        current_balance=3330.0,
        note='credit ledger item',
    )

    account_contract_ledgers = (
        LedgerAccountContract.get_ledger_account_contract_balance_by_contract(
            contract_id
        ).all()
    )
    assert (
        account_contract_ledgers[0].ledger_account_contract_id
        == contract_3_balance.ledger_account_contract_id
    )
    assert (
        account_contract_ledgers[0].current_balance
        == contract_3_balance.current_balance
    )
    assert len(account_contract_ledgers) == 1


def test_get_ledger_account_contract_balance_by_contracts(mock_event_fixtures):
    """Test to get most recent current balance by contract_ids."""
    account_id = 2
    mock_account(account_id)
    contract_id = 3
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )
    contract_2_balance = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=2,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=63.4,
        previous_balance=78.0,
        current_balance=141.4,
        note='credit ledger item',
    )

    contract_3_balance = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=3230,
        previous_balance=100.0,
        current_balance=3330.0,
        note='credit ledger item',
    )

    acc_contract_ledgers = (
        LedgerAccountContract.get_ledger_account_contract_balance_by_contracts(
            [contract_id, contract_2_balance.contract_id]
        ).all()
    )

    assert (
        acc_contract_ledgers[0].ledger_account_contract_id
        == contract_2_balance.ledger_account_contract_id
    )
    assert acc_contract_ledgers[0].current_balance == contract_2_balance.current_balance
    assert (
        acc_contract_ledgers[1].ledger_account_contract_id
        == contract_3_balance.ledger_account_contract_id
    )
    assert acc_contract_ledgers[1].current_balance == contract_3_balance.current_balance
    assert len(acc_contract_ledgers) == 2


def test_get_payable_balance_by_account(mock_event_fixtures):
    """Test account's payable balance only sums the positive contract balances."""
    account_id = 2
    currency_code = 'USD'
    mock_account(account_id)
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=2,
        currency_code=currency_code,
        current_balance=1000.00,
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=2,
        abacus_event_id=2,
        currency_code=currency_code,
        current_balance=-100.00,
    )
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=3,
        abacus_event_id=2,
        currency_code=currency_code,
        current_balance=2000.00,
    )

    res = LedgerAccountContract.get_payable_balance_by_account(account_id)

    assert res.account_id == account_id
    assert res.currency_code == 'USD'
    assert res.payable_balance == Decimal('3000.00')


def test_get_ledger_account_contract_balances_no_filter(mock_event_fixtures):
    """Test to get most recent current balances without filters."""
    account_id = 2
    mock_account(account_id)
    contract_id = 3
    first_ledger_entry = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    second_ledger_entry = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    results = LedgerAccountContract.get_ledger_account_contract_balances([], []).all()
    assert len(results) == 2
    assert (
        results[0].ledger_account_contract_id
        == first_ledger_entry.ledger_account_contract_id
    )
    assert (
        results[1].ledger_account_contract_id
        == second_ledger_entry.ledger_account_contract_id
    )


def test_get_ledger_account_contract_balances_contract_filter(mock_event_fixtures):
    """Test to get most recent current balances by contract ids."""
    account_id = 2
    mock_account(account_id)
    contract_id = 3
    LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    ledger_entry = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=contract_id,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    results = LedgerAccountContract.get_ledger_account_contract_balances(
        contract_ids=[contract_id], account_ids=[]
    ).all()
    assert len(results) == 1
    assert (
        results[0].ledger_account_contract_id == ledger_entry.ledger_account_contract_id
    )


def test_get_ledger_account_contract_balances_accounts_filter(mock_event_fixtures):
    """Test to get most recent current balances by accounts ids."""
    alt_account_id = 1
    account_id = 2
    mock_account(account_id)

    ledger_entry = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=alt_account_id,
        contract_id=2,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    results = LedgerAccountContract.get_ledger_account_contract_balances(
        contract_ids=[], account_ids=[account_id]
    ).all()
    assert len(results) == 1
    assert (
        results[0].ledger_account_contract_id == ledger_entry.ledger_account_contract_id
    )


def test_get_ledger_account_contract_balances_all_filters(mock_event_fixtures):
    """Test to get most recent current balances by contract and accounts ids."""
    account_id = 2
    mock_account(account_id)
    mock_account(3)
    mock_contract(10)

    ledger_entry = LedgerAccountContractFactory.create(
        account_id=account_id,
        contract_id=1,
        abacus_event_id=1,
        currency_code='EUR',
        currency_amount=78.0,
        previous_balance=0,
        current_balance=78.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=1,
        contract_id=2,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )
    LedgerAccountContractFactory.create(
        account_id=3,
        contract_id=3,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    alt_ledger_entry = LedgerAccountContractFactory.create(
        account_id=1,
        contract_id=10,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=100.0,
        previous_balance=0,
        current_balance=100.0,
        note='opening balance',
    )

    results = LedgerAccountContract.get_ledger_account_contract_balances(
        contract_ids=[1, 3, 10], account_ids=[account_id, 1]
    ).all()
    assert len(results) == 2
    assert (
        results[0].ledger_account_contract_id == ledger_entry.ledger_account_contract_id
    )
    assert (
        results[1].ledger_account_contract_id
        == alt_ledger_entry.ledger_account_contract_id
    )


def test_get_ledger_list_by_account_id(mock_event_fixtures):
    """Test getting list of ledgers by account_id."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=24,
        currency_code='USD',
        currency_amount=-1000.0,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='mechanical deduction (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=0,
        current_balance=-100.0,
        note='take reserves (debit)',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=5000.0,
        previous_balance=-100.00,
        current_balance=4900.00,
        note='close accounting period (credit)',
        contract_id=2,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=9,
        currency_code='USD',
        currency_amount=500.0,
        previous_balance=-100.00,
        current_balance=400.00,
        note='commit accounting run (credit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=3,
        currency_code='USD',
        currency_amount=25.00,
        previous_balance=4900.00,
        current_balance=4925.00,
        note='release reserves (credit)',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=5,
        currency_code='USD',
        currency_amount=-502.37,
        previous_balance=4925.00,
        current_balance=4422.63,
        note='adjustments applied (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=6,
        currency_code='USD',
        currency_amount=-4422.63,
        previous_balance=4422.63,
        current_balance=0.00,
        note='payment accepted (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=8,
        currency_code='USD',
        currency_amount=4422.63,
        previous_balance=0.00,
        current_balance=4422.63,
        note='payoneer canceled this payment so sad',
        contract_id=1,
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0
    )

    assert total_count == 8

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert data[0]['ledger_account_contract_id'] == 8
    assert data[0]['ending_balance'] == '4422.63'
    assert data[0]['opening_balance'] == '0.00'
    assert data[0]['currency_code'] == 'USD'
    assert data[0]['transaction_type'] == 'payment_returned'
    assert data[0]['contract_id'] == 1

    assert data[1]['ledger_account_contract_id'] == 7
    assert data[1]['ending_balance'] == '0.00'
    assert data[1]['opening_balance'] == '4422.63'
    assert data[1]['currency_code'] == 'USD'
    assert data[1]['transaction_type'] == 'send_payments'
    assert data[1]['contract_id'] == 1

    assert data[2]['ledger_account_contract_id'] == 6
    assert data[2]['ending_balance'] == '4422.63'
    assert data[2]['amount'] == '-502.37'
    assert data[2]['opening_balance'] == '4925.00'
    assert data[2]['currency_code'] == 'USD'
    assert data[2]['transaction_type'] == 'apply_pending_adjustments'
    assert data[2]['contract_id'] == 1

    assert data[3]['ledger_account_contract_id'] == 5
    assert data[3]['ending_balance'] == '4925.00'
    assert data[3]['opening_balance'] == '4900.00'
    assert data[3]['currency_code'] == 'USD'
    assert data[3]['transaction_type'] == 'release_reserves'
    assert data[3]['contract_id'] == 1

    # commit royalties event tied to accounting run
    assert data[4]['ledger_account_contract_id'] == 4
    assert data[4]['ending_balance'] == '400.00'
    assert data[4]['amount'] == '500.00'
    assert data[4]['opening_balance'] == '-100.00'
    assert data[4]['currency_code'] == 'USD'
    assert data[4]['transaction_type'] == 'commit_royalties'
    assert data[4]['contract_id'] == 1

    # commit royalties event tied to accounting period
    assert data[5]['ledger_account_contract_id'] == 3
    assert data[5]['ending_balance'] == '4900.00'
    assert data[5]['amount'] == '5000.00'
    assert data[5]['opening_balance'] == '-100.00'
    assert data[5]['currency_code'] == 'USD'
    assert data[5]['transaction_type'] == 'commit_royalties'
    assert data[5]['contract_id'] == 2

    assert data[6]['ledger_account_contract_id'] == 2
    assert data[6]['ending_balance'] == '-100.00'
    assert data[6]['opening_balance'] == '0.00'
    assert data[6]['currency_code'] == 'USD'
    assert data[6]['transaction_type'] == 'take_reserves'
    assert data[6]['contract_id'] == 1

    assert data[7]['ledger_account_contract_id'] == 1
    assert data[7]['ending_balance'] == '4000.00'
    assert data[7]['amount'] == '-1000.00'
    assert data[7]['opening_balance'] == '5000.00'
    assert data[7]['currency_code'] == 'USD'
    assert data[7]['transaction_type'] == 'commit_mechanicals'
    assert data[7]['contract_id'] == 1


def test_get_ledger_list_by_account_id_and_event_names(mock_event_fixtures):
    """Test getting list of ledgers by account_id and event names."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=24,
        currency_code='USD',
        currency_amount=-1000.0,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='mechanical deduction (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=0,
        current_balance=-100.0,
        note='take reserves (debit)',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=2,
        currency_code='USD',
        currency_amount=5000.0,
        previous_balance=-100.00,
        current_balance=4900.00,
        note='close accounting period (credit)',
        contract_id=2,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=9,
        currency_code='USD',
        currency_amount=500.0,
        previous_balance=-100.00,
        current_balance=400.00,
        note='commit accounting run (credit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=3,
        currency_code='USD',
        currency_amount=25.00,
        previous_balance=4900.00,
        current_balance=4925.00,
        note='release reserves (credit)',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=5,
        currency_code='USD',
        currency_amount=-502.37,
        previous_balance=4925.00,
        current_balance=4422.63,
        note='adjustments applied (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=6,
        currency_code='USD',
        currency_amount=-4422.63,
        previous_balance=4422.63,
        current_balance=0.00,
        note='payment accepted (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=8,
        currency_code='USD',
        currency_amount=4422.63,
        previous_balance=0.00,
        current_balance=4422.63,
        note='payoneer canceled this payment so sad',
        contract_id=1,
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0, 'send_payments,payment_returned'
    )

    assert total_count == 2

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert data[0]['ending_balance'] == '4422.63'
    assert data[0]['opening_balance'] == '0.00'
    assert data[0]['currency_code'] == 'USD'
    assert data[0]['transaction_type'] == 'payment_returned'
    assert data[0]['contract_id'] == 1

    assert data[1]['ending_balance'] == '0.00'
    assert data[1]['opening_balance'] == '4422.63'
    assert data[1]['currency_code'] == 'USD'
    assert data[1]['transaction_type'] == 'send_payments'
    assert data[1]['contract_id'] == 1


def test_get_ledger_list_by_account_id_and_statement_period_ids(mock_event_fixtures):
    """Test getting list of ledgers by account_id and statement period ids."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=24,
        currency_code='USD',
        currency_amount=-1000.0,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='mechanical deduction (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=0,
        current_balance=-100.0,
        note='take reserves (debit)',
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0, None, '1,2,3'
    )

    assert total_count == 2

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert all(d['statement_period_id'] == 1 for d in data)


def test_get_ledger_list_by_account_id_and_contract_ids(mock_event_fixtures):
    """Test getting list of ledgers by account_id and contract ids."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=24,
        currency_code='USD',
        currency_amount=-1000.0,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='mechanical deduction (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=0,
        current_balance=-100.0,
        note='take reserves (debit)',
        contract_id=2,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=5,
        currency_code='USD',
        currency_amount=-502.37,
        previous_balance=4925.00,
        current_balance=4422.63,
        note='adjustments applied (debit)',
        contract_id=1,
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0, None, None, '1,3,4'
    )

    assert total_count == 2

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert all(d['contract_id'] == 1 for d in data)


def test_get_ledger_list_by_account_id_and_filters(mock_event_fixtures):
    """Test getting list of ledgers by account_id and event names/statement period ids."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=24,
        currency_code='USD',
        currency_amount=-1000.0,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='mechanical deduction (debit)',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=1,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=0,
        current_balance=-100.0,
        note='take reserves (debit)',
        contract_id=1,
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0, 'take_reserves,commit_royalties', '1,2,3', '1,2,3'
    )

    assert total_count == 1

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert all(d['statement_period_id'] == 1 for d in data)
    assert all(d['contract_id'] == 1 for d in data)


def test_get_ledger_list_by_account_id_for_custom_payments(mock_event_fixtures):
    """Test getting list of ledgers by account_id for custom payments."""
    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=25,
        currency_code='USD',
        currency_amount=-1000.00,
        previous_balance=5000.00,
        current_balance=4000.00,
        note='Commit custom payment',
        contract_id=1,
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=26,
        currency_code='USD',
        currency_amount=-200.00,
        previous_balance=4000,
        current_balance=3800.0,
        note='Commit VAT summary',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=27,
        currency_code='USD',
        currency_amount=100.00,
        previous_balance=3800.00,
        current_balance=3900.00,
        note='Commit WHT',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=28,
        currency_code='USD',
        currency_amount=1000.00,
        previous_balance=3900.00,
        current_balance=4900.00,
        note='Return custom payment',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=29,
        currency_code='USD',
        currency_amount=200.0,
        previous_balance=5100,
        current_balance=4900.00,
        note='Return VAT summary',
    )

    LedgerAccountContractFactory.create(
        account_id=1,
        abacus_event_id=30,
        currency_code='USD',
        currency_amount=-100.0,
        previous_balance=5000.00,
        current_balance=5100.00,
        note='Return WHT',
    )

    account_ledgers, total_count = LedgerAccountContract.get_ledger_list_by_account_id(
        1, 100, 0
    )

    assert total_count == 6

    data = LedgerAccountContractListSchema().dump(account_ledgers, many=True)

    assert data[0]['ledger_account_contract_id'] == 6
    assert data[0]['ending_balance'] == '5100.00'
    assert data[0]['opening_balance'] == '5000.00'
    assert data[0]['currency_code'] == 'USD'
    assert data[0]['transaction_type'] == 'return_withholding_tax'
    assert data[0]['contract_id'] == 1

    assert data[1]['ledger_account_contract_id'] == 5
    assert data[1]['ending_balance'] == '4900.00'
    assert data[1]['opening_balance'] == '5100.00'
    assert data[1]['currency_code'] == 'USD'
    assert data[1]['transaction_type'] == 'return_vat_summary'
    assert data[1]['contract_id'] == 1

    assert data[2]['ledger_account_contract_id'] == 4
    assert data[2]['ending_balance'] == '4900.00'
    assert data[2]['opening_balance'] == '3900.00'
    assert data[2]['currency_code'] == 'USD'
    assert data[2]['transaction_type'] == 'return_custom_payment'
    assert data[2]['contract_id'] == 1

    assert data[3]['ledger_account_contract_id'] == 3
    assert data[3]['ending_balance'] == '3900.00'
    assert data[3]['opening_balance'] == '3800.00'
    assert data[3]['currency_code'] == 'USD'
    assert data[3]['transaction_type'] == 'commit_withholding_tax'
    assert data[3]['contract_id'] == 1

    assert data[4]['ledger_account_contract_id'] == 2
    assert data[4]['ending_balance'] == '3800.00'
    assert data[4]['opening_balance'] == '4000.00'
    assert data[4]['currency_code'] == 'USD'
    assert data[4]['transaction_type'] == 'commit_vat_summary'
    assert data[4]['contract_id'] == 1

    assert data[5]['ledger_account_contract_id'] == 1
    assert data[5]['ending_balance'] == '4000.00'
    assert data[5]['opening_balance'] == '5000.00'
    assert data[5]['currency_code'] == 'USD'
    assert data[5]['transaction_type'] == 'commit_custom_payment'
    assert data[5]['contract_id'] == 1