"""Bulk product update logic."""
import copy

from oto import response

from pricing.constants import error
from pricing.logic import legacy_product_mapping
from pricing.logic import product
from pricing.logic import product_orchard_pricing_tier
from pricing.logic import product_pricing_override


def bulk_update_products(data):  # noqa: C901
    """Bulk update products pricing.

    Args:
        data (dict): the data from which to create/update pricing.

    Returns:
        response.Response: containing the created pricing tiers/overrides.
    """
    if 'upcs' not in data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    if 'payload' not in data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    upcs = data['upcs']
    products = product.get_product_ids_from_upcs(upcs)

    if not products:
        return products

    product_ids = [product['product_id']
                   for product in products.message['items']]
    product_upcs = [str(product['upc'])
                    for product in products.message['items']]

    invalid_upcs = []
    if len(product_upcs) != len(upcs):
        for upc in upcs:
            if upc not in product_upcs:
                invalid_upcs.append(int(upc))

    overrides_to_create = []
    if 'product_pricing_overrides' in data['payload']:
        overrides_to_create = data[
            'payload']['product_pricing_overrides']

    default_pricing = None
    if 'default_pricing' in data['payload']:
        default_pricing = data['payload']['default_pricing']

    if len(product_ids) == 0:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    if not default_pricing and len(overrides_to_create) == 0:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    successes = []
    failures = []

    for product_id in product_ids:
        legacy_product_mapping.jit_music_migration(product_id)

        if default_pricing:
            if len(invalid_upcs) > 0:
                for invalid_upc in invalid_upcs:
                    failures.append({
                        'upc': invalid_upc,
                        'default_tier': 'Invalid UPC'
                    })

            default_pricing_to_apply = copy.deepcopy(default_pricing)
            tier_result = product_orchard_pricing_tier.\
                update_product_with_orchard_pricing_tier(
                    product_id, default_pricing_to_apply['pricing_family_id'],
                    default_pricing_to_apply)

            if tier_result:
                successes.append({
                    'upc': get_upc_from_products(product_id,
                                                 products.message['items']),
                    'default_tier': tier_result.message
                })
            else:
                failures.append({
                    'upc': get_upc_from_products(product_id,
                                                 products.message['items']),
                    'default_tier': tier_result.errors
                })

        if len(overrides_to_create) > 0:
            if len(invalid_upcs) > 0:
                for invalid_upc in invalid_upcs:
                    failures.append({
                        'upc': invalid_upc,
                        'override': 'Invalid UPC'
                    })

            found_overrides = product_pricing_override.\
                get_by_product_id(product_id)

            if found_overrides.message and \
                    len(found_overrides.message['items']) > 0:
                pricing_family_id = \
                    overrides_to_create[0]['pricing_family_id']

                overrides_without_sort_order = []
                overrides_with_sort_order = []

                for found_override in found_overrides.message['items']:
                    if not found_override['sort_order']:
                        overrides_without_sort_order.append(found_override)
                    else:
                        overrides_with_sort_order.append(found_override)

                max_sort_order = 0

                for found_override in overrides_with_sort_order:
                    if found_override['pricing_family_id'] == \
                            pricing_family_id:

                        if found_override['sort_order'] > max_sort_order:
                            max_sort_order = found_override[
                                'sort_order']

                        found_override['sort_order'] += \
                            len(overrides_to_create)

                        product_pricing_override.\
                            update_product_pricing_override(
                                found_override['product_id'],
                                found_override['product_pricing_override_id'],
                                {'pricing_family_id': found_override[
                                    'pricing_family_id'],
                                 'sort_order': found_override['sort_order']})

                max_sort_order += (len(overrides_to_create) + 1)

                if len(overrides_without_sort_order) > 0:
                    for override_without_sort_order in \
                            overrides_without_sort_order:
                        if override_without_sort_order['pricing_family_id'] \
                                == pricing_family_id:

                            override_without_sort_order['sort_order'] = \
                                max_sort_order

                            max_sort_order += 1

                            data = {
                                'sort_order': override_without_sort_order[
                                    'sort_order']
                            }
                            product_pricing_override.\
                                update_product_pricing_override(
                                    override_without_sort_order['product_id'],
                                    override_without_sort_order[
                                        'product_pricing_override_id'],
                                    data)

            for override in overrides_to_create:
                override_to_create = copy.deepcopy(override)
                override_result = product_pricing_override.\
                    create_product_pricing_override(
                        product_id, override_to_create)

                if override_result:
                    successes.append({
                        'upc': get_upc_from_products(
                            product_id,
                            products.message['items']),
                        'override': override_result.message
                    })
                else:
                    if override_result.errors['message'] != 'Duplicate Entry':
                        failures.append({
                            'upc': get_upc_from_products(
                                product_id,
                                products.message['items']),
                            'override': override_result.errors
                        })

    return response.Response({
        'successes': successes,
        'failures': failures
    })


def get_upc_from_products(product_id, products):
    """Get upc from a list of products regarding a product ID.

    Args:
        product_id (int): the product_id to search from.
        products (dict): the products to search from.

    Returns:
        response.Response: containing the upc.
    """
    found_upc = None
    for p in products:
        if p['product_id'] == product_id:
            found_upc = p['upc']

    return found_upc