"""Ledger Accounting Run Balance logic tests."""

from unittest.mock import patch

import pytest

from ledger.constants.constants import ERROR_INVALID_LIMIT_OFFSET, VAT_CATEGORIES_OLD
from ledger.constants.error import INVALID_VAT_CATEGORY
from ledger.logic import ledger_accounting_run_balance as logic

from tests.utils.factories import LedgerAccountingRunBalanceFactory


@patch('ledger.logic.ledger_accounting_run_balance.validate_record')
@patch('ledger.logic.ledger_accounting_run_balance.LedgerAccountingRunBalance')
@patch('ledger.logic.ledger_accounting_run_balance.db')
def test_bulk_create(
    mock_db,
    mock_model,
    mock_validate_record,
    mock_bulk_ledger_accounting_run_balances_body,
):
    """Test bulk creating ledger_accounting_run_balance entries."""
    accounting_run_id = 123

    mock_validate_record.return_value = True
    mock_model.return_value = '<ledger_accounting_run_balance>'

    res = logic.bulk_create(
        accounting_run_id, mock_bulk_ledger_accounting_run_balances_body
    )

    assert res.status == 201
    assert len(res.message) == len(mock_bulk_ledger_accounting_run_balances_body)
    assert mock_validate_record.call_count == len(
        mock_bulk_ledger_accounting_run_balances_body
    )
    assert mock_model.call_count == len(mock_bulk_ledger_accounting_run_balances_body)
    mock_db.session.bulk_save_objects.assert_called_once()
    mock_db.session.commit.assert_called_once()
    mock_db.session.close.assert_called_once()


@patch('ledger.logic.ledger_accounting_run_balance._validate_request_params')
@patch('ledger.logic.ledger_accounting_run_balance.LedgerAccountingRunBalance')
def test_get_ledger_accounting_run_balances(
    mock_model, mock_validation, mock_event_fixtures
):
    """Test getting paginated list of ledger_accounting_run_balances."""
    accounting_run_id = 1
    balances = LedgerAccountingRunBalanceFactory.create_batch(
        5, accounting_run_id=accounting_run_id
    )
    request_params = {'limit': 10, 'offset': 0}

    mock_model.find_by_accounting_run_id.return_value = (balances, len(balances))
    mock_validation.return_value = request_params

    res = logic.get_ledger_accounting_run_balances(accounting_run_id, request_params)

    assert res.status == 200
    assert res.message.get('items')
    assert res.message.get('total_count')
    mock_validation.assert_called_once_with(request_params)
    mock_model.find_by_accounting_run_id.assert_called_once_with(
        accounting_run_id, **request_params
    )


@patch('ledger.logic.ledger_accounting_run_balance._validate_request_params')
@patch('ledger.logic.ledger_accounting_run_balance.LedgerAccountingRunBalance')
def test_get_ledger_acc_run_balance_by_period_id_success(
    mock_model, mock_validation, mock_event_fixtures
):
    """Test get_ledger_acc_run_balance_by_period_id method."""
    entry = LedgerAccountingRunBalanceFactory.create()
    mock_model_response = [entry]
    vat_category = VAT_CATEGORIES_OLD.VAT_EXEMPT
    request_params = {'limit': 1, 'offset': 0}
    validated_params = {'vat_category': vat_category, 'limit': 1, 'offset': 0}

    mock_model.get_by_accounting_period_and_vat_category.return_value = (
        mock_model_response
    )
    mock_model.get_by_accounting_period_and_vat_category_count.return_value = 1
    mock_validation.return_value = validated_params

    res = logic.get_ledger_acc_run_balance_by_period_id(1, vat_category, request_params)

    assert res.status == 200
    mock_model.get_by_accounting_period_and_vat_category.assert_called_once_with(
        1, **validated_params
    )
    mock_model.get_by_accounting_period_and_vat_category_count.assert_called_once_with(
        1, vat_category
    )


@patch('ledger.logic.ledger_accounting_run_vat.LedgerAccountingRunVat')
def test_get_ledger_acc_run_balance_by_period_id_validation_error(mock_model):
    """Test get_ledger_acc_run_balance_by_period_id method for an invalid request params."""
    vat_category = 'test'
    request_params = {'limit': 1, 'offset': 0}

    res = logic.get_ledger_acc_run_balance_by_period_id(1, vat_category, request_params)

    assert res.status == 400
    assert res.errors['message'] == INVALID_VAT_CATEGORY.format(
        VAT_CATEGORIES_OLD=(', '.join(VAT_CATEGORIES_OLD))
    )
    mock_model.get_by_accounting_period_and_vat_category.assert_not_called()
    mock_model.get_by_accounting_period_and_vat_category_count.assert_not_called()


def test_validate_ledger_balance_request_params_success():
    """Test _validate_ledger_balance_request_params when all parameters are valid."""
    vat_category = VAT_CATEGORIES_OLD.VAT_APPLIED
    request_params = {'limit': 1, 'offset': 0}
    expected_response = {'vat_category': vat_category, 'limit': 1, 'offset': 0}

    res = logic._validate_request_params(request_params, vat_category)

    assert res == expected_response


def test_validate_ledger_balance_request_params_invalid():
    """Test _validate_ledger_balance_request_params for an invalid params."""
    with pytest.raises(
        Exception,
        match=INVALID_VAT_CATEGORY.format(
            VAT_CATEGORIES_OLD=(', '.join(VAT_CATEGORIES_OLD))
        ),
    ):
        vat_category = 'test'
        request_params = {'limit': 1, 'offset': 0}
        logic._validate_request_params(request_params, vat_category)

    with pytest.raises(Exception, match=ERROR_INVALID_LIMIT_OFFSET):
        request_params = {'limit': 'test', 'offset': 0}
        logic._validate_request_params(request_params)


@patch('ledger.logic.ledger_accounting_run_balance.LedgerAccountingRunBalance')
@patch(
    'ledger.logic.ledger_accounting_run_balance.'
    'LedgerAccountingRunBalanceContractCountSchema'
)
def test_get_ledger_accounting_run_balances_contract_count_dataloader(
    mock_schema, mock_model
):
    """Test get_ledger_accounting_run_balances_contract_count_dataloader logic."""
    mock_input = [1, 2]
    mock_items = [
        {'accounting_run_id': 1, 'contract_count': 3},
        {'accounting_run_id': 2, 'contract_count': 1},
    ]

    mock_model.find_contract_count_by_accounting_run_ids.return_value = mock_items
    mock_schema_instance = mock_schema.return_value
    mock_schema_instance.dump.return_value = mock_items

    res = logic.get_ledger_accounting_run_balances_contract_count_dataloader(mock_input)

    assert res.status == 200
    assert res.message == [{'data': item} for item in mock_items]

    mock_model.find_contract_count_by_accounting_run_ids.assert_called_once_with(
        mock_input
    )
    mock_schema_instance.dump.assert_called_once_with(mock_items)