"""Lambda test module."""

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

import pytest

from constants import general
from src import config
from src import app


@pytest.fixture
def transcoding_configs_mock_data():
    """Correct mock data for generate_transcoding_configs."""
    return [
        {
            'size': (2000, 2000),
            'key': 'img/jpeg/test_image_2000_2000.jpeg',
            'pillow_image_save_params': {
                'format': 'JPEG',
            },
            'preview': True,
            'output_image_buffer': None,
            'asset_type': 'JPG',
            'asset_subtype': 'xlarge_cover'
        }, {
            'size': (110, 110),
            'key': 'img/jpg/test_image_110_110.jpeg',
            'pillow_image_save_params': {
                'format': 'JPEG',
            },
            'preview': True,
            'output_image_buffer': None,
            'asset_type': 'JPG',
            'asset_subtype': 'cover'
        }, {
            'size': None,
            'key': 'img/tif/test_image.tif',
            'pillow_image_save_params': {
                'format': 'TIFF',
            },
            'preview': False,
            'output_image_buffer': None,
            'asset_type': 'TIF'
        }
    ]


@pytest.fixture
def final_assets_data():
    """Correct mock data for generate_transcoding_configs."""
    return [
        {
            'key': 'img/jpeg/test_image_2000_2000.jpeg',
            'bucket': config.PREVIEW_OUTPUT_BUCKET_NAME,
            'asset_type': 'JPG',
            'asset_subtype': 'xlarge_cover'
        },
        {
            'key': 'img/jpg/test_image_110_110.jpeg',
            'bucket': config.PREVIEW_OUTPUT_BUCKET_NAME,
            'asset_type': 'JPG',
            'asset_subtype': 'cover'
        },
        {
            'key': 'img/tif/test_image.tif',
            'bucket': config.OUTPUT_BUCKET_NAME,
            'asset_type': 'TIF',
            'asset_subtype': None
        }
    ]


@patch('src.buffers_utils.allocate_buffers')
@patch('src.buffers_utils.release_allocated_buffers')
@patch('src.s3.download_file_object')
@patch('src.s3.object_exists')
@patch('src.s3.upload_file_objects')
@patch('src.images_encoding.convert')
@patch('src.images_encoding.generate_transcoding_configs')
@patch('src.status.send_encoding_status')
def test_handler_success(
        send_encoding_status_mock, generate_transcoding_configs_mock,
        convert_mock, upload_file_objects_mock, object_exists_mock,
        download_file_object_mock, release_allocated_buffers_mock,
        allocate_output_buffers_mock, transcoding_configs_mock_data,
        final_assets_data):
    """Test handler function."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key.jpg'
    event_mock = {
        'key': test_key,
        'bucket': test_bucket
    }
    output_buffers_mock = [MagicMock() for i in transcoding_configs_mock_data]
    input_buffer_mock = MagicMock()
    buffers = [input_buffer_mock, *output_buffers_mock]
    object_exists_mock.return_value = True
    allocate_output_buffers_mock.return_value = buffers
    generate_transcoding_configs_mock.return_value = (
        transcoding_configs_mock_data)
    converted_mock_objects = []
    for configure in zip(transcoding_configs_mock_data, output_buffers_mock):
        converted_object = dict.copy(configure[0])
        converted_object['output_image_buffer'] = configure[1]
        converted_mock_objects.append(converted_object)
    convert_mock.return_value = converted_mock_objects
    # test function call
    result = app.handler(event_mock, None)
    # checking
    send_encoding_status_calls = [
        call(general.ENCODING_PROCESSING_STATUS, test_key, test_bucket),
        call(general.ENCODING_COMPLETED_STATUS, test_key, test_bucket,
             result_assets=final_assets_data),
    ]
    download_file_object_mock.assert_called_once_with(
        test_bucket, test_key, input_buffer_mock)
    convert_mock.assert_called_once_with(
        input_buffer_mock, transcoding_configs_mock_data, output_buffers_mock)
    preview_mock = [item for item in converted_mock_objects if item['preview']]
    output_mock = [
        item for item in converted_mock_objects if not item['preview']]
    upload_file_objects_calls = [
        call(output_mock, config.OUTPUT_BUCKET_NAME, 'image/tiff'),
        call(preview_mock, config.PREVIEW_OUTPUT_BUCKET_NAME, 'image/jpeg')]
    upload_file_objects_mock.assert_has_calls(upload_file_objects_calls)
    send_encoding_status_mock.assert_has_calls(send_encoding_status_calls)
    output_buffers_count = len(transcoding_configs_mock_data)
    allocate_output_buffers_mock.assert_called_once_with(
        output_buffers_count + 1)
    release_allocated_buffers_mock.assert_called_once_with(buffers)
    assert result
    assert result['status'] == 'OK'
    assert result['message'] == ''


@patch('src.buffers_utils.allocate_buffers')
@patch('src.buffers_utils.release_allocated_buffers')
@patch('src.s3.download_file_object')
@patch('src.s3.object_exists')
@patch('src.images_encoding.generate_transcoding_configs')
@patch('src.status.send_encoding_status')
def test_handler_failure(
        send_encoding_status_mock, generate_transcoding_configs_mock,
        object_exists_mock, download_file_object_mock,
        release_allocated_buffers_mock, allocate_output_buffers_mock,
        transcoding_configs_mock_data):
    """Test handler function failure call."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key.jpg'
    event_mock = {
        'key': test_key,
        'bucket': test_bucket
    }
    output_buffers_mock = [MagicMock() for i in transcoding_configs_mock_data]
    input_buffer_mock = MagicMock()
    object_exists_mock.return_value = True
    buffers = [input_buffer_mock, *output_buffers_mock]
    allocate_output_buffers_mock.return_value = buffers
    release_buffers = [input_buffer_mock, *output_buffers_mock]
    generate_transcoding_configs_mock.return_value = (
        transcoding_configs_mock_data)
    download_file_object_mock.side_effect = Exception('Mock Error')
    # test function call
    with pytest.raises(Exception) as e:
        app.handler(event_mock, None)

    # checking
    send_encoding_status_calls = [
        call(general.ENCODING_PROCESSING_STATUS, test_key, test_bucket),
        call(general.ENCODING_ERROR_STATUS, test_key, test_bucket,
             status_details='Mock Error'),
    ]
    download_file_object_mock.assert_called_once_with(
        test_bucket, test_key, input_buffer_mock)
    send_encoding_status_mock.assert_has_calls(send_encoding_status_calls)
    output_buffers_count = len(transcoding_configs_mock_data)
    allocate_output_buffers_mock.assert_called_once_with(
        output_buffers_count + 1)
    release_allocated_buffers_mock.assert_called_once_with(release_buffers)
    assert e.value.args[0] == 'An error occurred during the encoding. Error message: Mock Error'


@patch('src.s3.object_exists')
def test_handler_object_not_found(object_exists_mock):
    """Test handler function."""
    # mocking
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {
        'key': test_key,
        'bucket': test_bucket,
    }
    object_exists_mock.return_value = False
    with pytest.raises(Exception):
        # test function call
        app.handler(event_mock, None)