"""Test Payment Generation Processor."""

from unittest.mock import MagicMock, patch

from payments_generate.processor import PaymentGenerationProcessor


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.bulk_create_payment_payees')
def test_bulk_create_payment_payees(mock_bulk_create, mock_logger, mock_event):
    """Test processor's _bulk_create_payment_payees."""
    formatted_payees = [
        {
            'payee_id': 123,
            'currency_code': 'USD',
            'current_balance': '3000.00',
            'last_payment': '1000.99'
        }
    ]
    payment_group_payment_id = mock_event.get('target_id')
    mock_bulk_create.return_value = None
    processor = PaymentGenerationProcessor(mock_event)
    processor._bulk_create_payment_payees(formatted_payees, 1)

    mock_logger.info.assert_called_with(
        processor.BULK_MSG.format(len(formatted_payees))
    )
    mock_bulk_create.assert_called_once_with(payment_group_payment_id, formatted_payees)


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.bulk_create_payment_payees')
def test_bulk_create_payment_no_payees(mock_bulk_create, mock_logger, mock_event):
    """Test creating payments when there are no payees."""
    formatted_payees = []
    mock_bulk_create.return_value = None
    processor = PaymentGenerationProcessor(mock_event)
    processor._bulk_create_payment_payees(formatted_payees, 1)
    mock_logger.info.assert_called_with(
        processor.NOTHING_TO_DO.format(1)
    )
    mock_bulk_create.assert_not_called()


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.get_eligible_payees')
def test_eligible_payees(mock_get_payees, mock_logger, mock_event):
    """Test processor's _eligible_payees method."""
    payment_group_id = 44
    eligible_payees = [
        {
            'payee_id': 1,
            'currency_code': 'EUR',
            'current_balance': '2000.00'
        },
        {
            'payee_id': 3,
            'currency_code': 'EUR',
            'current_balance': '450.55'
        }
    ]
    mock_get_payees.return_value = eligible_payees
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._eligible_payees({'payment_group_id': payment_group_id})

    assert result == eligible_payees
    mock_logger.info.assert_called_with(processor.PAYEE_MSG.format(payment_group_id))
    mock_get_payees.assert_called_once_with(payment_group_id)


def test_format_payment_payees(mock_event):
    """Test processor's _format_payment_payees."""
    eligible_payees = [
        {
            'payee_id': 1,
            'currency_code': 'EUR',
            'current_balance': '2000.00'
        },
        {
            'payee_id': 3,
            'currency_code': 'EUR',
            'current_balance': '450.55'
        }
    ]
    payee_payments = {1: '1000.99', 3: '800.00'}

    processor = PaymentGenerationProcessor(mock_event)
    result = processor._format_payment_payees(eligible_payees, payee_payments)
    assert len(result) == len(payee_payments)
    for res in result:
        assert res['currency_code']
        assert res['current_balance']
        assert res['last_payment'] == payee_payments[res['payee_id']]
        assert res['payee_id']


@patch('payments_generate.processor.app_logger')
def test_log_init(mock_logger, mock_event):
    """Test log init is called when processor is initialized."""
    p = PaymentGenerationProcessor(mock_event)
    target_id = mock_event['target_id']
    mock_logger.info.assert_called_once_with(p.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(processor.SUCCESS_MSG)


@patch('payments_generate.processor.app_logger')
@patch('payments_generate.processor.last_payment_per_payee')
def test_payee_payments(mock_get_payments, mock_logger, mock_event):
    """Test processor's _payee_payments method."""
    payees = [{'payee_id': 123}, {'payee_id': 456}]
    payment_payees = {123: '1000.99', 456: '800.50'}
    mock_get_payments.return_value = payment_payees
    processor = PaymentGenerationProcessor(mock_event)
    result = processor._payee_payments(payees)

    assert result == payment_payees
    mock_logger.info.assert_called_with(processor.PAYMENT_MSG.format(len(payees)))
    mock_get_payments.assert_called_once_with(payees)


@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)


def test_process(mock_event):
    """Test PaymentGenerationProcessor process method."""
    pymt_grp_pymt = {
        'payment_group_payment_id': 1,
        'payment_group_id': 2
    }
    eligible_payees = ['<EligiblePayee>', '<EligiblePayee>']
    payee_payments = {123: '1000.99'}
    formatted_payees = [
        {
            'payee_id': 123,
            'currency_code': 'USD',
            'current_balance': '3000.00',
            'last_payment': '1000.99'
        }
    ]
    PaymentGenerationProcessor._payment_group_payment = \
        MagicMock(return_value=pymt_grp_pymt)
    PaymentGenerationProcessor._eligible_payees = MagicMock(return_value=eligible_payees) # noqa E501
    PaymentGenerationProcessor._payee_payments = MagicMock(return_value=payee_payments)
    PaymentGenerationProcessor._format_payment_payees = \
        MagicMock(return_value=formatted_payees)
    PaymentGenerationProcessor._bulk_create_payment_payees = MagicMock()
    PaymentGenerationProcessor._log_success = MagicMock()

    processor = PaymentGenerationProcessor(mock_event)
    processor.process()

    assert processor._event == mock_event
    PaymentGenerationProcessor._payment_group_payment.assert_called_once()
    PaymentGenerationProcessor._eligible_payees.assert_called_once_with(pymt_grp_pymt)
    PaymentGenerationProcessor._payee_payments.assert_called_once_with(eligible_payees)
    PaymentGenerationProcessor._format_payment_payees.assert_called_once_with(
        eligible_payees,
        payee_payments
    )
    PaymentGenerationProcessor._bulk_create_payment_payees.assert_called_once_with(
        formatted_payees,
        2
    )
    PaymentGenerationProcessor._log_success.assert_called_once()