"""Tests for the ows-abacus-state connector."""

from http import HTTPStatus
from typing import Any
from unittest import mock

import pytest

from payee.connectors import ows_abacus_state
from payee.utils.exception import AbacusStateException
from tests.utils.factories import AbacusStateFactory


def clean_state(item: dict[str, Any]) -> dict[str, Any]:
    """Remove extra fields."""
    for key in ('created_at', 'created_by', 'last_modified', 'last_modified_by'):
        del item[key]
    return item


@pytest.mark.parametrize(
    'response,status',
    (
        ([], HTTPStatus.OK),
        ([], HTTPStatus.BAD_REQUEST),
        (AbacusStateFactory.build_batch(4), HTTPStatus.OK),
        ([AbacusStateFactory.build(message=None)], HTTPStatus.OK),
    ),
)
@mock.patch('payee.connectors.ows_abacus_state.ows_client')
@mock.patch('payee.connectors.ows_abacus_state.flask_request')
def test_get_payee_states(
    mocked_flask_request: mock.Mock,
    mocked_ows_client: mock.Mock,
    response: list[dict[str, Any]],
    status: HTTPStatus,
):
    account_payee_id = 132
    ows_headers = {'header1': 'test2'}

    mocked_flask_request.get_ows_headers.return_value = ows_headers
    mocked_ows_client.get.return_value = mock.Mock(
        status_code=status, json=mock.Mock(return_value=response)
    )

    if status == HTTPStatus.OK:
        result = ows_abacus_state.get_payee_states(account_payee_id)
        assert result == {item['action_name']: clean_state(item) for item in response}
    else:
        with pytest.raises(AbacusStateException):
            ows_abacus_state.get_payee_states(account_payee_id)

    mocked_flask_request.get_ows_headers.assert_called_once_with()
    assert mocked_ows_client.get.call_args_list == [
        mock.call(
            'ows-abacus-state',
            f'/abacus-state/account_payee/{account_payee_id}/',
            headers=ows_headers,
        )
    ]


@pytest.mark.parametrize(
    'mock_states,status',
    (
        ([], HTTPStatus.BAD_REQUEST),
        (AbacusStateFactory.build_batch(4), HTTPStatus.CREATED),
        ([AbacusStateFactory.build(message=None)], HTTPStatus.CREATED),
    ),
)
@mock.patch('payee.connectors.ows_abacus_state.ows_client')
@mock.patch('payee.connectors.ows_abacus_state.flask_request')
def test_create_account_payee_states(
    mocked_flask_request: mock.Mock,
    mocked_ows_client: mock.Mock,
    mock_states: list[dict[str, Any]],
    status: HTTPStatus,
):
    account_payee_id = 132
    ows_headers = {'header1': 'test2'}

    mocked_flask_request.get_ows_headers.return_value = ows_headers
    mocked_ows_client.post.return_value = mock.Mock(
        status_code=status, json=mock.Mock(return_value=mock_states)
    )

    actions = [action['action_name'] for action in mock_states]

    if status == HTTPStatus.CREATED:
        result = ows_abacus_state.create_payee_states(
            account_payee_id,
            'account_payee',
            actions,
        )
        assert result == {
            item['action_name']: clean_state(item) for item in mock_states
        }
        expected_json = [
            {
                'parent_table_id': account_payee_id,
                'action_name': action,
                'parent_table_name': 'account_payee',
            }
            for action in actions
        ]
    else:
        with pytest.raises(AbacusStateException):
            ows_abacus_state.create_payee_states(account_payee_id, 'account_payee', [])
        expected_json = []

    mocked_flask_request.get_ows_headers.assert_called_once_with()
    assert mocked_ows_client.post.call_args_list == [
        mock.call(
            'ows-abacus-state',
            '/abacus-states/',
            headers=ows_headers,
            json=expected_json,
        )
    ]


@pytest.mark.parametrize(
    'mock_state,status',
    (
        (None, HTTPStatus.BAD_REQUEST),
        (AbacusStateFactory.build(), HTTPStatus.OK),
        (AbacusStateFactory.build(message=None), HTTPStatus.OK),
    ),
)
@mock.patch('payee.connectors.ows_abacus_state.ows_client')
@mock.patch('payee.connectors.ows_abacus_state.flask_request')
def test_update_state(
    mocked_flask_request: mock.Mock,
    mocked_ows_client: mock.Mock,
    mock_state: dict[str, Any],
    status: HTTPStatus,
):
    abacus_state_id = 132
    ows_headers = {'header1': 'test2'}

    mocked_flask_request.get_ows_headers.return_value = ows_headers
    mocked_ows_client.put.return_value = mock.Mock(
        status_code=status, json=mock.Mock(return_value=mock_state)
    )

    if status == HTTPStatus.OK:
        result = ows_abacus_state.update_state(
            abacus_state_id, mock_state['action_status'], mock_state['message']
        )
        assert result == clean_state(mock_state)
        expected_json = {
            'action_status': mock_state['action_status'],
            'message': mock_state['message'],
        }
    else:
        with pytest.raises(AbacusStateException):
            ows_abacus_state.update_state(abacus_state_id, 'init', 'test_message')
        expected_json = {
            'action_status': 'init',
            'message': 'test_message',
        }

    mocked_flask_request.get_ows_headers.assert_called_once_with()
    assert mocked_ows_client.put.call_args_list == [
        mock.call(
            'ows-abacus-state',
            f'/abacus-state/{abacus_state_id}/',
            headers=ows_headers,
            json=expected_json,
        )
    ]