"""Tests for payee handlers."""

from unittest.mock import Mock, patch

from flask.testing import FlaskClient
import pytest

from payee.schemas.payee import (
    PayeeCollaboratorPaginatedSchema,
    PayeeDataloaderOutputSchema,
    PayeePaginatedSchema,
    PayeeSchema,
)
from tests.utils.factories import PayeeCollaboratorFactory, PayeeFactory


@patch('payee.blueprints.payee.logic')
def test_post_payee_bulk_success(
    logic_mock: Mock,
    fixture_client: FlaskClient,
):
    """Verify that POST route exists and returns 200 status code."""
    body = {
        'limit': 1,
        'offset': 0,
        'requires_review': False,
    }

    data = {
        'total_count': 2,
        'items': [
            PayeeFactory.build(),
            PayeeFactory.build(),
        ],
    }

    logic_mock.get_payees_paginated.return_value = data

    res = fixture_client.post('/payees/bulk', json=body)

    assert res.status_code == 200
    assert res.json == PayeePaginatedSchema().dump(data)
    logic_mock.get_payees_paginated.assert_called_once_with(
        limit=1,
        offset=0,
        requires_review=False,
        abacus_states=None,
        account_ids=None,
        payoneer_program_ids=None,
        search_term=None,
    )


@pytest.mark.parametrize(
    'body,call_args',
    (
        ({'collaborator_ids': [1]}, ([1], None)),
        ({'payoneer_client_reference_ids': ['uuid']}, (None, ['uuid'])),
    ),
)
@patch('payee.blueprints.payee.logic')
def test_post_payee_dataloader_success(
    logic_mock: Mock,
    fixture_client: FlaskClient,
    body: dict[str, list[int | str]],
    call_args: tuple[list[int] | None, list[str] | None],
):
    """Verify that POST route exists and returns 200 status code."""

    data = {
        'payees': [
            {'data': PayeeFactory.build()},
        ]
    }

    logic_mock.get_payees_dataloader.return_value = data
    res = fixture_client.post('/payee/dataloader', json=body)

    assert res.status_code == 200
    assert res.json == PayeeDataloaderOutputSchema().dump(data)
    logic_mock.get_payees_dataloader.assert_called_once_with(*call_args)


def test_post_payee_dataloader_error(
    fixture_client,
):
    """Verify that POST route exists and returns 400 status code."""
    res = fixture_client.post(
        '/payee/dataloader',
        json={'collaborator_ids': [1], 'payoneer_client_reference_ids': ['uuid']},
    )

    assert res.status_code == 400

    res = fixture_client.post('/payee/dataloader', json={})

    assert res.status_code == 400


@patch('payee.blueprints.payee.logic')
def test_post_payee_collaborator_success(
    logic_mock,
    fixture_client,
):
    """Verify that POST route exists and returns 201 status code."""
    logic_mock.get_payees_by_collaborator_ids.return_value = {}
    logic_mock.create_payee_collaborator.return_value = PayeeFactory.build()

    res = fixture_client.post(
        '/payee-collaborator',
        json={'collaborator_id': 1, 'reference_payment_type_id': 8},
    )

    assert res.status_code == 201
    assert res.json == PayeeSchema().dump(PayeeFactory.build())


@patch('payee.blueprints.payee.logic')
def test_post_payee_collaborator_if_exists(
    logic_mock,
    fixture_client,
):
    """Verify that POST returns 200 status code if payee exists."""
    logic_mock.get_payees_by_collaborator_ids.return_value = {1: PayeeFactory.build()}
    logic_mock.create_payee_collaborator.return_value = PayeeFactory.build()

    res = fixture_client.post(
        '/payee-collaborator',
        json={'collaborator_id': 1, 'reference_payment_type_id': 8},
    )

    assert res.status_code == 200
    assert res.json == PayeeSchema().dump(PayeeFactory.build())


@patch('payee.blueprints.payee.logic')
def test_post_payee_collaborator_bulk_success(
    logic_mock: Mock,
    fixture_client: FlaskClient,
):
    """Verify that POST route exists and returns 200 status code."""
    body = {
        'limit': 1,
        'offset': 0,
        'payee_ids': [1],
    }

    data = {
        'total_count': 2,
        'items': [
            PayeeCollaboratorFactory.build(),
            PayeeCollaboratorFactory.build(),
        ],
    }

    logic_mock.get_payee_collaborators_paginated.return_value = data

    res = fixture_client.post('/payee-collaborators/bulk', json=body)

    assert res.status_code == 200
    assert res.json == PayeeCollaboratorPaginatedSchema().dump(data)
    logic_mock.get_payee_collaborators_paginated.assert_called_once_with(**body)