"""Tests for Contract Advance handlers."""

from unittest import mock

import pytest
from flask import testing as flask_testing
from owsresponse import response

from abacus_contract.tests.utils.factories import (
    ContractAdvanceFactory,
    ContractFactory,
)


@mock.patch('abacus_contract.blueprints.contract_advance.logic')
def test_get_contract_advances(mock_logic, fixture_client):
    """Test to get a list of contract_advances by contract_id and advance status."""
    contract_id = 1
    status = 'pending'
    mock_logic.get_contract_advances.return_value = response.Response(
        message='ok', status=200
    )

    res = fixture_client.get(
        f'/contract/{contract_id}/advances/{status}/?limit=2&offset=0'
    )

    assert res.status_code == 200
    mock_logic.get_contract_advances.assert_called_once()


@pytest.mark.parametrize(
    [
        'standalone_check_result',
        'get_account_id_result',
        'pdp_auth_result',
        'expected_status',
    ],
    [
        pytest.param(True, None, None, 200, id='Standalone check pass'),
        pytest.param(False, None, None, 403, id='Account not found'),
        pytest.param(False, 9, False, 403, id='PDP auth fail'),
        pytest.param(False, 9, True, 200, id='PDP auth pass'),
    ],
)
@mock.patch('abacus_contract.blueprints.contract_advance.authorization')
@mock.patch('abacus_contract.blueprints.contract_advance.contract_logic')
@mock.patch('abacus_contract.blueprints.contract_advance.flask_request')
def test_get_contract_advances_authorization(
    mock_flask_request: mock.MagicMock,
    mock_contract_logic: mock.MagicMock,
    mock_authorization: mock.MagicMock,
    standalone_check_result: bool,
    get_account_id_result: int | None,
    pdp_auth_result: bool | None,
    expected_status: int,
    fixture_client: flask_testing.FlaskClient,
):
    """Test authorization for getting contract advances."""
    mock_flask_request.verify_rules_access_standalone.return_value = (
        standalone_check_result
    )
    mock_contract_logic.get_account_id_by_contract_id.return_value = (
        get_account_id_result
    )
    mock_authorization.pdp_authorize_many_accounts.return_value = pdp_auth_result
    contract_id = 1
    status = 'pending'

    res = fixture_client.get(f'/contract/{contract_id}/advances/{status}/')
    assert res.status_code == expected_status
    mock_flask_request.verify_rules_access_standalone.assert_called_once()
    if not standalone_check_result:
        mock_contract_logic.get_account_id_by_contract_id.assert_called_once_with(1)
        if get_account_id_result:
            mock_authorization.pdp_authorize_many_accounts.assert_called_once_with([9])


@mock.patch('abacus_contract.blueprints.contract_advance.logic')
def test_delete_contract_advance(mock_logic, fixture_client):
    """Test to delete contract advance."""
    contract = ContractFactory.create()
    contract_advance = ContractAdvanceFactory.create(contract=contract)
    contract_advance_id = contract_advance.contract_advance_id

    mock_logic.delete_contract_advance.return_value = response.Response(status=204)

    res = fixture_client.delete(f'/contract-advance/{contract_advance_id}/')

    assert res.status_code == 204
    mock_logic.delete_contract_advance.assert_called_once()