"""Test for schedule handlers."""

from unittest.mock import MagicMock, patch

import pytest
from flask import testing
from owsresponse import response
from werkzeug.datastructures import MultiDict

from tests.utils.factories import ScheduleFactory


def test_get_schedule(fixture_client, mock_schedule_fixture):
    """Test GET endpoint to get schedule by id."""
    ScheduleFactory.create(**mock_schedule_fixture)
    schedule_id = 1234
    res = fixture_client.get(f'/schedule/{schedule_id}')

    assert res.status_code == 200
    assert res.json == mock_schedule_fixture


@pytest.mark.parametrize(
    ['standalone_check_result', 'pdp_check_result', 'expected_status'],
    [
        pytest.param(True, None, 200, id='standalone check pass'),
        pytest.param(False, False, 403, id='pdp check fail'),
        pytest.param(False, True, 200, id='pdp check pass'),
    ],
)
@patch('abacus_schedule.blueprints.schedule.authorization')
@patch('abacus_schedule.blueprints.schedule.flask_request')
def test_get_schedule_authorization(
    flask_request_mock: MagicMock,
    authorization_mock: MagicMock,
    standalone_check_result: bool,
    pdp_check_result: bool | None,
    expected_status: int,
    fixture_client: testing.FlaskClient,
) -> None:
    """Test authorization of GET /schedule/<id> endpoint."""
    flask_request_mock.verify_rules_access_standalone.return_value = (
        standalone_check_result
    )
    authorization_mock.pdp_authorize_resource.return_value = pdp_check_result
    ScheduleFactory.create(schedule_id=555)

    res = fixture_client.get('/schedule/555')

    assert res.status_code == expected_status
    flask_request_mock.verify_rules_access_standalone.assert_called_once()
    if standalone_check_result:
        authorization_mock.pdp_authorize_resource.assert_not_called()
    else:
        authorization_mock.pdp_authorize_resource.assert_called_once_with(
            resource_id=555, resource_type='abacus_schedule'
        )


@patch('abacus_schedule.blueprints.schedule.logic')
def test_get_schedule_by_target(mock_logic, fixture_client, mock_schedule_fixture):
    """Test GET endpoint to get sorted schedules by target."""
    alt_mock_schedule = mock_schedule_fixture.copy()
    alt_mock_schedule.update({'schedule_id': 1231, 'schedule_name': 'aaaa'})
    mock_list = [alt_mock_schedule, mock_schedule_fixture]
    mock_response = response.Response(message=mock_list)

    mock_logic.get_schedules_by_target.return_value = mock_response

    res = fixture_client.get('/schedules/contributor/126')

    assert res.status_code == 200
    assert res.json == mock_list
    mock_logic.get_schedules_by_target.assert_called_once_with(
        'contributor', '126', MultiDict([])
    )


@pytest.mark.parametrize(
    ['standalone_check_result', 'pdp_check_result', 'expected_status'],
    [
        pytest.param(True, None, 200, id='standalone check pass'),
        pytest.param(False, False, 403, id='pdp check fail'),
        pytest.param(False, True, 200, id='pdp check pass'),
    ],
)
@patch('abacus_schedule.blueprints.schedule.authorization')
@patch('abacus_schedule.blueprints.schedule.flask_request')
def test_get_schedules_by_target_authorization(
    flask_request_mock: MagicMock,
    authorization_mock: MagicMock,
    standalone_check_result: bool,
    pdp_check_result: bool | None,
    expected_status: int,
    fixture_client: testing.FlaskClient,
) -> None:
    """Test authorization of GET /schedules/<target_type>/<target_id> endpoint."""
    flask_request_mock.verify_rules_access_standalone.return_value = (
        standalone_check_result
    )
    authorization_mock.pdp_authorize_resource.return_value = pdp_check_result

    res = fixture_client.get('/schedules/contributor/a-target-id')

    assert res.status_code == expected_status
    flask_request_mock.verify_rules_access_standalone.assert_called_once()
    if standalone_check_result:
        authorization_mock.pdp_authorize_resource.assert_not_called()
    else:
        authorization_mock.pdp_authorize_resource.assert_called_once_with(
            resource_id='target_contributor_a-target-id',
            resource_type='abacus_schedule',
        )


@patch('abacus_schedule.blueprints.schedule.logic')
def test_update_schedule(mock_logic, fixture_client, mock_schedule_fixture):
    """Test PUT endpoint when updating a schedule."""
    schedule_id = 1234
    mock_schedule = ScheduleFactory.create(**mock_schedule_fixture)
    mock_update_body = {'schedule_name': 'new name'}

    mock_response_json = mock_schedule_fixture.copy()
    mock_response_json.update(mock_update_body)
    mock_response = response.Response(message=mock_response_json)
    mock_logic.update_schedule.return_value = mock_response

    res = fixture_client.put(f'/schedule/{schedule_id}', json=mock_update_body)

    mock_logic.update_schedule.assert_called_once_with(
        mock_schedule, **mock_update_body
    )
    assert res.status_code == 200
    assert res.json['schedule_name'] == 'new name'


@patch('abacus_schedule.blueprints.schedule.logic')
def test_create_schedule(mock_logic, fixture_client, mock_schedule_fixture):
    """Test POST endpoint when creating a schedule."""
    mock_response = response.Response(message=mock_schedule_fixture, status=201)
    mock_logic.create_schedule.return_value = mock_response

    mock_create_body = mock_schedule_fixture.copy()
    mock_create_body.pop('schedule_id')

    res = fixture_client.post('/schedule', json=mock_create_body)

    mock_logic.create_schedule.assert_called_once_with(**mock_create_body)
    assert res.status_code == 201
    assert res.json == mock_schedule_fixture