"""Test Payment Generation Processor."""

from unittest.mock import MagicMock
from unittest.mock import patch

from payments_generate import config
from payments_generate.processor import PaymentGenerationProcessor


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.get_eligible_accounts')
def test_eligible_accounts(mock_get_accounts, mock_logger, mock_event):
    """Test processor's _eligible_accounts method."""
    payment_group_id = 44
    eligible_accounts = [
        {
            'account_id': 1,
            'currency_code': 'EUR',
            'current_balance': '2000.00'
        },
        {
            'account_id': 3,
            'currency_code': 'EUR',
            'current_balance': '450.55'
        }
    ]
    mock_get_accounts.return_value = eligible_accounts
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._eligible_accounts({'payment_group_id': payment_group_id})

    assert result == eligible_accounts
    mock_logger.info.assert_called_with(config.ACCOUNT_MSG.format(payment_group_id))
    mock_get_accounts.assert_called_once_with(payment_group_id)


@patch('payments_generate.processor.app_logger')
def test_tax_withholding_rates(
    mock_logger, mock_reference_tax_withholding,
    mock_reference_tax_withholding_format, mock_event, request_engine
):
    """Test processor's _tax_withholding_rates method."""
    request_engine['ows-payment'].add_spec(
        'GET',
        '/reference-tax-withholding/',
        status=200,
        response={'items': mock_reference_tax_withholding, 'total_count': 2}
    )
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._tax_withholding_rates()

    assert result == mock_reference_tax_withholding_format
    mock_logger.info.assert_called_with(config.TAX_WITHHOLDING_RATES_MSG)


@patch('payments_generate.processor.app_logger')
def test_payment_minimums(
    mock_logger, mock_payment_minimums,
    mock_payment_minimums_format, mock_event, request_engine
):
    """Test processor's _payment_minimums method."""
    request_engine['ows-payment'].add_spec(
        'GET',
        '/payment-minimums/',
        status=200,
        response={'items': mock_payment_minimums, 'total_count': 2}
    )
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._payment_minimums()

    assert result == mock_payment_minimums_format
    mock_logger.info.assert_called_with(config.PAYMENT_MINIMUMS_MSG)


@patch('payments_generate.processor.app_logger')
def test_log_init(mock_logger, mock_event):
    """Test log init is called when processor is initialized."""
    PaymentGenerationProcessor(mock_event)
    target_id = mock_event['target_id']
    mock_logger.info.assert_called_once_with(config.PROCESSOR_MSG.format(target_id))


@patch('payments_generate.processor.app_logger')
def test_log_success(mock_logger, mock_event):
    """Test processor's log success log's a success message."""
    processor = PaymentGenerationProcessor(mock_event)
    processor._log_success()
    assert mock_logger.info.called_with(config.SUCCESS_MSG)


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.last_payment_per_account')
def test_account_payments(mock_get_payments, mock_logger, mock_event):
    """Test processor's _account_payments method."""
    accounts = [{'account_id': 123}, {'account_id': 456}]
    payment_accounts = {123: '1000.99', 456: '800.50'}
    mock_get_payments.return_value = payment_accounts
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._account_payments(accounts)

    assert result == payment_accounts
    mock_logger.info.assert_called_with(config.PAYMENT_MSG.format(len(accounts)))
    mock_get_payments.assert_called_once_with(accounts)


@patch('payments_generate.processor.get_payment_group_payment')
def test_payment_group_payment(mock_get_payment, mock_event):
    """Test processor's _payment_group_payment method."""
    mock_get_payment.return_value = '<PaymentGroupPayment>'
    target_id = mock_event['target_id']
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._payment_group_payment()

    assert result == '<PaymentGroupPayment>'
    mock_get_payment.assert_called_once_with(target_id)


@patch('payments_generate.processor.PaymentEntryQueue')
@patch('payments_generate.processor.AccountPaymentProcessor')
def test_process_payment_batches(
    mock_account_payment_processor,
    mock_payment_entry_queue,
    mock_event,
    mock_last_payment,
    mock_eligible_accounts,
    mock_payment_minimums
):
    """Test processor's process_payment_batches method."""
    payment_group_payment_id = mock_event.get('target_id')

    mock_payment_entry_queue.return_value.length = 10

    processor = PaymentGenerationProcessor(mock_event)
    processor.process_payment_batches(
        mock_last_payment,
        mock_eligible_accounts,
        mock_payment_minimums
    )

    mock_payment_entry_queue.assert_called_once_with(payment_group_payment_id)
    assert mock_account_payment_processor.call_count == 2
    assert mock_account_payment_processor.return_value.process.call_count == 2
    mock_payment_entry_queue.return_value.flush_entries.assert_called_once()


def test_processor_process(
    mock_event,
    mock_eligible_accounts,
    mock_last_payment,
    mock_payment_group_payment,
    mock_payment_minimums
):
    """Test Processor.process."""
    PaymentGenerationProcessor.process_payment_batches = MagicMock()
    PaymentGenerationProcessor._log_success = MagicMock()
    PaymentGenerationProcessor._payment_group_payment = MagicMock(
        return_value=mock_payment_group_payment
    )
    PaymentGenerationProcessor._eligible_accounts = MagicMock(
        return_value=mock_eligible_accounts
    )
    PaymentGenerationProcessor._account_payments = MagicMock(
        return_value=mock_last_payment
    )
    PaymentGenerationProcessor._payment_minimums = MagicMock(
        return_value=mock_payment_minimums
    )

    processor = PaymentGenerationProcessor(mock_event)
    processor.process()

    assert processor._event == mock_event
    processor._payment_group_payment.assert_called_once()
    processor._eligible_accounts.assert_called_once_with(mock_payment_group_payment)
    processor._account_payments.assert_called_once_with(mock_eligible_accounts)
    processor._payment_minimums.assert_called()
    processor.process_payment_batches.assert_called_once_with(
        mock_last_payment,
        mock_eligible_accounts,
        mock_payment_minimums
    )