"""Test payee logic."""

from unittest.mock import call, Mock, patch

from owsrequest.utils import mock_request

from payee.connectors.ows_collaborator import SERVICE_NAME
from payee.constants.constants import (
    ACTION_STATUSES,
    KYC_NOTIFICATION_MESSAGE,
    PAYEE_ACTION_NAMES,
)
from payee.logic import payee as logic
from payee.models.account_payee import AccountPayee
from payee.models.payee import Payee
from payee.schemas.payee import PayeeSchema
from tests.utils.factories import (
    AccountPayeeFactory,
    PayeeCollaboratorFactory,
    PayeeFactory,
)


@patch('payee.logic.payee.ows_collaborator')
@patch('payee.logic.payee.PayeeCollaborator')
@patch('payee.logic.payee.Payee')
@patch('payee.logic.payee.AccountPayee')
@patch('payee.logic.payee.create_payee_states_by_parent_table')
def test_create_payee_collaborator(
    create_payee_states_by_parent_table_mock,
    account_payee_mock,
    payee_mock,
    payee_collaborator_mock,
    mocked_ows_collaborator,
):
    """Test creating collaborator payees."""
    collaborator_id = 1
    collaborator_name = 'test'

    account_payee_mock.get_payee_by_account_id.return_value = (
        AccountPayeeFactory.build()
    )
    payee_mock.build.return_value = PayeeFactory.build()
    payee_collaborator_mock.build.return_value = PayeeCollaboratorFactory.build()

    mocked_ows_collaborator.get_collaborator.get.return_value = {
        'vendor_id': 1,
        'name': collaborator_name,
    }

    res = logic.create_payee_collaborator(
        {
            'collaborator_id': collaborator_id,
            'reference_payment_type_id': 8,
        }
    )

    assert PayeeSchema().dump(res) == PayeeSchema().dump(PayeeFactory.build())
    assert mocked_ows_collaborator.get_collaborator.call_args_list == [
        call(collaborator_id)
    ]


@patch('payee.logic.payee.Payee')
def test_get_payees_in_bulk_by_collaborator_ids(payee_mock):
    """Test getting payees."""

    data = [
        (PayeeFactory.build(), PayeeCollaboratorFactory.build()),
        (PayeeFactory.build(), PayeeCollaboratorFactory.build()),
    ]

    payee_mock.get_payees_by_collaborator_ids.return_value = data

    res = logic.get_payees_dataloader([1, 2], [])

    payee_mock.get_payees_by_collaborator_ids.assert_called_once_with([1, 2])
    res = {
        'payees': [
            {'data': data[0][0]},
            {'error': 'Payee not found collaborator_id:`2`'},
        ]
    }


@patch('payee.logic.payee.Payee')
def test_get_payees_in_bulk_by_payoneer_client_reference_id(payee_mock):
    """Test getting payees."""

    data = [PayeeFactory.build(), PayeeFactory.build()]

    payee_mock.get_payees_by_payoneer_client_reference_id.return_value = data

    res = logic.get_payees_dataloader([], ['abc', 'uuid'])

    payee_mock.get_payees_by_payoneer_client_reference_id.assert_called_once_with(
        ['abc', 'uuid']
    )
    assert res == {
        'payees': [
            {'data': None},
            {'data': data[1]},
        ]
    }


@patch('payee.logic.payee.Payee')
@patch('payee.logic.payee.AccountPayee')
def test_map_payee_id(
    account_payee_mock,
    payee_mock,
):
    """Test map payee ID decorator."""

    @logic.map_payee_id
    def wrapped_func(payee):
        return payee

    payee_mock.get_by_id.return_value = PayeeFactory.build()
    payee = wrapped_func(payee_id=123)
    assert isinstance(payee, Payee)

    payee_mock.get_by_id.return_value = None
    account_payee_mock.get_by_id.return_value = AccountPayeeFactory.build()
    account_payee = wrapped_func(account_payee_id=123)
    assert isinstance(account_payee, AccountPayee)


@patch('payee.logic.payee.Payee')
def test_get_payees_paginated(payee_mock):
    """Test getting payees paginated."""

    data = (
        [
            PayeeFactory.build(),
            PayeeFactory.build(),
        ],
        2,
    )

    payee_mock.get_payees.return_value = data

    call_args = dict(
        limit=1,
        offset=0,
        account_ids=[1, 2],
        payoneer_program_ids=[1],
        search_term='alice',
    )

    res = logic.get_payees_paginated(
        **call_args,
        requires_review=True,
        abacus_states=[
            {
                'action_status': ACTION_STATUSES.COMPLETE,
                'action_name': PAYEE_ACTION_NAMES.BANKING_ELIGIBILITY,
            }
        ],
    )
    payee_mock.get_payees.assert_called_once_with(
        **call_args,
        abacus_states=[
            {
                'action_status': ACTION_STATUSES.COMPLETE,
                'action_name': PAYEE_ACTION_NAMES.BANKING_ELIGIBILITY,
            },
            {
                'action_status': ACTION_STATUSES.RUNNING,
                'message': KYC_NOTIFICATION_MESSAGE,
            },
        ],
    )
    assert res == {
        'items': data[0],
        'total_count': data[1],
    }


@patch('payee.logic.payee.PayeeCollaborator')
def test_get_payee_collaborators_paginated(payee_mock):
    """Test getting payee collaborators paginated."""

    data = (
        [
            PayeeCollaboratorFactory.build(),
            PayeeCollaboratorFactory.build(),
        ],
        2,
    )

    payee_mock.get_payee_collaborators.return_value = data

    call_args = dict(
        limit=1,
        offset=0,
        payee_ids=[123],
    )

    res = logic.get_payee_collaborators_paginated(**call_args)
    payee_mock.get_payee_collaborators.assert_called_once_with(**call_args)
    assert res == {
        'items': data[0],
        'total_count': data[1],
    }