"""Lambda function module."""

from src import buffers_utils
from src import config
from src.config import logger
from constants import general
from constants import errors
from src import images_encoding
from src import lambda_exceptions
from src import s3
from src import status


def handler(event, context):
    """Lambda entry point.

    Args:
        event (dict): Information about uploaded image.
        context (dict): Environment state.
    Returns:
        dict: Dict with transcoding results.

    """
    bucket, key = event.get('bucket'), event.get('key')
    if not s3.object_exists(bucket, key):
        message = errors.ERROR_MESSAGES[errors.S3_FILE_NOT_FOUND_CODE].format(
            key=key, bucket=bucket)
        status.send_encoding_status(
            general.ENCODING_ERROR_STATUS, key, bucket, status_details=message)
        lambda_exceptions.notify_and_raise(
            general.LAMBDA_NAME, general.ENCODING_ERROR_STATUS,
            errors.S3_FILE_NOT_FOUND_CODE, key, bucket, {
                'key': key, 'bucket': bucket})

    descriptors = images_encoding.generate_transcoding_configs(
        key, config.BASE_TRANSCODE_OUTPUT_CONFIG)
    output_files_count = len(descriptors)
    buffers = buffers_utils.allocate_buffers(output_files_count + 1)
    input_buffer = buffers[0]
    output_buffers = buffers[1:]
    try:
        status.send_encoding_status(
            general.ENCODING_PROCESSING_STATUS, key, bucket)
        s3.download_file_object(bucket, key, input_buffer)
        result_images = images_encoding.convert(
            input_buffer, descriptors, output_buffers)
        preview_images = [image for image in result_images if image['preview']]
        output_images = [
            image for image in result_images if not image['preview']]
        s3.upload_file_objects(
            output_images, config.OUTPUT_BUCKET_NAME, 'image/tiff')
        s3.upload_file_objects(
            preview_images, config.PREVIEW_OUTPUT_BUCKET_NAME, 'image/jpeg')

        result_assets = [
            {
                'key': descriptor['key'],
                'bucket': (
                    config.PREVIEW_OUTPUT_BUCKET_NAME
                    if descriptor['preview']
                    else config.OUTPUT_BUCKET_NAME),
                'asset_type': descriptor['asset_type'],
                'asset_subtype': descriptor.get('asset_subtype')
            }
            for descriptor in descriptors
        ]
        status.send_encoding_status(
            general.ENCODING_COMPLETED_STATUS, key, bucket,
            result_assets=result_assets)
        return {'status': 'OK', 'message': ''}
    except Exception as e:
        logger.exception(str(e))
        status.send_encoding_status(
            general.ENCODING_ERROR_STATUS, key, bucket,
            status_details=str(e))
        lambda_exceptions.notify_and_raise(
            general.LAMBDA_NAME, general.ENCODING_ERROR_STATUS,
            errors.IMAGE_ENCODING_ERROR_CODE, key, bucket, {
                'message': str(e)})
    finally:
        buffers_utils.release_allocated_buffers(buffers)