"""set-marketing-blurb."""
import uuid

from ddex_ingester_common.constants.ddex_providers import SME
from ddex_ingester_common.helpers.s3_ddex import load_ddex_json
from ddex_ingester_common.lambda_exceptions import MarketingBlurbException
from ddex_ingester_common.logging import utils as logging_utils
from ddex_ingester_common.schemas.s3_schema import S3Schema
from ddex_ingester_common.schemas.state_machine_schema import \
    StateMachineSchema
from lambdacommon.graphql import graphql

import config
from constants import queries

logger = logging_utils.get_logger(config.app_logger)


def handler(event, context):
    """Lambda entry point."""
    parsed_ddex = S3Schema().load(load_ddex_json(event))

    if not parsed_ddex.product.marketing_blurb:
        return event

    context = StateMachineSchema().load(event)
    correlation_id = context.correlation_id or str(uuid.uuid4())
    context.correlation_id = correlation_id
    logging_utils.update_logger_correlation_id(logger, correlation_id)
    logging_utils.update_logger_with_message_ids(
        logger,
        context.message_id,
        context.message_thread_id,
        context.execution_name
    )
    logger.info(f'Received productId: {context.product.product_id}')

    try:
        graphql_conn = graphql.GraphQLConnector(
            config.GRAPHQL_GATEWAY_URL, config.APPLICATION_NAME)
        graphql_conn.set_headers(
            {
                'Orchard-User-Id': config.OA_USER,
                'Correlation-Id': correlation_id,
            }
        )

        product = get_product_marketing_blurb(
            context.product.product_id, graphql_conn)

        # look for marketing blurb with SME subject
        # update if found, create it otherwise
        found_program = 0
        if product and product.get('marketingProgramInfos'):
            for program in product.get('marketingProgramInfos'):
                if program.get('subject') == SME:
                    found_program = program.get('marketingProgramInfoId')
                    break

        payload = {
            'subject': SME,
            'client': config.MARKETING_PROGRAM_INFO_OA_CLIENT,
            'description': parsed_ddex.product.marketing_blurb,
            'marketingProgram': config.MARKETING_BLURB_PROGRAM_ID,
            'entityId': context.product.product_id,
            'entityType': config.MARKETING_PROGRAM_INFO_ENTITY_TYPE,
        }

        if found_program > 0:
            update_product_marketing_blurb(
                found_program, payload, graphql_conn)
        else:
            create_product_marketing_blurb(payload, graphql_conn)
    except graphql.GraphQLError as err:
        raise MarketingBlurbException('Graphql error') from err
    except Exception as exp:
        raise Exception(f'Error processing marketing blurb.\n{exp}') from exp

    return StateMachineSchema().dump(context)


def create_product_marketing_blurb(payload, graphql_conn):
    """Create product marketing blurb."""
    graphql_conn.execute(
        queries.create_product_marketing_blurb,
        {'data': {'data': [payload]}}
    )


def update_product_marketing_blurb(
        marketing_program_info_id, payload, graphql_conn):
    """Update product marketing blurb."""
    graphql_conn.execute(
        queries.update_product_marketing_blurb,
        {
            'marketingProgramInfoId': marketing_program_info_id,
            'data': payload,
        }
    )


def get_product_marketing_blurb(product_id, graphql_conn):
    """Get product marketing blurb."""
    return graphql_conn.execute(
        queries.get_product_marketing_blurb,
        {
            'productId': product_id,
            'programId': config.MARKETING_BLURB_PROGRAM_ID
        }
    )['data']['getProductMarketingProgramInfoByProgram']