"""payonner module tests."""

from unittest.mock import patch

import pytest

from payee.utils.payoneer import PayoneerDataHelper as payoneer


def test_build_payoneer_address():
    """Test build address."""
    params = {
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
    }

    address = payoneer.build_individual_address(params)

    assert address == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
        }
    }

    params['address_2'] = 'address 2'
    address = payoneer.build_individual_address(params)

    assert address == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'address_line_2': 'address 2',
        }
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    address = payoneer.build_individual_address(params)

    assert address == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'US',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': 'province',
        }
    }


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=False,
)
def test_build_individual_payee(mock_feature):
    """Test build individual payee."""
    params = {
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'last_name': 'last name',
        'first_name': 'first name',
        'date_of_birth': '01-01-2000',
        'email': 'test@example.com',
    }

    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
        },
    }

    params['address_2'] = 'address 2'
    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'address_line_2': 'address 2',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'US',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': 'province',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
        },
    }


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=True,
)
def test_build_individual_payee_with_email_phone(mock_feature):
    """Test build individual payee."""
    params = {
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'last_name': 'last name',
        'first_name': 'first name',
        'date_of_birth': '01-01-2000',
        'email': 'test@example.com',
        'phone': '4567890',
        'phone_country': 'US',
    }

    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }

    params['address_2'] = 'address 2'
    params['phone'] = '4567890'
    params['phone_country'] = 'US'
    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'address_line_2': 'address 2',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    payee = payoneer.build_individual_payee(params)

    assert payee == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'US',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': 'province',
        },
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=False,
)
def test_build_company_payee_generic_flow(mock_feature):
    """Test build company payee."""
    params = {
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'name': 'name',
    }

    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
        },
    }

    params['address_2'] = 'address 2'
    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'US',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
            'incorporated_state': 'province',
        },
    }


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=True,
)
def test_build_company_payee(mock_feature):
    """Test build company payee."""
    params = {
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'name': 'name',
    }

    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
        },
        'contact': {
            'email': None,
            'phone': None,
            'phone_country': None,
        },
    }

    params['address_2'] = 'address 2'
    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
        },
        'contact': {
            'email': None,
            'phone': None,
            'phone_country': None,
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    params['email'] = 'test@example.com'
    params['phone'] = '4567890'
    params['phone_country'] = 'US'
    payee = payoneer.build_company_payee(params)

    assert payee == {
        'company': {
            'name': 'name',
            'incorporated_country': 'US',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
            'incorporated_state': 'province',
        },
        'contact': {
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }


@pytest.mark.parametrize(
    'phone_data', [{'phone': '34567890', 'phone_country': 'US'}, {}]
)
@patch('payee.utils.payoneer.is_account_payee_flow')
def test_build_individual_payee_contact_phone(mock_feature, phone_data):
    """Test build individual payee contact."""
    mock_feature.return_value = bool(phone_data)
    params = {
        'last_name': 'last name',
        'first_name': 'first name',
        'date_of_birth': '01-01-2000',
        'email': 'test@example.com',
        **phone_data,
    }

    contact = payoneer.build_individual_payee_contact(params)

    assert contact == {
        'contact': {
            'last_name': 'last name',
            'first_name': 'first name',
            'date_of_birth': '01-01-2000',
            'email': 'test@example.com',
            **phone_data,
        }
    }

    if phone_data:
        assert contact['contact'].items() > phone_data.items()


@pytest.mark.parametrize(
    'email_phone_data', [{'phone': '34567890', 'phone_country': 'US'}, {}]
)
@patch('payee.utils.payoneer.is_account_payee_flow')
def test_build_company_payee_contact_phone(mock_feature, email_phone_data):
    """Test build individual payee contact."""
    mock_feature.return_value = bool(email_phone_data)

    data = payoneer.build_company_payee_contact(email_phone_data)

    if email_phone_data:
        assert data['contact'].items() > email_phone_data.items()
    else:
        assert 'contact' not in data


def test_build_payout_method():
    """Test build payout method."""
    params = {
        'bank_account_type': 'bank account type',
        'country': 'country',
        'currency': 'currency',
        'bank_field_details': 'bank field details',
    }

    payout_method = payoneer.build_payout_method(params)

    assert payout_method == {
        'bank_account_type': 'bank account type',
        'country': 'country',
        'currency': 'currency',
        'bank_field_details': 'bank field details',
    }


def test_format_register_payee_request():
    """Test format register payee request."""
    params = {
        'type': 'type',
        'account_payee_id': 'account payee id',
    }

    with (
        patch.object(payoneer, 'build_payout_method') as mock_build_payout_method,
        patch.object(payoneer, 'get_register_strategy') as mock_get_strategy,
    ):
        mock_build_payout_method.return_value = {'type': 'BANK'}
        mock_get_strategy.return_value.return_value = {'payee': 'payee'}

        request = payoneer.format_register_payee_request(
            params['account_payee_id'], params
        )

        assert request == {
            'payee_id': 'account payee id',
            'payee': {'payee': 'payee', 'type': 'type'},
            'payout_method': {'type': 'BANK'},
        }

        mock_build_payout_method.assert_called_once_with(params)
        mock_get_strategy.assert_called_once_with('type')
        mock_get_strategy.return_value.assert_called_once_with(params)


def test_format_update_payee_request():
    """Test format update payee request."""
    params = {
        'type': 'BANK',
        'bank_account_type': 'PERSONAL',
        'country': 'US',
        'currency': 'USD',
        'bank_field_details': 'bank_field_details',
    }

    result = payoneer.format_update_payee_request(params)

    assert result == {
        'type': 'BANK',
        'bank_account_type': 'PERSONAL',
        'country': 'US',
        'currency': 'USD',
        'bank_field_details': 'bank_field_details',
    }


@pytest.mark.parametrize(
    'input_country,expected_country',
    [
        ('GB', 'UK'),
        ('XK', 'KV'),
    ],
)
def test_format_update_payee_request_country_transformations(
    input_country, expected_country
):
    """Test format update payee request country code transformations."""
    params = {
        'type': 'BANK',
        'bank_account_type': 'PERSONAL',
        'country': input_country,
        'currency': 'USD',
        'bank_field_details': 'bank_field_details',
    }
    result = payoneer.format_update_payee_request(params)
    assert result == {
        'type': 'BANK',
        'bank_account_type': 'PERSONAL',
        'country': expected_country,
        'currency': 'USD',
        'bank_field_details': 'bank_field_details',
    }


def test_get_register_strategy():
    """Test get register strategy."""
    assert (
        payoneer.get_register_strategy('INDIVIDUAL') == payoneer.build_individual_payee
    )
    assert payoneer.get_register_strategy('COMPANY') == payoneer.build_company_payee
    with pytest.raises(KeyError):
        payoneer.get_register_strategy('UNKNOWN')


def test_get_address_strategy():
    """Test get address strategy."""
    assert (
        payoneer.get_address_strategy('INDIVIDUAL') == payoneer.build_individual_address
    )
    assert payoneer.get_address_strategy('COMPANY') == payoneer.build_company_address
    with pytest.raises(KeyError):
        payoneer.get_address_strategy('UNKNOWN')


def test_register_payee_helper():
    """Test register payee helper."""
    assert (
        payoneer.get_register_strategy('INDIVIDUAL') == payoneer.build_individual_payee
    )
    assert payoneer.get_register_strategy('COMPANY') == payoneer.build_company_payee

    with (
        patch.object(payoneer, 'build_payout_method') as mock_build_payout_method,
        patch.object(payoneer, 'get_register_strategy') as mock_get_strategy,
    ):
        mock_build_payout_method.return_value = {'type': 'BANK'}
        mock_get_strategy.return_value.return_value = {'payee': 'payee'}

        request = payoneer.format_register_payee_request(
            'account_payee_id', {'type': 'type', 'account_payee_id': 'account_payee_id'}
        )

        assert request == {
            'payee_id': 'account_payee_id',
            'payee': {'payee': 'payee', 'type': 'type'},
            'payout_method': {'type': 'BANK'},
        }

        mock_build_payout_method.assert_called_once_with(
            {'type': 'type', 'account_payee_id': 'account_payee_id'}
        )
        mock_get_strategy.assert_called_once_with('type')
        mock_get_strategy.return_value.assert_called_once_with(
            {'type': 'type', 'account_payee_id': 'account_payee_id'}
        )


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=False,
)
def test_format_edit_profile_request_individual(mock_feature):
    """Test format_edit_profile_request."""
    params = {
        'type': 'INDIVIDUAL',
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'last_name': 'last name',
        'first_name': 'first name',
        'date_of_birth': '01-01-2000',
        'email': 'test@example.com',
        'phone': '4567890',
        'phone_country': 'US',
    }

    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'address_line_2': '',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'state': '',
        },
        'contact': {
            'email': 'test@example.com',
        },
    }

    params['address_2'] = 'address 2'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': '',
        },
        'contact': {
            'email': 'test@example.com',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'US',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': 'province',
        },
        'contact': {
            'email': 'test@example.com',
        },
    }


