"""Test KYC notification models."""

from unittest import mock
from uuid import UUID

from pydantic import ValidationError
import pytest

from src.models.kyc_notification import (
    PayeeKycApprovedRequestModel,
    PayeeKycDeclinedRequestModel,
    PayeeKycNotificationRequestModel,
    PayeeKycRequirementReopenRequestModel,
)
from src.models.payee import PayeeEntityType


def test_payee_kyc_approved_request_model_account_payee_success() -> None:
    """Test PayeeKycApprovedRequestModel."""
    model_obj = PayeeKycApprovedRequestModel.model_validate(
        {'Payee Id': '12', 'Payoneer Id': '3131'}
    )

    assert dict(model_obj) == dict(
        payoneer_client_reference_id=12, payoneer_payee_id=3131
    )
    assert model_obj.payee_entity_type == PayeeEntityType.account_payee
    assert model_obj.payee_entity_id == 12


@mock.patch('src.models.kyc_notification.get_payee')
def test_payee_kyc_approved_request_model_payee_success(
    mocked_get_payee: mock.Mock,
) -> None:
    """Test PayeeKycApprovedRequestModel."""
    payoneer_client_reference_id = '00000000-0000-4000-8000-000000000000'

    model_obj = PayeeKycApprovedRequestModel.model_validate(
        {
            'Payee Id': payoneer_client_reference_id,
            'Payoneer Id': '3131',
        }
    )

    mocked_get_payee.return_value = mock.Mock(payee_id=9001)

    assert dict(model_obj) == dict(
        payoneer_client_reference_id=UUID(payoneer_client_reference_id),
        payoneer_payee_id=3131,
    )
    assert model_obj.payee_entity_type == PayeeEntityType.payee
    assert model_obj.payee_entity_id == 9001


def test_payee_kyc_approved_request_model_failure() -> None:
    """Test PayeeKycApprovedRequestModel validation failure."""
    with pytest.raises(ValidationError) as exc_info:
        PayeeKycApprovedRequestModel.model_validate({'Payee Id': 'abc'})
    assert [e['loc'] for e in exc_info.value.errors()] == [
        ('Payee Id', 'int'),
        ('Payee Id', 'uuid'),
        ('Payoneer Id',),
    ]


@pytest.mark.parametrize(
    'payoneer_client_reference_id,payoneer_payee_id,reason',
    (('15', '123', ''), ('12', 321, None), ('178777', '5472353759483768', 'test_re')),
)
def test_payee_kyc_declined_request_model_success(
    payoneer_client_reference_id: str,
    payoneer_payee_id: str | int,
    reason: str | None,
) -> None:
    """Test PayeeKycDeclinedRequestModel."""
    assert dict(
        PayeeKycDeclinedRequestModel.model_validate(
            {
                'Payee Id': payoneer_client_reference_id,
                'Payoneer Id': payoneer_payee_id,
                **({'Reason Description': reason} if reason is not None else {}),
            }
        )
    ) == dict(
        payoneer_client_reference_id=int(payoneer_client_reference_id),
        payoneer_payee_id=int(payoneer_payee_id),
        reason=reason,
    )


def test_payee_kyc_declined_request_model_failure() -> None:
    """Test PayeeKycDeclinedRequestModel validation failure."""
    with pytest.raises(ValidationError) as exc_info:
        PayeeKycDeclinedRequestModel.model_validate({'Payee Id': 'abc'})
    assert [e['loc'] for e in exc_info.value.errors()] == [
        ('Payee Id', 'int'),
        ('Payee Id', 'uuid'),
        ('Payoneer Id',),
    ]


