"""AccountCreateProcessor unit tests."""

from collections import namedtuple
from unittest.mock import MagicMock, call, patch

from lambdacommon.graphql import graphql

import config
from sync_account.constants.graphql import (
    ABACUS_CREATE_ACCOUNT_MUTATION,
    ABACUS_UPDATE_ACCOUNT_MUTATION,
)
from sync_account.processor import SyncAccountProcessor

Response = namedtuple('Response', 'message status')


@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test__create_abacus_account_success(
    mock_execute, mock_event, mock_abacus_create_account_mutation_result
):
    """Test _create_abacus_account success."""
    vendor_id = mock_event['vendor_id']
    vendor_name = mock_event['vendor_name']
    currency_code = mock_event['currency']
    country = mock_event['country']
    mock_execute.return_value = mock_abacus_create_account_mutation_result

    expected_data = {
        'data': {
            'accountId': vendor_id,
            'accountName': vendor_name,
            'createdBy': config.GRAPHQL_HEADERS['Orchard-Identity-Id'],
            'countryOfTaxResidence': country,
            'currencyCode': currency_code,
            'creationSource': config.APPLICATION_NAME,
        }
    }
    expected_result = mock_abacus_create_account_mutation_result['data'][
        'abacusCreateAccount'
    ]

    result = SyncAccountProcessor(mock_event)._create_abacus_account(
        vendor_id, vendor_name, currency_code, country
    )

    assert mock_execute.call_args_list == [
        call(ABACUS_CREATE_ACCOUNT_MUTATION, expected_data)
    ]
    assert result == expected_result


@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test__create_abacus_account_failure_already_exists(
    mock_execute, mock_event, mock_abacus_create_account_mutation_result
):
    """Test _create_abacus_account failure, account is already exists."""
    vendor_id = mock_event['vendor_id']
    vendor_name = mock_event['vendor_name']
    currency_code = mock_event['currency']
    country = mock_event['country']
    mock_execute.side_effect = graphql.GraphQLError([{}])
    mock_execute.side_effect.response = {'status': 409}

    expected_data = {
        'data': {
            'accountId': vendor_id,
            'accountName': vendor_name,
            'createdBy': config.GRAPHQL_HEADERS['Orchard-Identity-Id'],
            'countryOfTaxResidence': country,
            'currencyCode': currency_code,
            'creationSource': config.APPLICATION_NAME,
        }
    }
    expected_result = None

    result = SyncAccountProcessor(mock_event)._create_abacus_account(
        vendor_id, vendor_name, currency_code, country
    )

    assert mock_execute.call_args_list == [
        call(ABACUS_CREATE_ACCOUNT_MUTATION, expected_data)
    ]
    assert result == expected_result


@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test_update_abacus_account_success(
    mock_execute, mock_update_event, mock_abacus_update_account_mutation_result
):
    """Test _update_abacus_account success."""
    mock_vendor = mock_abacus_update_account_mutation_result['data'][
        'abacusUpdateAccount'
    ]
    vendor_id = mock_vendor['accountId']
    vendor_name = mock_vendor['accountName']
    mock_execute.return_value = mock_abacus_update_account_mutation_result

    expected_input = {'data': {'accountId': vendor_id, 'accountName': vendor_name}}
    expected_result = mock_abacus_update_account_mutation_result['data'][
        'abacusUpdateAccount'
    ]

    result = SyncAccountProcessor(mock_update_event)._update_abacus_account(
        vendor_id, vendor_name
    )

    assert mock_execute.call_args_list == [
        call(ABACUS_UPDATE_ACCOUNT_MUTATION, expected_input)
    ]
    assert result == expected_result


@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test_update_abacus_account_failure_account_doesnt_exist(
    mock_execute, mock_update_event, mock_abacus_update_account_mutation_result
):
    """Test _update_abacus_account failure, account doesn't exist."""
    mock_vendor = mock_abacus_update_account_mutation_result['data'][
        'abacusUpdateAccount'
    ]
    vendor_id = mock_vendor['accountId']
    vendor_name = mock_vendor['accountName']
    mock_execute.side_effect = graphql.GraphQLError([{}])
    mock_execute.side_effect.response = {'status': 404}

    expected_input = {'data': {'accountId': vendor_id, 'accountName': vendor_name}}
    expected_result = None

    result = SyncAccountProcessor(mock_update_event)._update_abacus_account(
        vendor_id, vendor_name
    )

    assert mock_execute.call_args_list == [
        call(ABACUS_UPDATE_ACCOUNT_MUTATION, expected_input)
    ]
    assert result == expected_result


