"""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 (
    SetCarveoutsException,
    SetMainReleaseDateException,
    SetPricingException
)
from graphql import GraphQLError
from utils.set_product_deal_utils import (
    update_carveouts,
    update_pricing,
    update_product_release_date
)


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_main_release_date 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)

    # Update release / sales start dates
    modeled_release = set_main_release_date(event, modeled_release, logger)

    # Update territory careveouts
    modeled_release = set_carveouts(event, modeled_release, logger)

    # Update product pricing
    modeled_release = set_pricing(event, modeled_release, logger)

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

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

    return result


def set_main_release_date(
        event: Dict,
        model: BulkRelease,
        logger: object) -> BulkRelease:
    """Set the release date and sales start date."""
    # Log lambda begins message
    logger.info('set_main_release_date started.')

    try:
        update_product_release_date(event, model, logger)

    except GraphQLError as err:
        message = err.get_response_body().get('message')
        raise SetMainReleaseDateException(message) from err

    return model


def set_carveouts(
        event: Dict,
        model: BulkRelease,
        logger: object) -> BulkRelease:
    """Set the carveouts."""
    # Log lambda begins message
    logger.info('set_carveouts started.')

    try:
        update_carveouts(event, model, logger)

    except GraphQLError as err:
        message = err.get_response_body().get('message')
        raise SetCarveoutsException(message) from err

    return model


def set_pricing(
        event: Dict,
        model: BulkRelease,
        logger: object) -> BulkRelease:
    """Set the product pricing."""
    # Log lambda begins message
    logger.info('set_pricing started.')

    try:
        update_pricing(event, model, logger)

    except GraphQLError as err:
        message = err.get_response_body().get('message')
        raise SetPricingException(message) from err

    return model