"""Main Handler."""
from typing import Dict

from bulk_metadata_ingester_common.models.bulk_release import BulkRelease
from bulk_metadata_ingester_common.utils.jitter import jitter
from bulk_metadata_ingester_common.utils.logging import get_current_logger
from bulk_metadata_ingester_common.utils.release_utils import \
    get_release_track_list
import config
from config import graphql_gateway
from constants.exceptions import (
    CheckProductException,
    CreateProductException,
    UpdateProductException
)
from ddex_ingester_common.constants.status import IN_CONTENT
from ddex_ingester_common.utils.genre_mapping import get_orchard_genre_mapping
from lambdacommon.graphql.graphql import GraphQLError
from utils.product_utils import (
    check_for_product,
    create_product,
    update_product,
)

# Feature flag for unknown functionality
AWAL_DUPE_PRODUCT_CODE = False


def handler(event: Dict, context: object) -> Dict:
    """Lambda Entrypoint."""
    key = event.get('key')
    bucket = event.get('bucket')
    item_index = event.get('item_index')
    correlation_id = event.get('correlation_id')
    release = event.get('release', {})
    tracks = event.get('tracks', {})

    logger = get_current_logger(
        config.ENVIRONMENT,
        config.LAMBDA_NAME,
        logging_level=config.LOGGING_LEVEL,
        correlation_id=correlation_id)

    # Jitter calls - Sleep for randomness
    jitter(logger)

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

    # Log lambda begins message
    logger.info(f'set_product received: {event}')

    # Get release from JSON doc
    release_track_list = get_release_track_list(bucket, key, item_index)

    # Move JSON dict to model
    modeled_release = BulkRelease(json_release_rows=release_track_list)

    # Rehydrate context
    modeled_release.rehydrate(release, tracks)

    # Execute lambda logic
    modeled_release = set_product(event, modeled_release, logger)

    # Get all passed and updated fields
    updates = modeled_release.get_modified()

    result = {
        **event,
        'release': {
            **updates['release'],
        },
        'tracks': {
            **updates['tracks']
        }
    }

    return result


def set_product(
        event: Dict,
        release: BulkRelease,
        logger: object) -> BulkRelease:
    """Create or update a product for a release."""
    # Log lambda begins message
    logger.info(f'set_product started with Project_id {release.project_id} - '
                f'"{release.release_name}"')

    # Get the genre Id's for the release
    genre_mapping = get_orchard_genre_mapping(
        graphql_gateway,
        release.genre,
        release.subgenre
    )

    # Assign them in the model
    release.genre_id = genre_mapping['genre_id']
    release.subgenre_id = genre_mapping['subgenre_id']

    try:
        # Check if product exists
        graphql_result = check_for_product(release, logger)
    except GraphQLError as err:
        message = err.get_response_body().get('message')
        raise CheckProductException(message) from err

    if not graphql_result:
        try:
            # Create product
            product_result = create_product(event, release, logger)
            # Assign product id to model
            release.product_id = product_result.get('productId')
            if not release.upc:
                release.upc = product_result.get('upc')

        except GraphQLError as err:
            message = err.get_response_body().get('message')
            raise CreateProductException(message) from err
    else:
        try:
            # Assign product_id to release model
            release.product_id = graphql_result.get('productId')

            status = graphql_result.get('status')

            if status == IN_CONTENT:
                message = \
                    f'Could not update UPC {release.upc} - Product_id ' \
                    f'{release.product_id}. Product is `in_content`.'

                raise UpdateProductException(message)

            update_product(event, release, logger)
        except GraphQLError as err:
            message = err.get_response_body().get('message')
            raise UpdateProductException(message) from err

    return release