"""Tests for the AWS Eventbridge Scheduler Connector."""

from unittest.mock import patch

from botocore.exceptions import ClientError

from timed_release.connectors import scheduler


@patch(
    'timed_release.connectors.scheduler.boto3.client',
    return_value='scheduler_client')
def test_get_scheduler_client(mock_boto_client):
    """Test getting boto3.client."""
    scheduler_client = scheduler.get_scheduler_client()
    mock_boto_client.assert_called_with('scheduler')
    assert scheduler_client == 'scheduler_client'


@patch('timed_release.connectors.scheduler.boto3.client.get_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_get_event_schedule_found(mock_boto_client, mock_get_schedule):
    """Test boto3.client.get_schedule() found."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    value = {
        'Arn': 'string',
        'Name': f'{schedule_name}',
        'ScheduleExpression': 'at(2023-01-01T13:01:00Z)'
    }

    mock_get_schedule.return_value = value
    mock_boto_client.get_schedule = mock_get_schedule
    result = scheduler.get_event_schedule(schedule_name, scheduler_group)
    mock_get_schedule.assert_called_with(
        GroupName=scheduler_group, Name=f'{schedule_name}')
    assert result == value


@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_get_event_schedule_not_found(mock_boto_client):
    """Test boto3.client.get_schedule() not found."""
    mock_boto_client.return_value = mock_boto_client
    scheduler_group = 'test-scheduler-group'

    def get_event_schedule_side_effect(**kwargs):
        raise ClientError({
            'Error': {
                'Code': 'ResourceNotFoundException',
                'Message': 'Resource was not found'
            }
        }, 'get_schedule')

    mock_boto_client.get_schedule.side_effect = \
        get_event_schedule_side_effect
    result = scheduler.get_event_schedule(1234, scheduler_group)
    assert result is None


@patch('timed_release.connectors.scheduler.boto3.client.create_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_create_event_schedule(mock_boto_client, mock_create_schedule):
    """Test boto3.client.create_schedule() success."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}
    value = {
        'ScheduleArn': 'string'
    }

    mock_create_schedule.return_value = value
    mock_boto_client.create_schedule = mock_create_schedule
    result = scheduler.create_event_schedule(
            schedule_name, schedule_datetime, target_arn, payload,
            scheduler_group, scheduler_role_arn)
    mock_create_schedule.assert_called_once()
    assert result == value


@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_create_event_schedule_exception(mock_boto_client):
    """Test boto3.client.create_schedule() raises exception."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}

    def create_event_schedule_side_effect(**kwargs):
        raise ClientError({
            'Error': {
                'Code': 'ResourceNotFoundException',
                'Message': 'Resource was not found'
            }
        }, 'get_schedule')

    mock_boto_client.create_schedule.side_effect = \
        create_event_schedule_side_effect
    raised = False
    try:
        scheduler.create_event_schedule(
            schedule_name, schedule_datetime, target_arn, payload,
            scheduler_group, scheduler_role_arn)
    except Exception:
        raised = True
    assert raised is True


@patch('timed_release.connectors.scheduler.boto3.client.update_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_update_event_schedule(mock_boto_client, mock_update_schedule):
    """Test boto3.client.update_schedule() success."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}
    value = {
        'ScheduleArn': 'string'
    }

    mock_update_schedule.return_value = value
    mock_boto_client.update_schedule = mock_update_schedule
    result = scheduler.update_event_schedule(
        schedule_name, schedule_datetime, target_arn, payload,
        scheduler_group, scheduler_role_arn)
    mock_update_schedule.assert_called_once()
    assert result == value


@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_update_event_schedule_exception(mock_boto_client):
    """Test boto3.client.updateSchedule() raises exception."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}

    def update_event_schedule_side_effect(**kwargs):
        raise ClientError({
            'Error': {
                'Code': 'ResourceNotFoundException',
                'Message': 'Resource was not found'
            }
        }, 'get_schedule')

    mock_boto_client.update_schedule.side_effect = \
        update_event_schedule_side_effect
    raised = False
    try:
        scheduler.update_event_schedule(
            schedule_name, schedule_datetime, target_arn, payload,
            scheduler_group, scheduler_role_arn)
    except Exception:
        raised = True
    assert raised is True


@patch('timed_release.connectors.scheduler.boto3.client.get_schedule')
@patch('timed_release.connectors.scheduler.boto3.client.create_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_upsert_event_schedule_create(
        mock_boto_client, mock_create_schedule, mock_get_schedule):
    """Test boto3.client.create_schedule() is called on upsert."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}
    expected = {
        'ScheduleArn': 'string'
    }
    schedule = None

    mock_create_schedule.return_value = expected
    mock_get_schedule.return_value = schedule
    mock_boto_client.update_schedule = mock_create_schedule
    mock_boto_client.get_schedule = mock_get_schedule
    result = scheduler.upsert_event_schedule(
        schedule_name, schedule_datetime, target_arn, payload,
        scheduler_group, scheduler_role_arn)
    mock_create_schedule.assert_called_once()
    assert result == expected


@patch('timed_release.connectors.scheduler.boto3.client.get_schedule')
@patch('timed_release.connectors.scheduler.boto3.client.update_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_upsert_event_schedule_update(
        mock_boto_client, mock_update_schedule, mock_get_schedule):
    """Test boto3.client.update_schedule() is called on upsert."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    scheduler_role_arn = 'test-scheduler-role-arn'
    schedule_datetime = '2023-01-01T13:01:00Z'
    target_arn = 'an:arn:test'
    payload = {'key': 'value'}
    expected = {
        'ScheduleArn': 'string'
    }
    schedule = {
        'Arn': 'string',
        'Name': f'{schedule_name}',
        'ScheduleExpression': 'at(2023-01-01T13:01:00Z)'
    }

    mock_update_schedule.return_value = expected
    mock_get_schedule.return_value = schedule
    mock_boto_client.update_schedule = mock_update_schedule
    mock_boto_client.get_schedule = mock_get_schedule
    result = scheduler.upsert_event_schedule(
        schedule_name, schedule_datetime, target_arn, payload,
        scheduler_group, scheduler_role_arn)
    mock_update_schedule.assert_called_once()
    assert result == expected


@patch('timed_release.connectors.scheduler.boto3.client.delete_schedule')
@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_delete_event_schedule_found(mock_boto_client, mock_delete_schedule):
    """Test boto3.client.delete_schedule() success."""
    mock_boto_client.return_value = mock_boto_client
    schedule_name = 1234
    scheduler_group = 'test-scheduler-group'
    value = {}

    mock_delete_schedule.return_value = value
    mock_boto_client.get_schedule = mock_delete_schedule
    result = scheduler.delete_event_schedule(schedule_name, scheduler_group)
    mock_delete_schedule.assert_called_with(
        GroupName=scheduler_group, Name=f'{schedule_name}')
    assert result == value


@patch(
    'timed_release.connectors.scheduler.boto3.client')
def test_delete_event_schedule_exception(mock_boto_client):
    """Test boto3.client.delete_schedule() raises exception."""
    mock_boto_client.return_value = mock_boto_client
    scheduler_group = 'test-scheduler-group'

    def delete_event_schedule_side_effect(**kwargs):
        raise ClientError({
            'Error': {
                'Code': 'ResourceNotFoundException',
                'Message': 'Resource was not found'
            }
        }, 'get_schedule')

    mock_boto_client.delete_schedule.side_effect = \
        delete_event_schedule_side_effect
    result = scheduler.delete_event_schedule(1234, scheduler_group)
    assert result is None