"""Lambda test module."""

from unittest.mock import call
from unittest.mock import patch

import pytest

from constants import general
from src import app
from src import lambda_exceptions


@patch('src.s3.head_object')
@patch('src.util.extract_triggered_key')
@patch('src.app.get_metadata')
@patch('src.app.skip_if_asset_upload_already_handled')
@patch('src.app.post_asset')
@patch('src.status.send_general_status')
def test_handler(
    send_general_status_mock,
    post_asset_mock,
    skip_if_asset_upload_already_handled_mock,
    get_metadata_mock,
    extract_triggered_key_mock,
    head_object_mock,
):
    """Test handler function."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    metadata_mock = {
        'filename': test_key,
        'bucket': test_bucket,
        'product_id': 1,
        'upc': '1112223333',
        'track_unique_id': 0,
        'is_correction': 1
    }
    extract_triggered_key_mock.return_value = (test_bucket, test_key)
    get_metadata_mock.return_value = metadata_mock
    # test function call
    result = app.handler(event_mock, None)
    # checking
    calls = [
        call(
            general.LAMBDA_NAME, general.UPLOAD_COMPLETE_STATUS, test_key,
            input_params=metadata_mock, bucket=test_bucket),
        call(
            general.LAMBDA_NAME, general.ACKNOWLEDGE_COMPLETE_STATUS, test_key,
            input_params=metadata_mock, bucket=test_bucket)]
    extract_triggered_key_mock.assert_called_once_with(event_mock)
    head_object_mock.assert_called_once_with(test_bucket, test_key)
    get_metadata_mock.assert_called_once_with(head_object_mock.return_value, test_key, test_bucket)
    skip_if_asset_upload_already_handled_mock.assert_called_once_with(metadata_mock['filename'])
    post_asset_mock.assert_called_once_with(**metadata_mock)
    send_general_status_mock.assert_has_calls(calls)
    assert result == {
        'bucket': test_bucket,
        'key': test_key,
        'acknowledge_status': 'ok',
    }


@patch('src.app.logger')
@patch('src.app.config')
@patch('src.s3.head_object')
def test_handler_transcoding_paused(head_object_mock, mock_config, mock_logger):
    """Test handler function when transcoding is paused."""
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    mock_config.PAUSE_TRANSCODING = True

    with pytest.raises(lambda_exceptions.StopProcessingException, match='stop_v2_processing'):
        app.handler(event_mock, None)
    mock_logger.critical.assert_called_once_with('Transcoding paused: test_bucket test_key')
    head_object_mock.assert_not_called()


@patch('src.s3.head_object')
@patch('src.util.extract_triggered_key')
@patch('src.app.get_metadata')
@patch('src.app.skip_if_asset_upload_already_handled')
@patch('src.app.post_asset')
@patch('src.status.send_general_status')
def test_handler_asset_upload_already_handled(
    send_general_status_mock,
    post_asset_mock,
    skip_if_asset_upload_already_handled_mock,
    get_metadata_mock,
    extract_triggered_key_mock,
    head_object_mock,
):
    """Test handler function raises AssetUploadAlreadyHandled."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    metadata_mock = {
        'filename': test_key,
        'bucket': test_bucket,
        'product_id': 1,
        'upc': '1112223333',
        'track_unique_id': 0,
        'is_correction': 1
    }
    extract_triggered_key_mock.return_value = (test_bucket, test_key)
    get_metadata_mock.return_value = metadata_mock
    skip_if_asset_upload_already_handled_mock.side_effect = lambda_exceptions.AssetUploadAlreadyHandled()

    # test function call
    result = app.handler(event_mock, None)

    # checking
    extract_triggered_key_mock.assert_called_once_with(event_mock)
    head_object_mock.assert_called_once_with(test_bucket, test_key)
    get_metadata_mock.assert_called_once_with(head_object_mock.return_value, test_key, test_bucket)
    skip_if_asset_upload_already_handled_mock.assert_called_once_with(metadata_mock['filename'])
    post_asset_mock.assert_not_called()
    send_general_status_mock.assert_not_called()
    assert result == {'acknowledge_status': 'asset_upload_already_handled'}


@patch('src.s3.head_object')
@patch('src.util.extract_triggered_key')
@patch('src.app.get_metadata')
@patch('src.app.skip_if_asset_upload_already_handled')
@patch('src.app.post_asset')
@patch('src.status.send_general_status')
def test_handler_asset_upload_asset_status_fetch_error(
    send_general_status_mock,
    post_asset_mock,
    skip_if_asset_upload_already_handled_mock,
    get_metadata_mock,
    extract_triggered_key_mock,
    head_object_mock,
):
    """Test handler function raises Exception on asset status fetch error."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    metadata_mock = {
        'filename': test_key,
        'bucket': test_bucket,
        'product_id': 1,
        'upc': '1112223333',
        'track_unique_id': 0,
        'is_correction': 1
    }
    extract_triggered_key_mock.return_value = (test_bucket, test_key)
    get_metadata_mock.return_value = metadata_mock
    skip_if_asset_upload_already_handled_mock.side_effect = Exception('Could not determine asset status.')

    # test function call
    with pytest.raises(lambda_exceptions.LoggedException, match='Could not determine asset status.'):
        app.handler(event_mock, None)

    # checking
    extract_triggered_key_mock.assert_called_once_with(event_mock)
    head_object_mock.assert_called_once_with(test_bucket, test_key)
    get_metadata_mock.assert_called_once_with(head_object_mock.return_value, test_key, test_bucket)
    skip_if_asset_upload_already_handled_mock.assert_called_once_with(metadata_mock['filename'])
    post_asset_mock.assert_not_called()
    send_general_status_mock.assert_called_once_with(
        function='acknowledge',
        status='acknowledge_error',
        filename='test_key',
        error_code='acknowledge_error',
        description='An error occurred during the acknowledge. Error message: Could not determine asset status.',
        bucket='test_bucket',
        input_params=None,
    )


@patch('src.s3.head_object')
@patch('src.util.extract_triggered_key')
@patch('src.status.ows_assets')
def test_handler_object_not_found(
        ows_assets, extract_triggered_key_mock, head_object_mock):
    """Test handler function."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    extract_triggered_key_mock.return_value = (test_bucket, test_key)
    head_object_mock.return_value = None

    with pytest.raises(Exception):
        app.handler(event_mock, None)


@patch('src.app.util.extract_triggered_key')
@patch('src.app.lambda_exceptions.notify_and_raise')
def test_handler_fail_with_exception(notify_and_raise_mock, extract_triggered_key_mock):
    """Test handler function."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'detail-type': 'Object Created',
        'detail': {
            'bucket': {
                'name': test_bucket
            },
            'object': {
                'key': test_key
            }
        }
    }
    extract_triggered_key_mock.side_effect = Exception(
        'key_error'
    )
    app.handler(event_mock, None)
    notify_and_raise_mock.assert_called_once_with(
        'acknowledge',
        'acknowledge_error',
        'acknowledge_error',
        None,
        None,
        {'message': 'key_error'}
    )