"""Lambda test module."""

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

import pytest

from constants import general
from constants import errors
from src import image_validation_logic
from src import app
from src import lambda_exceptions


@pytest.fixture
def event_data():
    """Fixture for the incoming event."""
    return {
        'key': 'test_key',
        'bucket': 'test_bucket',
        'asset_upload_type': 'static_artwork'}


@pytest.fixture
def validation_error():
    """Image validation error mock."""
    return image_validation_logic.InvalidImageError(
        message='This image is seriously jacked up',
        code='red'
    )


@patch('src.s3.head_object')
@patch('src.s3.download_file_object')
@patch('src.image_validation_logic.validate_image')
@patch('src.buffers_utils.allocate_buffers')
@patch('src.buffers_utils.release_allocated_buffers')
@patch('src.status.send_general_status')
def test_handler(
    send_general_status_mock,
    release_allocated_buffers_mock,
    allocate_buffers_mock,
    validate_image_mock,
    s3_download_object_mock,
    s3_head_object_mock,
    event_data
):
    """Test handler function."""
    s3_object_mock = MagicMock()
    buffer_mock = MagicMock()
    s3_head_object_mock.return_value = s3_object_mock
    allocate_buffers_mock.return_value = [buffer_mock]
    validate_image_mock.return_value = True

    result = app.handler(event_data, None)

    s3_head_object_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    s3_download_object_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'], buffer_mock)
    validate_image_mock.assert_called_with(
        file_contents=buffer_mock
    )
    send_general_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, general.IMAGE_VALIDATION_COMPLETE_STATUS,
        event_data['key'], input_params=event_data,
        bucket=event_data['bucket'])
    release_allocated_buffers_mock.assert_called_once_with([buffer_mock])

    assert result == {
        **event_data,
        'is_valid': True,
    }


@patch('src.s3.head_object')
@patch('src.status.send_general_status')
def test_handler_object_not_found(
        send_status_mock, head_object_mock, event_data):
    """Test handler function with s3 object not found."""
    head_object_mock.return_value = None
    error_msg = errors.ERROR_MESSAGES[errors.S3_FILE_NOT_FOUND_CODE].format(
        **event_data)

    with pytest.raises(lambda_exceptions.LoggedException):
        app.handler(event_data, None)
    send_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, general.IMAGE_VALIDATION_ERROR_STATUS,
        event_data['key'], errors.S3_FILE_NOT_FOUND_CODE,
        error_msg, event_data['bucket'], event_data)


@patch('src.s3.head_object')
@patch('src.status.send_general_status')
def test_handler_with_wrong_asset_upload_type(
        send_status_mock,
        s3_head_object_mock,
        event_data):
    """Test handler function with wrong asset type."""
    asset_upload_type = 'wrong_asset_type'
    event_data['asset_upload_type'] = asset_upload_type
    s3_object_mock = MagicMock()
    s3_head_object_mock.return_value = s3_object_mock
    error_msg = errors.ERROR_MESSAGES[
        errors.IMAGE_WRONG_ASSET_UPLOAD_TYPE_ERROR_CODE].format(
            key=event_data['key'],
            bucket=event_data['bucket'],
            type=asset_upload_type)

    with pytest.raises(lambda_exceptions.LoggedException):
        app.handler(event_data, None)
    s3_head_object_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    send_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, general.IMAGE_VALIDATION_ERROR_STATUS,
        event_data['key'], errors.IMAGE_WRONG_ASSET_UPLOAD_TYPE_ERROR_CODE,
        error_msg, event_data['bucket'], event_data)


@patch('src.s3.head_object')
@patch('src.status.send_general_status')
def test_handler_failure(
        send_status_mock, s3_head_object_mock, event_data):
    """Test handler with exception."""
    exception_msg = 'error message'
    error_msg = errors.ERROR_MESSAGES[
        errors.IMAGE_VALIDATION_ERROR_CODE].format(message=exception_msg)
    s3_head_object_mock.side_effect = Exception(exception_msg)
    with pytest.raises(Exception):
        app.handler(event_data, None)
        send_status_mock.assert_called_once_with(
            general.LAMBDA_NAME, general.IMAGE_VALIDATION_ERROR_STATUS,
            event_data['key'], errors.IMAGE_VALIDATION_ERROR_CODE,
            error_msg, event_data['bucket'], event_data)


@patch('src.s3.download_file_object')
@patch('src.s3.head_object')
@patch('src.image_validation_logic.validate_image')
@patch('src.status.send_general_status')
@patch('src.buffers_utils.allocate_buffers')
def test_handler_with_failed_validation(
        allocate_buffers_mock, send_general_status_mock,
        validate_image_mock, s3_head_object_mock,
        s3_download_file_mock, event_data):
    """Test handler function with a failed image validation."""
    s3_object_mock = MagicMock()
    s3_head_object_mock.return_value = s3_object_mock

    file_buffer_mock = MagicMock()
    allocate_buffers_mock.return_value = [file_buffer_mock]

    validation_error = image_validation_logic.InvalidImageError(
        message='This image is seriously jacked up',
        code='red'
    )
    validate_image_mock.side_effect = validation_error

    result = app.handler(event_data, None)

    validate_image_mock.assert_called_once_with(
        file_contents=file_buffer_mock
    )
    send_general_status_mock.assert_called_once_with(
        function=general.LAMBDA_NAME,
        status=general.IMAGE_VALIDATION_ERROR_STATUS,
        filename=event_data.get('key'),
        error_code=validation_error.code,
        description=str(validation_error),
        input_params=event_data
    )
    assert result == {'is_valid': False}