"""Tests for Abacus statement period handlers."""

import json
from unittest.mock import ANY, patch

from collaborator.constants import error
from collaborator.constants.features import (
    ABACUS_COLLABORATORS,
    ABACUS_COLLABORATORS_PAYONEER_API_INTEGRATION,
)
from collaborator.schemas.abacus_statement_period import (
    GetDpPaymentsForAbacusStatementPeriodResponseSchema,
    PatchDpPaymentsForAbacusStatementPeriodResponseSchema,
    PatchDpPaymentsForAbacusStatementPeriodSchema,
    PutDpPaymentsForAbacusStatementPeriodResponseSchema,
)
from collaborator.schemas.dp_payment import DpPaymentAction, DpPaymentSchema
from tests.testutils import mock_auth
from tests.testutils.seed.dp_payment_seed import dp_payment_seed_data


@patch("collaborator.handlers.abacus_statement_period.get_dp_payments")
def test_get_dp_payments_for_abacus_statement_period(
    mock_get_dp_payments,
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test GET handler for DP payments on an Abacus statement period."""
    mock_auth(mocker, mock_account.id)
    mock_features({ABACUS_COLLABORATORS: True})

    mock_payments = [DpPaymentSchema(**payment) for payment in dp_payment_seed_data]
    mock_get_dp_payments.return_value = (
        mock_payments,
        123,
    )

    abacus_statement_period_id = 1
    result = auth_client.get(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payments"
    )

    mock_get_dp_payments.assert_called_once_with(abacus_statement_period_id)

    assert result.status_code == 200
    assert (
        result.json
        == GetDpPaymentsForAbacusStatementPeriodResponseSchema(
            currency_agnostic_total_amount=123,
            total_count=len(dp_payment_seed_data),
            payments=mock_payments,
        ).dump()
    )


@patch("collaborator.logic.abacus_statement_period.create_dp_payment_transactions")
def test_create_dp_payment_transactions_for_abacus_statement_period(
    mock_create_dp_payment_transactions,
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test POST handler for DP payment transactions on an Abacus statement period."""
    mock_auth(mocker, mock_account.id)
    mock_features({ABACUS_COLLABORATORS: True})

    abacus_statement_period_id = 1
    result = auth_client.post(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payment-transactions"
    )

    mock_create_dp_payment_transactions.assert_called_once_with(
        abacus_statement_period_id,
        ANY,
    )
    assert result.status_code == 204


@patch("collaborator.logic.abacus_statement_period.replace_dp_payments")
def test_put_dp_payments_for_abacus_statement_period(
    mock_replace_dp_payments,
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test PUT handler for DP payments on an Abacus statement period."""
    mock_auth(mocker, mock_account.id)
    mock_features({ABACUS_COLLABORATORS: True})

    mock_payments = [DpPaymentSchema(**payment) for payment in dp_payment_seed_data]
    mock_replace_dp_payments.return_value = (
        mock_payments,
        123,
    )

    abacus_statement_period_id = 1
    result = auth_client.put(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payments"
    )

    mock_replace_dp_payments.assert_called_once_with(abacus_statement_period_id, ANY)

    assert result.status_code == 200
    assert (
        result.json
        == PutDpPaymentsForAbacusStatementPeriodResponseSchema(
            currency_agnostic_total_amount=123,
            total_count=len(dp_payment_seed_data),
            payments=mock_payments,
        ).dump()
    )


@patch("collaborator.logic.abacus_statement_period.approve_dp_payments")
def test_patch_dp_payments_for_abacus_statement_period(
    mock_approve_dp_payments,
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test PATCH handler for DP payments on an Abacus statement period."""
    mock_auth(mocker, mock_account.id)
    mock_features({ABACUS_COLLABORATORS: True})

    mock_payments = [DpPaymentSchema(**payment) for payment in dp_payment_seed_data]
    mock_approve_dp_payments.return_value = mock_payments

    abacus_statement_period_id = 1
    result = auth_client.patch(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payments",
        content_type="application/json",
        data=json.dumps(
            PatchDpPaymentsForAbacusStatementPeriodSchema(
                action_name=DpPaymentAction.APPROVE,
            ).dump()
        ),
    )

    mock_approve_dp_payments.assert_called_once_with(abacus_statement_period_id, ANY)

    assert result.status_code == 200
    assert (
        result.json
        == PatchDpPaymentsForAbacusStatementPeriodResponseSchema(
            total_count=len(dp_payment_seed_data),
            payments=mock_payments,
        ).dump()
    )


@patch("collaborator.logic.abacus_statement_period.submit_dp_payments")
def test_submit_dp_payments_for_abacus_statement_period(
    mock_submit_dp_payments,
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test POST handler for submitting DP payments for an Abacus statement period."""
    mock_auth(mocker, mock_account.id)
    mock_features({ABACUS_COLLABORATORS_PAYONEER_API_INTEGRATION: True})

    expected_result = {"submitted_count": 2}
    mock_submit_dp_payments.return_value = expected_result

    abacus_statement_period_id = 1
    result = auth_client.post(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payments/submit-to-payoneer"
    )

    mock_submit_dp_payments.assert_called_once_with(abacus_statement_period_id, ANY)

    assert result.status_code == 200
    assert result.json == expected_result


def test_submit_dp_payments_feature_disabled(
    auth_client,
    mock_account,
    mocker,
    mock_features,
):
    """Test POST submit returns 403 when feature flag is disabled."""
    mock_auth(mocker, mock_account.id)

    abacus_statement_period_id = 1
    result = auth_client.post(
        f"/abacus-statement-period/{abacus_statement_period_id}/dp-payments/submit-to-payoneer"
    )

    assert result.status_code == 403
    assert result.json["code"] == error.ERROR_CODE_AUTHORIZATION
    assert result.json["message"] == error.ERROR_MESSAGE_FORBIDDEN_USER