"""retrieve-orchard-metadata."""
from typing import Dict
import uuid

import config
from config import graphql_gateway
from constants.queries import (
    GET_PRODUCT_BY_UPC,
    UNSUBMIT_PRODUCT)
from ddex_ingester_common.constants.status import (
    PRODUCT_UNSUBMITTED, TRANSFER_TO_CONTENT)
from ddex_ingester_common.lambda_exceptions import (
    UnsubmitException)
from ddex_ingester_common.logging import utils as logging_utils
from ddex_ingester_common.schemas.state_machine_schema import (
    StateMachineSchema
)
from marshmallow.utils import get_value

logger = logging_utils.get_logger(config.app_logger)


def handler(event, context):
    """Lambda entry point."""
    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
    )
    graphql_gateway.set_headers(
        {
            'Orchard-User-Id': config.OA_USER,
            'Correlation-Id': correlation_id,
        }
    )
    graphql_result = get_product_metadata(context)
    status = graphql_result.get('status')

    enrich_product_id(context, graphql_result)

    if status == TRANSFER_TO_CONTENT:
        unsubmit_product(context.product.product_id)
        # We have unsubmitted this call, so need to retrieve an updated state
        graphql_result = get_product_metadata(context)

    enrich_context(context, graphql_result)

    return StateMachineSchema().dump(context)


def enrich_context(context, graphql_result):
    """Enrich context object with fields from a GraphQL product result.

    Args:
        context (object): Context object
        result (dict): GraphQL response

    """
    enrich_track_tuids(context, graphql_result)
    enrich_orchard_original_values(context, graphql_result)
    enrich_product_status(context, graphql_result)
    enrich_orchard_label(context, graphql_result)
    enrich_display_status(context, graphql_result)


def unsubmit_product(product_id: int) -> Dict:
    """Unsubmit product."""
    logger.info(
        f'Running unsubmit with product_id: {product_id}'
    )

    result = graphql_gateway.execute(
        UNSUBMIT_PRODUCT,
        {
            'productId': product_id
        }
    )['data']['unsubmitProduct']

    if result.get('result') != PRODUCT_UNSUBMITTED:
        raise UnsubmitException(
            f'Unsubmit failed for product_id: {product_id}'
        )

    return result


def get_product_metadata(context: object) -> dict:
    """Get product metadata via GraphQL.

    Args:
        context (object): Context object

    Returns:
        result (dict): GraphQL response
    """
    upc = context.product.upc
    result = graphql_gateway.execute(
        GET_PRODUCT_BY_UPC, {'upc': upc}
    )['data']['productByUpc']

    logger.info(f'Graphql result: {result}')
    return result


def enrich_product_id(context: object, result: dict):
    """Enrich context product id.

    Args:
        context (object): Context object
        result (dict): GraphQL response
    """
    product_id = result.get('productId')
    if not product_id:
        raise ValueError('Product ID not found.')

    logger.info(f'Found product id: {product_id}')
    context.product.product_id = product_id


def enrich_track_tuids(context: object, result: dict):
    """Enrich context tuids.

    Args:
        context (object): Context object
        result (dict): GraphQL response

    """
    orchard_tracks = result.get('tracks')
    for track in context.tracks:
        found_track = next(
            (
                orch_track for orch_track in orchard_tracks
                if orch_track['isrc'] == track.isrc
            ),
            None)
        if found_track:
            logger.info(
                f'Found TUID {found_track["tuid"]} for ISRC: {track.isrc}'
            )
            track.tuid = found_track['tuid']
        else:
            logger.info(
                f'No TUID found for ISRC: {track.isrc}'
            )


def enrich_orchard_original_values(context: object, result: dict):
    """Enrich original values.

    Args:
        context (object): Context object
        result (dict): GraphQL response
    """
    sale_start_date = result.get('saleStartDate')
    release_date = result.get('releaseDate')
    carveout_object = result.get('productTerritoryCarveouts', None)
    carveout_codes = None
    if carveout_object:
        carveout_codes = [d['countryCode'] for d in carveout_object]

    original_values = {
        'sale_start_date': sale_start_date,
        'carveout_country_codes': carveout_codes,
        'release_date': release_date
    }

    context.product.original_values = original_values


def enrich_product_status(context: object, result: dict):
    """Enrich product status.

    Args:
        context (object): Context object
        result (dict): GraphQL response
    """
    status = result.get('status')
    logger.info(f'Setting product status: {status}')
    context.product.status = status


def enrich_orchard_label(context: object, result: dict):
    """Enrich Orchard label.

    Args:
        context (object): Context object
        result (dict): GraphQL response
    """
    label = get_value(
        result,
        'label.name',
        None
    )
    logger.info(f'Setting orchard label: {label}')

    context.orchard_label = label


def enrich_display_status(context: object, result: dict):
    """Enrich context with display_status.

    Args:
        context (object): Context object
        result (dict): GraphQL response

    """
    display_status = result.get('displayStatus')

    logger.info(f'Found display status: {display_status}')

    context.product.display_status = display_status