"""Test contract reserve handlers."""

from decimal import Decimal
from unittest.mock import MagicMock, patch

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


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_create_contract_reserve(mock_logic, fixture_client):
    """Tets to create contract_reserve."""
    contract_id = 123
    json_body = {
        'installments_in_months': 4,
        'reserve_release_offset_in_months': 2,
        'reserve_rate': '80.00',
    }
    mock_logic.create_contract_reserve.return_value = response.Response(
        message='ok', status=201
    )

    res = fixture_client.post(f'/contract/{contract_id}/reserves/', json=json_body)

    assert res.status_code == 201
    mock_logic.create_contract_reserve.assert_called_once_with(
        contract_id=123,
        installments_in_months=4,
        reserve_release_offset_in_months=2,
        reserve_rate=Decimal('80.00'),
    )


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_update_reserve_by_contract_id(mock_logic, fixture_client):
    """Tets to update reserve by contract_id."""
    contract_id = 123
    json_body = {
        'installments_in_months': 4,
        'reserve_release_offset_in_months': 2,
        'reserve_rate': '80.00',
    }
    mock_logic.update_contract_reserve_by_contract_id.return_value = response.Response(
        message='ok', status=201
    )

    res = fixture_client.put(f'/contract/{contract_id}/reserves/', json=json_body)

    assert res.status_code == 201
    mock_logic.update_contract_reserve_by_contract_id.assert_called_once_with(
        contract_id=123,
        installments_in_months=4,
        reserve_release_offset_in_months=2,
        reserve_rate=Decimal('80.00'),
    )


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_update_reserve_by_contract_id_validates_payload(mock_logic, fixture_client):
    """Test update reserve by contract_id validates payload."""
    contract_id = 123
    json_body = {}

    res = fixture_client.put(f'/contract/{contract_id}/reserves/', json=json_body)

    assert res.status_code == 400
    assert not mock_logic.update_contract_reserve_by_contract_id.called


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_get_reserve_by_contract_id(mock_logic, fixture_client):
    """Test to get contract_reserve."""
    contract_id = 123
    expected_response = {
        'release_schedule': [
            '0.250000000000',
            '0.250000000000',
            '0.250000000000',
            '0.250000000000',
        ],
        'contract_reserve_id': 1,
        'installments_in_months': 4,
        'reserve_release_offset_in_months': 2,
        'reserve_rate': '80.00',
        'contract_id': contract_id,
    }
    mock_logic.get_reserve_by_contract_id.return_value = response.Response(
        message=expected_response, status=200
    )

    res = fixture_client.get(f'/contract/{contract_id}/reserves')

    assert res.status_code == 200
    assert res.json == expected_response
    mock_logic.get_reserve_by_contract_id.assert_called_once_with(contract_id)


@pytest.mark.parametrize(
    [
        'standalone_check_result',
        'get_account_id_result',
        'pdp_check_result',
        'expected_status',
    ],
    [
        pytest.param(True, None, None, 200, id='Standalone check pass'),
        pytest.param(False, None, None, 403, id='Account id not found'),
        pytest.param(False, 47, False, 403, id='PDP check fail'),
        pytest.param(False, 47, True, 200, id='PDP check pass'),
    ],
)
@patch('abacus_contract.blueprints.contract_reserve.logic')
@patch('abacus_contract.blueprints.contract_reserve.contract_logic')
@patch('abacus_contract.blueprints.contract_reserve.authorization')
@patch('abacus_contract.blueprints.contract_reserve.flask_request')
def test_get_reserves_by_contract_id_authorization(
    mock_flask_request: MagicMock,
    mock_authorization: MagicMock,
    mock_contract_logic: MagicMock,
    mock_logic: MagicMock,
    standalone_check_result: bool,
    get_account_id_result: int | None,
    pdp_check_result: bool | None,
    expected_status: int,
    fixture_client: flask_testing.FlaskClient,
) -> None:
    """Test authorization for getting reserves by contract_id."""
    contract_id = 123
    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_check_result
    mock_logic.get_reserve_by_contract_id.return_value = response.Response()

    res = fixture_client.get(f'/contract/{contract_id}/reserves')

    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(
            contract_id
        )
        if get_account_id_result:
            mock_authorization.pdp_authorize_many_accounts.assert_called_once_with(
                [get_account_id_result]
            )


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_get_contract_reserves_by_ids(mock_logic, fixture_client):
    """Test to get reserves by list of contract_reserve_ids via POST request."""
    contract_reserve_ids = [1]
    expected_response = [
        {
            'account_id': 1,
            'release_schedule': ['0.500000000000', '0.500000000000'],
            'contract_reserve_id': 1,
            'installments_in_months': 4,
            'reserve_release_offset_in_months': 2,
            'reserve_rate': '80.00',
            'contract_id': 1,
        }
    ]

    mock_logic.get_contract_reserves_by_ids.return_value = response.Response(
        message=expected_response, status=200
    )
    res = fixture_client.post('/contract-reserves/', json=contract_reserve_ids)

    assert res.status_code == 200
    assert res.json == expected_response
    mock_logic.get_contract_reserves_by_ids.assert_called_once_with(
        contract_reserve_ids
    )


@patch('abacus_contract.blueprints.contract_reserve.logic')
def test_get_contract_reserves_by_contract_ids(mock_logic, fixture_client):
    """Test to get reserves by list of contract_ids via POST request."""
    contract_ids = [1]
    expected_response = [
        {
            'release_schedule': ['0.500000000000', '0.500000000000'],
            'contract_reserve_id': 1,
            'installments_in_months': 4,
            'reserve_release_offset_in_months': 2,
            'reserve_rate': '80.00',
            'contract_id': 1,
        }
    ]

    mock_logic.get_contract_reserves_by_contract_ids.return_value = response.Response(
        message=expected_response, status=200
    )
    res = fixture_client.post('/contract/contract-reserves/', json=contract_ids)

    assert res.status_code == 200
    assert res.json == expected_response
    mock_logic.get_contract_reserves_by_contract_ids.assert_called_once_with(
        contract_ids
    )