@patch('sync_account.processor.logger')
@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test_update_abacus_account_failure_gql_exception(
    mock_execute,
    mock_logger,
    mock_update_event,
    mock_abacus_update_account_mutation_result,
):
    """Test _update_abacus_account failure on unexpected gql exception."""
    mock_vendor = mock_abacus_update_account_mutation_result['data'][
        'abacusUpdateAccount'
    ]
    vendor_id = mock_vendor['accountId']
    vendor_name = mock_vendor['accountName']
    mock_execute.side_effect = graphql.GraphQLError([{}])
    mock_execute.side_effect.response = {'status': 500}

    expected_data = {'data': {'accountId': vendor_id, 'accountName': vendor_name}}

    SyncAccountProcessor(mock_update_event)._update_abacus_account(
        vendor_id, vendor_name
    )

    payload = expected_data['data']
    mock_logger.assert_has_calls(
        [
            call.info('Updating an account 12345'),
            call.info(f'Error while updating an account {payload}.\nNone - None  '),
        ]
    )
    assert mock_execute.call_args_list == [
        call(ABACUS_UPDATE_ACCOUNT_MUTATION, expected_data)
    ]


def test_process_vendor_name_not_exists():
    """Test _update_abacus_account when vendor_name doesn't exist in payload."""
    mock_event_data = {
        'operation': {'type': 'update', 'timestamp': 1691053218547.5486},
        'payload': {'vendor_id': 1234, 'wel_email_sender': '199'},
        'topic': 'event.accounts',
    }
    result = SyncAccountProcessor(mock_event_data).process()
    assert result is None


@patch('sync_account.processor.logger')
@patch('lambdacommon.graphql.graphql.GraphQLConnector.execute')
def test__create_abacus_account_failure_gql_exception_ff(
    mock_execute, mock_logger, mock_event
):
    """Test _create_abacus_account failure on unexpected gql exception when FF is enabled."""  # noqa: E501
    vendor_id = mock_event['vendor_id']
    vendor_name = mock_event['vendor_name']
    currency_code = mock_event['currency']
    country = mock_event['country']
    mock_execute.side_effect = graphql.GraphQLError([{}])
    mock_execute.side_effect.response = {'status': 500}
    SyncAccountProcessor._is_feature_enabled = MagicMock(return_value=True)

    expected_data = {
        'data': {
            'accountId': vendor_id,
            'accountName': vendor_name,
            'createdBy': config.GRAPHQL_HEADERS['Orchard-Identity-Id'],
            'countryOfTaxResidence': country,
            'currencyCode': currency_code,
            'creationSource': config.APPLICATION_NAME,
        }
    }

    SyncAccountProcessor(mock_event)._create_abacus_account(
        vendor_id, vendor_name, currency_code, country
    )
    payload = expected_data['data']

    mock_logger.assert_has_calls(
        [
            call.info('Creating account for Test vendor'),
            call.info(f'Error while creating an account {payload}.\nNone - None  '),
        ]
    )

    assert mock_execute.call_args_list == [
        call(ABACUS_CREATE_ACCOUNT_MUTATION, expected_data)
    ]


def test_process_creating_abacus_account_for_accounts_topic(mock_create_event_payload):
    """Test process method for creating an account when kafka topic is accounts."""
    SyncAccountProcessor._create_abacus_account = MagicMock(return_value=True)
    result = SyncAccountProcessor(mock_create_event_payload).process()

    SyncAccountProcessor._create_abacus_account.assert_called_once_with(
        '12345', 'Test vendor 12345', 'USD'
    )
    assert result is None


def test_process_creating_abacus_account_for_knrAccountCreation_topic(mock_event):
    """Test process method for creating an account when kafka topic is knrAccountCreation."""  # noqa: E501
    vendor_id = mock_event['vendor_id']
    vendor_name = mock_event['vendor_name']
    currency_code = mock_event['currency']
    country = mock_event['country']
    SyncAccountProcessor._create_abacus_account = MagicMock(return_value=True)
    result = SyncAccountProcessor(mock_event).process()

    SyncAccountProcessor._create_abacus_account.assert_called_once_with(
        str(vendor_id), vendor_name, currency_code, country
    )
    assert result is None