"""Tests for Handlers."""

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

from owsresponse import response
import pytest

from vector_job_rules import api
from vector_job_rules import handlers
from vector_job_rules.constants import error


def get_client():
    """Create an api test client fixture."""
    return api.app.test_client()


@pytest.fixture
def fixture_client():
    """Create an api test client fixture."""
    return get_client()


def fixture_ok_response():
    """Create a response.Response fixture for generic ok."""
    return response.Response(error.SUCCESS_CODE)


@patch('vector_job_rules.handlers.rule.get_rules', return_value=fixture_ok_response())
@pytest.mark.parametrize(
    'fixture_client, url, rule_ids, status, status_code',
    [
        (get_client(), '/rules', None, None, 200),
        (get_client(), '/rules?status=inactive', None, 'inactive', 200),
        (get_client(), '/rules?status=active', None, 'active', 200),
        (get_client(), '/rules?status=inactive&rule_ids=1', (1,), 'inactive', 200),
        (
            get_client(),
            '/rules?status=inactive&rule_ids=1,2,3',
            (
                1,
                2,
                3,
            ),
            'inactive',
            200,
        ),
        (get_client(), '/rules?status=test', None, None, 400),
        (get_client(), '/rules?status=inactive&rule_ids=test', None, None, 400),
    ],
)
def test_handler_get_rules_success(
    mock_get_rules, fixture_client, url, rule_ids, status, status_code
):
    """Test GET /rules handler success."""
    result = fixture_client.get(url)

    if status_code == 200:
        mock_get_rules.assert_called_with(rule_ids=rule_ids, status=status)

    assert result.status_code == status_code

    if status_code == 400:
        response_body = json.loads(result.data.decode())
        assert response_body['message'] == error.INVALID_QUERY_PARAM_VALUE


@patch(
    'vector_job_rules.handlers.rule.get_rules',
    return_value=response.Response(message={'items': [123]}),
)
def test_handler_get_rules_by_id_success(mock_get_rules, fixture_client):
    """Test GET /rules/conditions handler success."""
    result = fixture_client.get('/rules/123')
    mock_get_rules.assert_called_with(rule_ids=(123,))

    assert result.status_code == 200


@patch(
    'vector_job_rules.handlers.rule.get_rules',
    return_value=response.Response(message={'items': []}),
)
def test_handler_get_rules_by_id_not_found(mock_get_rules, fixture_client):
    """Test GET /rules/conditions handler success."""
    result = fixture_client.get('/rules/123')
    mock_get_rules.assert_called_with(rule_ids=(123,))

    assert result.status_code == 404


@patch(
    'vector_job_rules.handlers.rule_condition_field.get_fields',
    return_value=fixture_ok_response(),
)
def test_handler_get_fields_success(mock_get_fields, fixture_client):
    """Test GET /rules/conditions handler success."""
    result = fixture_client.get('/rules/conditions')
    mock_get_fields.assert_called()

    assert result.status_code == 200


@patch(
    'vector_job_rules.handlers.rule.update_rules',
    return_value=response.Response(message='Rule priorities successfully updated.'),
)
def test_handler_update_rules(mock_update_rules, fixture_client):
    """Test PATCH /rules handler success."""
    payload = [{'rule_id': 1, 'priority': 1, 'updated_by': 1734}]
    result = fixture_client.patch('/rules', data=json.dumps(payload))
    mock_update_rules.assert_called_with(
        [{'rule_id': 1, 'priority': 1, 'updated_by': 1734}]
    )

    assert result.status_code == 200
    assert result.data == b'Rule priorities successfully updated.'


def test_handler_update_rules_without_updated_by_fail(fixture_client):
    """Test PATCH /rules handler success."""
    payload = [{'rule_id': 1, 'priority': 1}]
    result = fixture_client.patch('/rules', data=json.dumps(payload))

    assert result.status_code == 400
    result_body = json.loads(result.data)
    assert result_body['message']['0']['updated_by'] == [
        'Missing data for required field.'
    ]


def test_handler_update_rules_fail(fixture_client):
    """Test PATCH /rules handler fail."""
    payload = [{'rule_id': 'string', 'priority': 'string', 'updated_by': 'string'}]
    result = fixture_client.patch('/rules', data=json.dumps(payload))

    assert result.status_code == 400
    result_body = json.loads(result.data)
    assert result_body['message']['0']['rule_id'] == ['Not a valid integer.']
    assert result_body['message']['0']['priority'] == ['Not a valid integer.']
    assert result_body['message']['0']['updated_by'] == ['Not a valid integer.']


def test_exception_handler(fixture_client):
    """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()
    with api.app.app_context() as context:
        context.g.log = MagicMock()
        server_response = handlers.exception_handler(mock_error)
        context.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