"""Functional tests for Ledger Reserve Taken."""

from decimal import Decimal

from ledger.constants.constants import LEDGER_ACCOUNT_ENTRIES_SUCCESS_MSG
from ledger.constants.error import ERROR_RECORD_ALREADY_EXISTS, ERROR_UNKNOWN_CURRENCY
from ledger.models.ledger_account import LedgerAccount

from tests.utils.factories import LedgerReserveTakenFactory


def test_bulk_create_ledger_reserve_taken_entries_success(
    fixture_client, mock_bulk_ledger_reserve_taken_body, mock_event_fixtures
):
    """Test to create bulk Ledger Reserve Taken entries."""
    res = fixture_client.post(
        '/ledger-reserve-taken/bulk', json=mock_bulk_ledger_reserve_taken_body
    )
    assert res.status_code == 201
    assert len(res.json) == 2
    assert res.json == [
        {
            'ledger_reserve_taken_id': 1,
            'abacus_event_id': 1,
            'accounting_run_id': 1,
            'contract_reserve_id': 1,
            'currency_code': 'USD',
            'gross_returns': '-50.00',
            'gross_sales': '200.00',
            'net_revenue': '150.00',
            'net_revenue_after_reserve': '100.00',
            'reserve_amount': '50.00',
            'statement_period_id': 1,
        },
        {
            'ledger_reserve_taken_id': 2,
            'abacus_event_id': 1,
            'accounting_run_id': 1,
            'contract_reserve_id': 2,
            'currency_code': 'AUD',
            'gross_returns': '-30.00',
            'gross_sales': '80.00',
            'net_revenue': '65.10',
            'net_revenue_after_reserve': '53.10',
            'reserve_amount': '118.20',
            'statement_period_id': 1,
        },
    ]


def test_bulk_create_ledger_reserve_taken_entries_invalid_post_body(
    fixture_client,
    mock_bulk_ledger_reserve_taken_body,
):
    """Test error is returned when POST body contains duplicates."""
    params = [
        mock_bulk_ledger_reserve_taken_body[0],
        mock_bulk_ledger_reserve_taken_body[0],
    ]

    res = fixture_client.post('/ledger-reserve-taken/bulk', json=params)

    assert res.status_code == 400
    assert res.json.get('code') == 'error'
    assert res.json.get('message')


def test_bulk_create_ledger_reserve_taken_entries_invalid_currency(
    fixture_client, mock_bulk_ledger_reserve_taken_body, mock_event_fixtures
):
    """Test bulk creating ledger_reserve_taken entries validates currency code."""
    mock_bulk_ledger_reserve_taken_body[0]['currency_code'] = 'test'
    res = fixture_client.post(
        '/ledger-reserve-taken/bulk', json=mock_bulk_ledger_reserve_taken_body
    )

    assert res.status_code == 400
    assert res.json.get('code') == 'error'
    assert res.json.get('message') == ERROR_UNKNOWN_CURRENCY.format(code='test')


def test_bulk_create_ledger_reserve_taken_entries_duplicate_entry(
    fixture_client, mock_bulk_ledger_reserve_taken_body, mock_event_fixtures
):
    """Test bulk creating ledger_reserve_taken entries validates currency code."""
    abacus_event_id = mock_bulk_ledger_reserve_taken_body[0]['abacus_event_id']
    accounting_run_id = mock_bulk_ledger_reserve_taken_body[0]['accounting_run_id']
    contract_reserve_id = mock_bulk_ledger_reserve_taken_body[0]['contract_reserve_id']

    LedgerReserveTakenFactory.create(
        abacus_event_id=abacus_event_id,
        accounting_run_id=accounting_run_id,
        contract_reserve_id=contract_reserve_id,
    )

    res = fixture_client.post(
        '/ledger-reserve-taken/bulk', json=mock_bulk_ledger_reserve_taken_body
    )

    assert res.status_code == 400
    assert res.json.get('code') == 'error'
    assert res.json.get('message') == ERROR_RECORD_ALREADY_EXISTS.format(
        {
            'abacus_event_id': abacus_event_id,
            'accounting_run_id': accounting_run_id,
            'contract_reserve_id': contract_reserve_id,
        }
    )


def test_get_ledger_reserve_taken_by_accounting_run_id(
    fixture_client, mock_event_fixtures
):
    """Test to get list of Ledger Reserve Taken by accounting run id."""
    accounting_run_id = 1
    LedgerReserveTakenFactory.create()
    LedgerReserveTakenFactory.create(accounting_run_id=2)

    result = fixture_client.get(
        f'/ledger-reserve-taken/accounting-run/{accounting_run_id}'
    )

    assert result.status_code == 200
    assert result.json['items'] == [
        {
            'ledger_reserve_taken_id': 1,
            'abacus_event_id': 1,
            'account_id': 1,
            'accounting_run_id': 1,
            'contract_id': 1,
            'contract_reserve_id': 1,
            'currency_code': 'USD',
            'gross_returns': '-50.00',
            'gross_sales': '150.00',
            'net_revenue': '104.00',
            'net_revenue_after_reserve': '44.00',
            'reserve_amount': '-60.00',
            'statement_period_id': 1,
        }
    ]
    assert result.json['total_count'] == 1


def test_debit_reserves_from_ledger_account_by_run(fixture_client, mock_event_fixtures):
    """Test to debit reserves from ledger_account for ledger_reserve_taken entries."""
    accounting_run_id = 1
    LedgerReserveTakenFactory.create()

    result = fixture_client.post(
        f'/ledger-reserve-taken/accounting-run/{accounting_run_id}'
    )

    ledger_account_entry = LedgerAccount.query.all()
    assert result.status_code == 201
    assert result.json['message'] == LEDGER_ACCOUNT_ENTRIES_SUCCESS_MSG.format(
        len(ledger_account_entry)
    )

    assert ledger_account_entry[0].current_balance == Decimal('-60.00')
    assert ledger_account_entry[0].currency_code == 'USD'
    assert ledger_account_entry[0].abacus_event_id == 1
    assert ledger_account_entry[0].previous_balance == Decimal('0.00')
    assert ledger_account_entry[0].currency_amount == Decimal('-60.00')