"""Payment Group functional tests."""

from payment.constants.constants import SPECIFIC_ACCOUNTS_PAYMENT_GROUP_NAME
from payment.constants.error import (
    ERROR_ALREADY_EXISTS,
    ERROR_CANNOT_REUSE,
    ERROR_UNKNOWN_CURRENCY,
    ERROR_UPDATE_NON_REUSABLE_PAYMENT_GROUP,
)
from tests.utils.factories import PaymentGroupFactory


def test_create_payment_group_success(fixture_client):
    """Successful creation of payment group."""
    post_body = {
        'group_criteria': {'currency_codes': ['CAD']},
        'group_name': 'Payment Group Name',
        'is_reusable': True,
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 201
    assert res.json['payment_group_id']
    assert res.json['group_criteria'] == post_body['group_criteria']
    assert res.json['group_name'] == post_body['group_name']
    assert res.json['is_reusable']


def test_create_payment_group_using_ref_payment_entity(fixture_client):
    """Successful creation of a payment group payment with group_criteria.reference_payment_entities."""  # noqa: E501
    ref_payment_entities_expected = [2]

    post_body = {
        'group_name': 'Payment Group Name',
        'group_criteria': {
            'currency_codes': ['USD', 'EUR'],
            'reference_payment_entities': ref_payment_entities_expected,
            'reference_agreement_types': [1, 2],
        },
        'is_reusable': True,
    }
    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 201
    assert (
        res.json['group_criteria']['currency_codes']
        == post_body['group_criteria']['currency_codes']
    )
    assert (
        res.json['group_criteria']['reference_payment_entities']
        == ref_payment_entities_expected
    )
    assert (
        res.json['group_criteria']['reference_agreement_types']
        == post_body['group_criteria']['reference_agreement_types']
    )


def test_create_payment_group_success_specific_account(fixture_client, mock_accounts):
    """Test successful creation of payment group for a specific account."""
    post_body = {
        'group_criteria': {'account_id': 1},
        'group_name': 'Payment Group Name',
        'payment_name': 'Payment Group Payment Name',
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 201
    assert res.json['payment_group_id']
    assert res.json['group_criteria'] == post_body['group_criteria']
    assert not res.json['is_reusable']


def test_create_payment_group_success_list_specific_account(
    fixture_client, mock_accounts
):
    """Test successful creation of payment group for specific account as list."""
    post_body = {
        'group_criteria': {'account_ids': [1]},
        'group_name': 'Payment Group Name',
        'payment_name': 'Payment Group Payment Name',
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 201
    assert res.json['payment_group_id']
    assert res.json['group_criteria'] == post_body['group_criteria']
    assert res.json['group_name'] == 'Payment Group Name'
    assert not res.json['is_reusable']


def test_create_payment_group_success_list_specific_accounts(
    fixture_client, mock_accounts
):
    """Test successful creation of payment group for specific accounts as list."""
    post_body = {
        'group_criteria': {'account_ids': [1, 2, 3]},
        'group_name': 'Payment Group Name',
        'payment_name': 'Payment Group Payment Name',
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 201
    assert res.json['payment_group_id']
    assert res.json['group_criteria'] == post_body['group_criteria']
    assert res.json['group_name'] == SPECIFIC_ACCOUNTS_PAYMENT_GROUP_NAME
    assert not res.json['is_reusable']


def test_create_payment_group_error(fixture_client):
    """Test error is raised on creation of a reusable payment group for an account."""
    post_body = {
        'group_criteria': {'account_id': 123},
        'group_name': 'Payment Group Name',
        'payment_name': 'Payment Group Payment Name',
        'is_reusable': True,
    }

    res = fixture_client.post('/payment-group/', json=post_body)

    assert res.status_code == 400
    assert res.json['code'] == 'error'
    assert res.json['message'] == ERROR_CANNOT_REUSE


def test_create_payment_group_invalid_currency(fixture_client):
    """Creation of payment group fails with invalid currency code."""
    post_body = {
        'group_criteria': {'currency_codes': ['NYJ', 'CAD']},
        'group_name': 'Payment Group Name',
        'is_reusable': 1,
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 400
    assert res.json['code'] == 'error'
    assert res.json['message'] == ERROR_UNKNOWN_CURRENCY.format(code='NYJ')


def test_create_payment_group_duplicate_name(fixture_client):
    """Creation of payment group fails if name is used by a reusable payment group."""
    existing_payment_group = PaymentGroupFactory.create()
    post_body = {
        'group_criteria': {},
        'group_name': existing_payment_group.group_name,
        'is_reusable': True,
    }

    res = fixture_client.post('/payment-group/', json=post_body)
    assert res.status_code == 400
    assert res.json['code'] == 'error'
    assert res.json['message'] == ERROR_ALREADY_EXISTS.format(
        object_type='Payment Group'
    )


def test_get_payment_group(fixture_client):
    """Test getting a specified payment group."""
    payment_group = PaymentGroupFactory.create()

    res = fixture_client.get(f'/payment-group/{payment_group.payment_group_id}')
    assert res.status_code == 200
    assert res.json['group_criteria'] == payment_group.group_criteria
    assert res.json['group_name'] == payment_group.group_name
    assert res.json['is_reusable'] == payment_group.is_reusable
    assert res.json['payment_group_id'] == payment_group.payment_group_id


def test_get_reusable_payment_groups(fixture_client):
    """Test getting a reusable payment groups."""
    payment_group = PaymentGroupFactory.create(is_reusable=True)

    res = fixture_client.get('/payment-group/reusable-groups')
    result = res.json

    assert res.status_code == 200
    assert result['items'][0]['group_criteria'] == payment_group.group_criteria
    assert result['items'][0]['group_name'] == payment_group.group_name
    assert result['items'][0]['is_reusable'] == payment_group.is_reusable
    assert result['items'][0]['payment_group_id'] == payment_group.payment_group_id


def test_get_reusable_payment_groups_with_pagination(fixture_client):
    """Test getting a reusable payment groups with query params limit and offset."""
    payment_group = PaymentGroupFactory.create(
        group_name='M/Q 45 days', is_reusable=True
    )
    PaymentGroupFactory.create(group_name='M/Q 90 days', is_reusable=True)

    res = fixture_client.get('/payment-group/reusable-groups?limit=1&offset=0')
    result = res.json

    assert res.status_code == 200
    assert len(result['items']) == 1
    assert result['total_count'] == 2
    assert result['items'][0]['group_criteria'] == payment_group.group_criteria
    assert result['items'][0]['group_name'] == payment_group.group_name
    assert result['items'][0]['is_reusable'] == payment_group.is_reusable
    assert result['items'][0]['payment_group_id'] == payment_group.payment_group_id


def test_update_payment_group_success(fixture_client):
    """Successful update of payment group."""
    payment_group = PaymentGroupFactory.create(is_reusable=True)
    post_body = {
        'group_name': 'Updated Payment Group Name',
    }

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 200
    assert res.json['payment_group_id'] == payment_group.payment_group_id
    assert res.json['group_name'] == post_body['group_name']


def test_update_payment_group_reusable_success(fixture_client):
    """Successful update of payment group is_reusable to False."""
    payment_group = PaymentGroupFactory.create(is_reusable=True)
    post_body = {
        'is_reusable': False,
    }

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 200
    assert res.json['is_reusable'] == False


def test_update_payment_group_failure_non_reusable(fixture_client):
    """Error update of payment group."""
    payment_group = PaymentGroupFactory.create(is_reusable=False)
    post_body = {
        'group_name': 'Updated Payment Group Name',
    }

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 400
    assert res.json == {
        'code': 'error',
        'message': ERROR_UPDATE_NON_REUSABLE_PAYMENT_GROUP,
    }


def test_update_payment_group_error_validation_incorrect_data(fixture_client):
    """Error update of payment group."""
    payment_group = PaymentGroupFactory.create(is_reusable=True)
    post_body = {
        'group_name': '',
    }

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 400
    assert res.json == {
        'code': 'error',
        'message': {'json': {'group_name': ['Must be specified.']}},
    }


def test_update_payment_group_error_validation_unknown_fields(fixture_client):
    """Error update of payment group."""
    payment_group = PaymentGroupFactory.create(is_reusable=True)
    post_body = {'payment_group_id': 1, 'group_criteria': {}}

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 400
    assert res.json == {
        'code': 'error',
        'message': {'json': {field: ['Unknown field.'] for field in post_body}},
    }


def test_update_payment_group_error_reusable_true(fixture_client):
    """Error update of payment group."""
    payment_group = PaymentGroupFactory.create(is_reusable=False)
    post_body = {
        'is_reusable': True,
    }

    res = fixture_client.put(
        f'/payment-group/{payment_group.payment_group_id}', json=post_body
    )
    assert res.status_code == 400
    assert res.json == {
        'code': 'error',
        'message': {'json': {'is_reusable': ['Must be equal to False.']}},
    }