"""Lambda function module."""
from random import random
from time import sleep

from common.graphql.asset_queries import get_asset_status_v2_query
from common.helpers.asset import valid_artwork
from common.helpers.bulk_asset import load_bulk_asset_json
from common.helpers.catalog_ingestion import log_catalog_action
from common.lambda_exceptions import ArtworkException
from common.lambda_exceptions import ArtworkFatalException

import config
from config import graphql_gateway

from constants import jitter as jitter_const
from constants.asset import VALIDATION_ERROR


def handler(event, asset):
    """Lambda entrypoint."""
    correlation_id = event['correlation_id']

    logger = config.get_current_logger(correlation_id)

    logger.info(f'poll_art_status received: {event}')

    # Jitter calls
    jitter(correlation_id)

    asset = load_bulk_asset_json(event)

    graphql_gateway.set_headers(
        {
            'Orchard-User-Id': config.OA_USER,
            'Correlation-Id': correlation_id
        }
    )

    require_v1 = False

    try:
        # Call ows assets for status of uploaded track asset
        check_artwork_valid(
            require_v1,
            str(asset.product.product_id),
            asset.product.artwork.ows_assets_filename,
            asset.correlation_id
        )
    except ArtworkFatalException as e:
        msg = f'Fatal Validation error for ' \
              f'Product ID {asset.product.product_id}, ' \
              f'UPC: {asset.product.upc}: {str(e)}'
        logger.error(msg)
        raise e

    # Log success condition
    success_msg = f'Artwork for Product ID {asset.product.product_id}, ' \
                  f'UPC {asset.product.upc} ' \
                  f'transferred successfully.'
    logger.info(success_msg)  # No error - Write success json

    log_catalog_action(
        config.SNOWFLAKE_S3_BUCKET,
        config.SNOWFLAKE_S3_LOCATION,
        asset,
        'insert',
        'artwork',
        'Success',
        success_msg
    )

    lambda_result = {
        'product_id': asset.product.product_id,
        'upc': asset.product.upc,
        'msg': success_msg,
        'execution_name': asset.execution_name,
        'state_machine_name': asset.state_machine_name,
        'correlation_id': asset.correlation_id
    }

    return lambda_result


def check_artwork_valid(require_v1: bool, product_id: str, filename: str,
                        correlation_id: str = None):
    """Get artwork asset status from ows-assets."""
    if not valid_artwork(graphql_gateway, product_id, require_v1):
        logger = config.get_current_logger(correlation_id)
        logger.info('Artwork asset is not valid')

        result = graphql_gateway.execute(
            get_asset_status_v2_query,
            {'filename': filename}
        )['data']['assetStatus']

        status = result.get('status') if result else None

        if status == VALIDATION_ERROR:
            raise ArtworkFatalException(
                'Artwork asset failed validation'
            )

        raise ArtworkException(
            'Artwork asset is not valid'
        )


def jitter(correlation_id):
    """Jitter lambda calls so the systems don't get hammered."""
    logger = config.get_current_logger(correlation_id)

    if config.ENVIRONMENT.upper() == 'PROD':
        jitter_amt = (random() + random()) / jitter_const.PROD_FACTOR
    else:
        jitter_amt = (random() + random()) / jitter_const.QA_FACTOR

    logger.info(f'Jittering: {jitter_amt}')

    sleep(jitter_amt)