"""Product."""
import collections

from glom import glom

from switchboard_consumer.constants.release_correction import (
    FAILED_TO_FETCH_PRODUCT_INFORMATION)
from switchboard_consumer.formatters.errors import (
    format_generic_error, format_graphql_errors)
from switchboard_consumer.formatters.product import (format_result_id,
                                                     get_company_code)
from switchboard_consumer.formatters.track import (
    format_switchboard_product_tracks_for_release_corrections)
from switchboard_consumer.logic.participant.product_participant_handler \
    import ProductParticipantHandler
from switchboard_consumer.logic.participant.track_participant_handler \
    import TrackParticipantHandler
from switchboard_consumer.logic.release_correction.release_correction import (
    diff_product_artists, diff_products_for_release_correction,
    diff_track_artists, diff_track_writers,
    diff_tracks_for_release_correction, handle_release_correction_update,
    update_non_release_correctable_fields
)
from switchboard_consumer.utils.graphql import is_error
from switchboard_consumer.utils.message import create_processing_result


def create_product(
        logger, message, orchard_client, create_product_payload):
    """Create product."""
    create_product_result = orchard_client.create_product(
        create_product_payload, message.correlation_id)
    processing_results = []
    if create_product_result.get('errors'):
        errors = create_product_result.get('errors')
        logger.error('Problem inserting product. - {}'.format(errors))
        processing_results.append(create_processing_result(
            message.ids,
            message,
            errors=format_graphql_errors(errors)))
        return None, processing_results

    product_id = create_product_result['productId']
    logger.info('Product inserted into Orchard with id: {}'.format(product_id))
    original_id = message.sending_system_local_id
    result_ids = format_result_id(product_id, original_id)

    processing_results.append(create_processing_result(
        message.ids + result_ids,
        message,
    ))

    return product_id, processing_results


def update_product(logger, message, payload, orchard_client):
    """Update product when in the IN PROGRESS state."""
    result = orchard_client.update_product(payload, message.correlation_id)

    insert_id = payload['productId']
    original_id = message.sending_system_local_id
    result_ids = format_result_id(insert_id, original_id)

    if result.get('errors'):
        errors = result.get('errors')
        logger.error('Problem updating product - {}'.format(errors))

        return create_processing_result(
            [message.sending_system_local_id] + result_ids,
            message,
            errors=format_graphql_errors(errors)
        )

    logger.info('Product updated in Orchard with id: {}'.format(insert_id))

    return create_processing_result(
        [message.sending_system_local_id] + result_ids,
        message,
    )


def release_correct_product(product_id, sony_product, message,
                            swb_client, orchard_client, logger):
    """Handle updating a product via release correction"""
    results = []
    orchard_local_id = product_id
    orchard_product = orchard_client.get_product_by_id(
        orchard_local_id,
        message.correlation_id
    )
    vendor_id = get_company_code(sony_product['labelAccount'])
    subaccount_id = get_company_code(sony_product['subAccount'])
    result_ids = format_result_id(orchard_local_id,
                                  message.sending_system_local_id)
    rc_items = glom(orchard_product, 'releaseCorrection.items', default=None)

    if is_error(orchard_product):
        msg = 'Failed to get product by id from Orchard'
        logger.error(msg, custom_fields={
                     'raw_errors': orchard_product['errors'],
                     'orchard_product_id': orchard_local_id})
        results.append(create_processing_result(
            [message.sending_system_local_id] + result_ids,
            message,
            errors=[format_generic_error(FAILED_TO_FETCH_PRODUCT_INFORMATION)]
        ))
        return results

    # Build participants for product and tracks
    product_participant_handler = ProductParticipantHandler(
        logger, orchard_client, message, vendor_id, subaccount_id)
    processing_results, sony_artists = product_participant_handler.process(
        sony_product)
    results.extend(processing_results)

    track_participant_handler = TrackParticipantHandler(
        sony_product,
        logger, orchard_client, message,
        vendor_id, subaccount_id
    )
    track_processing_results, sony_tracks = \
        format_switchboard_product_tracks_for_release_corrections(
            sony_product, logger, track_participant_handler
        )
    results.extend(track_processing_results)

    product_updates = {
        **diff_products_for_release_correction(
            orchard_product, sony_product, rc_items
        ),
        **diff_product_artists(
            orchard_product['artists'],
            sony_artists),
    }

    orchard_tracks = orchard_product['tracks']

    track_simple_updates = diff_tracks_for_release_correction(
        orchard_tracks,
        sony_tracks,
        logger
    )

    track_artist_updates = diff_track_artists(
        orchard_tracks,
        sony_tracks
    )

    track_writer_updates = diff_track_writers(
        orchard_tracks,
        sony_tracks
    )

    track_updates = collections.defaultdict(list)
    dicts = [
        track_simple_updates,
        track_artist_updates,
        track_writer_updates
    ]

    for D in dicts:
        for key, value in D.items():
            track_updates[key].extend(value)

    results.append(handle_release_correction_update(
        orchard_product, sony_product,
        product_updates, track_updates,
        message, orchard_client, logger))

    errors = update_non_release_correctable_fields(
        orchard_product, sony_product, sony_tracks,
        message, orchard_client, logger
    )
    if errors:
        results.append(errors)

    return results


def unsubmit_product(logger, message, product_id, orchard_client):
    """Unsubmit product."""
    logger.info('About to unsubmit product with id: {}'.format(product_id))

    result = orchard_client.unsubmit_product(
        product_id, message.correlation_id)

    if result.get('errors'):
        errors = result.get('errors')
        logger.error('Problem unsubmitting product {}'.format(errors))
        result_ids = format_result_id(product_id,
                                      message.sending_system_local_id)
        return create_processing_result(
            [message.sending_system_local_id] + result_ids,
            message,
            errors=format_graphql_errors(errors)
        )

    logger.info('Product unsubmitted in Orchard with id: {}'.format(
        product_id))

    return {}