@pytest.mark.parametrize(
    'payoneer_client_reference_id,payoneer_payee_id,session_id,requirement_id,sub_requirement_id',
    (
        ('178777', '5472353759483768', 'tst_s_id', 'tst_req_id', None),
        ('12', 321, None, None, 'tst_sub_req_id'),
    ),
)
def test_payee_kyc_notification_request_model_success(
    payoneer_client_reference_id: str,
    payoneer_payee_id: str | int,
    session_id: str | None,
    requirement_id: str | None,
    sub_requirement_id: str | None,
) -> None:
    """Test PayeeKycNotificationRequestModel."""
    assert dict(
        PayeeKycNotificationRequestModel.model_validate(
            {
                'Payee Id': payoneer_client_reference_id,
                'Payoneer Id': payoneer_payee_id,
                'Session Id': session_id,
                'File Upload Link': 'file_link',
                'Requirement Id': requirement_id,
                'Sub Requirement Id': sub_requirement_id,
            }
        )
    ) == dict(
        payoneer_client_reference_id=int(payoneer_client_reference_id),
        payoneer_payee_id=int(payoneer_payee_id),
        session_id=session_id,
        file_upload_link='file_link',
        requirement_id=requirement_id,
        sub_requirement_id=sub_requirement_id,
    )


def test_payee_kyc_notification_request_model_failure() -> None:
    """Test PayeeKycNotificationRequestModel validation failure."""
    with pytest.raises(ValidationError) as exc_info:
        PayeeKycNotificationRequestModel.model_validate({'Payoneer Id': 'abc'})
    assert [e['loc'] for e in exc_info.value.errors()] == [
        ('Payee Id',),
        ('Payoneer Id',),
        ('File Upload Link',),
    ]


@pytest.mark.parametrize(
    (
        'payoneer_client_reference_id,payoneer_payee_id,session_id,requirement_type_id,sub_requirement_status_id'
        ',possible_sub_requirement_types,entity_reference_type_id,entity_reference_id'
    ),
    (
        ('178777', '5472353759483768', 's_id', '18', '55', '1,2,5,abc', '8', 'ref_id'),
        ('12', 321, None, None, None, None, None, None),
        ('12', 321, None, 18, 55, None, 8, None),
    ),
)
def test_payee_kyc_requirement_reopen_request_model_success(
    payoneer_client_reference_id: str,
    payoneer_payee_id: str | int,
    session_id: str | None,
    requirement_type_id: int | str | None,
    sub_requirement_status_id: int | str | None,
    possible_sub_requirement_types: str | None,
    entity_reference_type_id: int | str | None,
    entity_reference_id: str | None,
) -> None:
    """Test PayeeKycRequirementReopenRequestModel."""
    assert dict(
        PayeeKycRequirementReopenRequestModel.model_validate(
            {
                'Payee Id': payoneer_client_reference_id,
                'Payoneer Id': payoneer_payee_id,
                'Session Id': session_id,
                'File Upload Link': 'file_link',
                'Requirement Type Id': requirement_type_id,
                'Sub Requirement Status Id': sub_requirement_status_id,
                'Possible Sub Requirement Types': possible_sub_requirement_types,
                'Entity Reference Type Id': entity_reference_type_id,
                'Entity Reference Id': entity_reference_id,
            }
        )
    ) == dict(
        payoneer_client_reference_id=int(payoneer_client_reference_id),
        payoneer_payee_id=int(payoneer_payee_id),
        session_id=session_id,
        file_upload_link='file_link',
        requirement_type_id=int(requirement_type_id)
        if requirement_type_id
        else requirement_type_id,
        sub_requirement_status_id=int(sub_requirement_status_id)
        if sub_requirement_status_id
        else sub_requirement_status_id,
        possible_sub_requirement_types=possible_sub_requirement_types,
        entity_reference_type_id=int(entity_reference_type_id)
        if entity_reference_type_id
        else entity_reference_type_id,
        entity_reference_id=entity_reference_id,
    )


def test_payee_kyc_requirement_reopen_request_model_failure() -> None:
    """Test PayeeKycRequirementReopenRequestModel validation failure."""
    with pytest.raises(ValidationError) as exc_info:
        PayeeKycRequirementReopenRequestModel.model_validate({'Payoneer Id': 'abc'})
    assert [e['loc'] for e in exc_info.value.errors()] == [
        ('Payee Id',),
        ('Payoneer Id',),
        ('File Upload Link',),
    ]