"""Lambda function module."""
import config
from src import images_encoding
from src.common import buffers_utils
from src.common import lambda_exceptions
from src.common import s3
from src.common import status
from src.common import util
from src.common.constants import encoding_statuses
from src.common.constants import errors


def _log_error(errs, key, bucket):
    status.send_encoding_status(
        status_name=encoding_statuses.ERROR,
        key=key,
        bucket=bucket,
        errors=errs
    )


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

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

    """
    try:
        buffers = None
        bucket, key, asset_config, file_type = util.extract_event(event)

        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:]

        status.send_encoding_status(
            status_name=encoding_statuses.PROCESSING,
            key=key,
            bucket=bucket
        )

        input_buffer = s3.download_file_object(bucket, key, input_buffer)
        buffers[0] = 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, asset_config.get(config.OUTPUT_BUCKET_NAME), 'image/tiff')
        s3.upload_file_objects(preview_images, asset_config.get(config.PREVIEW_BUCKET_NAME), 'image/jpeg')

        result_assets = [
            {
                'key': descriptor['key'],
                'asset_type': descriptor['asset_type'],
                'asset_subtype': descriptor.get('asset_subtype')
            }
            for descriptor in descriptors
        ]

        status.send_encoding_status(
            status_name=encoding_statuses.ENCODING_COMPLETED,
            key=key,
            bucket=bucket,
            final_assets=result_assets)
        return {'status': 'OK', 'message': 'image encoding successful'}

    except lambda_exceptions.LambdaStatusError as error:
        config.logger.exception(str(error))
        # if this is a malformed event but we have the key, we can send the error to the microserivce.
        # if the key is missing, then we cant post the status
        if 'key' in event:
            _log_error(error.errors, event.get('key'), event.get('bucket', None))
        raise

    except lambda_exceptions.LambdaError as error:
        config.logger.exception(str(error))
        raise

    except Exception as error:
        config.logger.exception(str(error))
        e = dict()
        msg = errors.ERROR_MESSAGES.get(errors.IMAGE_ENCODING_ERROR_CODE).format(message=str(error))
        e[errors.IMAGE_ENCODING_ERROR_CODE] = msg
        _log_error(e, key, bucket)
        raise

    finally:
        if buffers:
            buffers_utils.release_allocated_buffers(buffers)