"""Payee model tests."""

import pytest

from payee.constants.constants import (
    ACTION_STATUSES,
    KYC_NOTIFICATION_MESSAGE,
    PAYEE_ACTION_NAMES,
)
from payee.models.payee import Payee
from tests.utils.factories import (
    PayeeCollaboratorFactory,
    PayeeFactory,
)


def test_get_payees_by_collaborator_ids(payee_fixtures, payee_collaborator_fixtures):
    """Get payees by payee_collaborator_id list."""

    payee1 = PayeeFactory.create(payee_id=None, payoneer_client_reference_id='ABC')
    payee2 = PayeeFactory.create(payee_id=None, payoneer_client_reference_id='DEF')

    collab1 = PayeeCollaboratorFactory.create(
        payee_collaborator_id=100, collaborator_id=10, payee_id=payee1.payee_id
    )
    collab2 = PayeeCollaboratorFactory.create(
        payee_collaborator_id=200, collaborator_id=20, payee_id=payee2.payee_id
    )

    result = Payee.get_payees_by_collaborator_ids(
        [collab1.collaborator_id, collab2.collaborator_id]
    )

    assert len(result) == 2

    returned_pairs = {(p.payee_id, pc.payee_collaborator_id) for p, pc in result}
    expected = {
        (payee1.payee_id, collab1.payee_collaborator_id),
        (payee2.payee_id, collab2.payee_collaborator_id),
    }
    assert returned_pairs == expected

    for payee_obj, collab_obj in result:
        assert payee_obj.payee_id == collab_obj.payee_id


def test_get_payees_by_payoneer_client_reference_id(payee_fixtures):
    """Get payees by payoneer_client_reference_id list."""

    payee1 = PayeeFactory.create(payee_id=None, payoneer_client_reference_id='ABC123')
    payee2 = PayeeFactory.create(payee_id=None, payoneer_client_reference_id='DEF456')

    PayeeFactory.create(payee_id=None, payoneer_client_reference_id='GHI789')

    result = Payee.get_payees_by_payoneer_client_reference_id(['ABC123', 'DEF456'])

    # only the first two should be returned
    assert len(result) == 2
    returned_refs = {p.payoneer_client_reference_id for p in result}
    assert returned_refs == {'ABC123', 'DEF456'}

    returned_ids = {p.payee_id for p in result}
    expected_ids = {payee1.payee_id, payee2.payee_id}
    assert returned_ids == expected_ids


@pytest.mark.parametrize(
    'args,expected_ids',
    [
        (dict(), {1, 2}),
        (
            {
                'abacus_states': [
                    {
                        'action_status': ACTION_STATUSES.COMPLETE,
                    }
                ]
            },
            {1},
        ),
    ],
)
def test_get_payees(args, expected_ids, payee_fixtures, abacus_state_fixtures):
    """Get payees."""

    payees, total_count = Payee.get_payees(limit=2, offset=0, **args)
    assert total_count == len(expected_ids)
    returned_ids = {p.payee_id for p in payees}
    assert returned_ids == expected_ids


def test_get_payees_filter_abacus_states(payee_fixtures, abacus_state_fixtures):
    """Only payees with matching abacus state dicts are returned."""
    payees, total_count = Payee.get_payees(
        limit=10,
        abacus_states=[
            {
                'action_status': ACTION_STATUSES.COMPLETE,
                'action_name': PAYEE_ACTION_NAMES.BANKING_ELIGIBILITY,
            }
        ],
    )
    assert total_count == 1
    assert {p.payee_id for p in payees} == {1}

    payees, total_count = Payee.get_payees(
        limit=10,
        abacus_states=[
            {
                'action_status': ACTION_STATUSES.COMPLETE,
                'action_name': PAYEE_ACTION_NAMES.BANKING_ELIGIBILITY,
            },
            {
                'action_status': ACTION_STATUSES.ERROR,
                'action_name': PAYEE_ACTION_NAMES.BANKING_ELIGIBILITY,
            },
        ],
    )
    assert total_count == 2
    assert {p.payee_id for p in payees} == {1, 2}


def test_get_payees_filter_account_ids(payee_fixtures, payee_collaborator_fixtures):
    """Only collaborator payees with matching account_ids are returned."""
    payees, total_count = Payee.get_payees(limit=10, account_ids=[1])
    assert total_count == 2
    assert {p.payee_id for p in payees} == {1, 2}

    payees, total_count = Payee.get_payees(limit=10, account_ids=[999])
    assert total_count == 0


def test_get_payees_filter_payoneer_program_ids(payee_fixtures):
    """Only payees with matching payoneer_program_id are returned."""
    payees, total_count = Payee.get_payees(limit=10, payoneer_program_ids=[1])
    assert total_count == 2

    payees, total_count = Payee.get_payees(limit=10, payoneer_program_ids=[999])
    assert total_count == 0


def test_get_payees_filter_search_term_by_name(payee_fixtures):
    """Search term matches payee_name case-insensitively."""
    PayeeFactory.create(
        payee_id=None,
        payee_name='Alice Wonder',
        payoneer_client_reference_id='alice-ref',
    )
    PayeeFactory.create(
        payee_id=None, payee_name='Bob Smith', payoneer_client_reference_id='bob-ref'
    )

    payees, total_count = Payee.get_payees(limit=10, search_term='alice')
    assert total_count == 1
    assert payees[0].payee_name == 'Alice Wonder'


def test_get_payees_filter_search_term_by_id(payee_fixtures):
    """Search term matches payee_id when it is numeric."""
    payees, total_count = Payee.get_payees(limit=10, search_term='1')
    assert {p.payee_id for p in payees} == {1}