"""Tests for Handlers."""

import json
from unittest.mock import call, MagicMock, patch

from owsresponse import response
import pytest

from blacklist_manager import handlers
from blacklist_manager import api


@pytest.fixture
def client():
    """Return flask test client."""
    return api.app.test_client()


@patch('blacklist_manager.handlers.g', spec=['log'])
def test_exception_handler(mock_g):
    """Verify exception_Handler returns 500 status code and json payload."""
    message = (
        'The server encountered an internal error '
        'and was unable to complete your request.')
    mock_error = MagicMock()
    server_response = handlers.exception_handler(mock_error)
    mock_g.log.exception.assert_called_with(mock_error)

    # assert status code is 500
    assert server_response.status_code == 500

    # assert json payload
    response_message = json.loads(server_response.data.decode())
    assert response_message['message'] == message
    assert response_message['code'] == response.error.ERROR_CODE_INTERNAL_ERROR


@patch('blacklist_manager.handlers.blacklist_words.validate_artists_for_blacklisting')
def test_validate_artists_handler_success_200(mock_validate, client):
    """Test handler returns 200 on success."""
    mock_validate.return_value = MagicMock(status=200)
    resp = client.post(
        '/validate-artists',
        json={"product_artists": [{"name": "A"}]}
    )
    assert resp.status_code == 200
    mock_validate.assert_called_once_with({"product_artists": [{"name": "A"}]})


@patch('blacklist_manager.handlers.blacklist_words.validate_artists_for_blacklisting')
def test_validate_artists_handler_status_code_400(mock_validate, client):
    """Test handler returns status 400."""
    mock_validate.return_value = MagicMock(status=400, message={"error": "take a look"}, errors=None)
    resp = client.post(
        '/validate-artists',
        json={"product_artists": [{"name": "A"}]}
    )
    assert resp.status_code == 400
    assert resp.get_json() == {"error": "take a look"}
    mock_validate.assert_called_once_with({"product_artists": [{"name": "A"}]})


@pytest.mark.parametrize(
    ("pdp_authorized", "expected_handler_called", "expected_status_code",
     "expected_error_response_calls", "expected_flaskify_calls"),
    [
        pytest.param(
            True, True, 200, [], [],
            id="PDP authorizes — handler is called",
        ),
        pytest.param(
            False, False, 403,
            [call(code='forbidden', message='User is forbidden', status=403)],
            [call('error_response')],
            id="PDP denies — 403 returned",
        ),
    ]
)
@patch('blacklist_manager.handlers.response.create_error_response')
@patch('blacklist_manager.handlers.flaskify')
@patch('blacklist_manager.handlers.authorization.pdp_authorize_resource_without_attributes')
def test_require_pdp_auth(
    mock_pdp_authorize,
    mock_flaskify,
    mock_create_error_response,
    pdp_authorized,
    expected_handler_called,
    expected_status_code,
    expected_error_response_calls,
    expected_flaskify_calls,
):
    """Test require_standalone_authorization decorator for authorized and denied cases."""
    mock_handler = MagicMock(return_value=MagicMock(status_code=200))
    mock_handler.__name__ = 'mock_handler'
    mock_pdp_authorize.return_value = pdp_authorized
    mock_flaskify.return_value = MagicMock(status_code=expected_status_code)
    mock_create_error_response.return_value = 'error_response'

    decorated = handlers.require_pdp_auth(
        action='xyz',
        resource_type='example_type',
        resource_id=0,
    )(mock_handler)

    with api.app.test_request_context():
        result = decorated()

    mock_pdp_authorize.assert_called_once_with(
        action='xyz',
        resource_id=0,
        resource_type='example_type',
    )
    assert mock_handler.called == expected_handler_called
    assert result.status_code == expected_status_code
    assert mock_create_error_response.mock_calls == expected_error_response_calls
    assert mock_flaskify.mock_calls == expected_flaskify_calls