"""Test schedule logic."""

from unittest.mock import patch

from abacus_schedule.logic import schedule

from tests.utils.factories import ScheduleFactory


@patch('abacus_schedule.logic.schedule.Schedule')
def test_get_schedules_by_target(mock_schedule_model):
    """Test get schedules by target type and id logic."""
    mock_schedule = ScheduleFactory.create()
    target_type = mock_schedule.target_type
    target_id = mock_schedule.target_id
    mock_schedule_model.get_schedules_by_target.return_value = [mock_schedule]

    request_params = dict(include_only_schedules=False)
    response = schedule.get_schedules_by_target(target_type, target_id, request_params)
    mock_schedule_model.get_schedules_by_target.assert_called_once_with(
        target_type, target_id, False
    )
    assert response.status == 200
    assert response.message == [
        {
            'schedule_id': mock_schedule.schedule_id,
            'schedule_name': mock_schedule.schedule_name,
            'target_id': mock_schedule.target_id,
            'target_type': mock_schedule.target_type,
            'conditions': {},
        }
    ]


@patch('abacus_schedule.logic.schedule.Schedule')
def test_get_schedule_by_target_error(mock_schedule_model):
    """Test get sorted schedules by target with invalid target type."""
    request_params = dict(include_only_schedules=False)
    response = schedule.get_schedules_by_target('other', 1234, request_params)

    mock_schedule_model.get_schedules_by_target.assert_not_called()
    assert response.status == 400
    assert response.errors == {
        'code': 'error',
        'message': 'Invalid target type "other" for Schedules',
    }


@patch('abacus_schedule.logic.schedule.Schedule')
def test_get_schedules_with_include_only_schedules(mock_schedule_model):
    """Test get schedules by target type, id and include_only_schedules."""
    mock_schedule = ScheduleFactory.create()
    target_type = mock_schedule.target_type
    target_id = mock_schedule.target_id
    mock_schedule_model.get_schedules_by_target.return_value = [mock_schedule]

    request_params = dict(include_only_schedules='true')
    response = schedule.get_schedules_by_target(target_type, target_id, request_params)
    mock_schedule_model.get_schedules_by_target.assert_called_once_with(
        target_type, target_id, True
    )
    assert response.status == 200
    assert response.message == [
        {
            'schedule_id': mock_schedule.schedule_id,
            'schedule_name': mock_schedule.schedule_name,
            'target_id': mock_schedule.target_id,
            'target_type': mock_schedule.target_type,
            'conditions': {},
        }
    ]


@patch('abacus_schedule.logic.schedule.Schedule')
def test_update_schedule(mock_schedule_model):
    """Test update schedule."""
    mock_schedule = ScheduleFactory.create()
    update_info = {'conditions': {'auto_add': True}, 'schedule_name': 'updated name'}
    response = schedule.update_schedule(mock_schedule, **update_info)

    mock_schedule_model.commit_changes.assert_called_once()
    assert response.status == 200
    updated_schedule = response.message
    assert updated_schedule['schedule_id'] == mock_schedule.schedule_id
    assert updated_schedule['schedule_name'] == update_info['schedule_name']
    assert updated_schedule['conditions'] == update_info['conditions']


@patch('abacus_schedule.logic.schedule.Schedule')
def test_update_schedule_invalid(mock_schedule_model):
    """Test update fails if conditions are invalid."""
    existing_schedule = ScheduleFactory.create(
        conditions={'auto_add': True}, target_id='err-target'
    )
    mock_schedule = ScheduleFactory.create(target_id='err-target')

    mock_schedule_model.get_schedules_by_target.return_value = [
        mock_schedule,
        existing_schedule,
    ]
    update_info = {'conditions': {'auto_add': True}, 'schedule_name': 'updated name'}
    response = schedule.update_schedule(mock_schedule, **update_info)

    mock_schedule_model.commit_changes.assert_not_called()
    mock_schedule_model.get_schedules_by_target.assert_called_once_with(
        'contributor', mock_schedule.target_id
    )
    assert response.status == 400
    assert (
        response.errors['message']
        == 'An auto add schedule for contributor err-target already exists.'
    )


@patch('abacus_schedule.logic.schedule.Schedule')
def test_create_schedule(mock_schedule_model, mock_schedule_fixture):
    """Test create schedule."""
    mock_id = mock_schedule_fixture.pop('schedule_id')
    mock_schedule_model.create.return_value = ScheduleFactory.create(
        **mock_schedule_fixture
    )
    response = schedule.create_schedule(**mock_schedule_fixture)

    mock_schedule_model.create.assert_called_once_with(**mock_schedule_fixture)
    assert response.status == 201
    new_schedule = response.message

    assert new_schedule.pop('schedule_id') != mock_id
    assert new_schedule == mock_schedule_fixture


@patch('abacus_schedule.logic.schedule.Schedule')
def test_create_schedule_invalid(mock_schedule_model):
    """Test create schedule fails if conditions are invalid."""
    existing_schedule = ScheduleFactory.create(
        conditions={'auto_add': True}, target_id='err-target'
    )
    mock_schedule_model.get_schedules_by_target.return_value = [existing_schedule]

    new_schedule_params = {
        'schedule_name': 'new schedule',
        'target_type': 'contributor',
        'target_id': 'err-target',
        'conditions': {'auto_add': True},
    }
    response = schedule.create_schedule(**new_schedule_params)

    mock_schedule_model.get_schedules_by_target.assert_called_once_with(
        new_schedule_params['target_type'], new_schedule_params['target_id']
    )
    mock_schedule_model.create.assert_not_called()
    assert response.status == 400
    assert (
        response.errors['message']
        == 'An auto add schedule for contributor err-target already exists.'
    )