@patch(
    'payee.utils.payoneer.is_account_payee_flow',
    return_value=True,
)
def test_format_edit_profile_request_individual_phone_enabled(mock_feature):
    """Test format_edit_profile_request."""
    params = {
        'type': 'INDIVIDUAL',
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'last_name': 'last name',
        'first_name': 'first name',
        'date_of_birth': '01-01-2000',
        'email': 'test@example.com',
        'phone': '4567890',
        'phone_country': 'US',
    }

    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'address_line_2': '',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'state': '',
        },
        'contact': {
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }

    params['address_2'] = 'address 2'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'BR',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': '',
        },
        'contact': {
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'address': {
            'address_line_1': 'address 1',
            'city': 'city',
            'country': 'US',
            'zip_code': '12345',
            'address_line_2': 'address 2',
            'state': 'province',
        },
        'contact': {
            'email': 'test@example.com',
            'phone': '4567890',
            'phone_country': 'US',
        },
    }


def test_format_edit_profile_request_company():
    """Test build company payee."""
    params = {
        'type': 'COMPANY',
        'address_1': 'address 1',
        'city': 'city',
        'country_code': 'BR',
        'zip': '12345',
        'name': 'name',
    }

    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'company': {
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_address_2': '',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_state': '',
        },
    }

    params['address_2'] = 'address 2'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'company': {
            'incorporated_country': 'BR',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
            'incorporated_state': '',
        },
    }

    params['country_code'] = 'US'
    params['province'] = 'province'
    data = payoneer.format_edit_profile_request(params)

    assert data == {
        'company': {
            'incorporated_country': 'US',
            'incorporated_address_1': 'address 1',
            'incorporated_city': 'city',
            'incorporated_zipcode': '12345',
            'incorporated_address_2': 'address 2',
            'incorporated_state': 'province',
        },
    }