"""Track Pricing Override logic."""

from oto import response

from pricing.constants import error
from pricing.models import ows_track
from pricing.models import track_pricing_override
from pricing.models import track_pricing_override_store
from pricing.models import track_pricing_override_territory


def get_by_track_id(track_id):
    """Get track pricing overrides by track ID.

    Args:
        track_id (int): the ID of a track.
    Returns:
        response.Response: containing the track pricing overrides.
    """
    return track_pricing_override.get_by_track_id(track_id)


def get_track_pricing_overrides_for_product(product_id):
    """Get track pricing overrides by product ID.

    Args:
        product_id (int): the ID of a product.
    Returns:
        response.Response: containing the track pricing overrides.
    """
    tracks_response = ows_track.get_tracks_by_product_id(product_id)

    if tracks_response.status != 200:
        return tracks_response

    track_ids = convert_ows_track_response(tracks_response)

    results = []

    for track_id in track_ids:
        track_override_response = get_by_track_id(track_id)

        if not track_override_response:
            return track_override_response
        results += track_override_response.message['items']

    return response.Response(
        {
            'items': results,
            'total_track_count': len(track_ids)
        })


def create_track_pricing_override(track_id, data):
    """Create a track pricing override.

    Args:
        track_id (int): the track id.
        data (dict): dict
    Returns:
         response.Response: containing the track pricing override
    """
    territories = []
    if 'territories' in data:
        territories = data['territories']
        del data['territories']

    stores = []
    if 'stores' in data:
        stores = data['stores']
        del data['stores']

    try:
        if has_duplicate(track_id, data, territories, stores):
            return response.create_error_response(
                400, error.ERROR_MESSAGE_DUPLICATE)
    except Exception:
        return response.create_error_response(
            500, error.ERROR_MESSAGE_DB_ISSUE)

    create_result = track_pricing_override.create_track_pricing_override(
        track_id, data)

    if create_result.status != 200 or \
            (len(territories) == 0 and len(stores) == 0):
        return create_result

    track_pricing_override_id = create_result.message[
        'track_pricing_override_id']

    if len(territories) > 0:
        territories_result = \
            track_pricing_override_territory.update_territories(
                track_pricing_override_id, territories)

        if territories_result.status != 200:
            return territories_result

        created_territories = territories_result.message['created']
        create_result.message['territories'] = [item['territory_code'] for item
                                                in created_territories]

    if len(stores) > 0:
        stores_result = \
            track_pricing_override_store.update_stores(
                track_pricing_override_id, stores)

        if stores_result.status != 200:
            return stores_result

        created_stores = stores_result.message['created']
        create_result.message['stores'] = [item['store_id'] for item in
                                           created_stores]

    return create_result


def bulk_create_track_pricing_override(product_id, data):
    """Create new track pricing overrides.

    Args:
        product_id (int): the product id
        data (dict): dict
    Returns:
         response.Response: containing the track pricing overrides
    """
    if 'items' not in data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    tracks_response = ows_track.get_tracks_by_product_id(product_id)

    if tracks_response.status != 200:
        return tracks_response

    track_ids = convert_ows_track_response(tracks_response)

    for item in data['items']:
        if 'track_id' not in item:
            return response.create_error_response(
                400, error.ERROR_MESSAGE_EMPTY_BODY)

        if not item['track_id'] in track_ids:
            return response.create_error_response(
                400, error.ERROR_MESSAGE_EMPTY_BODY)

    results = []
    for item in data['items']:
        create_result = create_track_pricing_override(item['track_id'], item)

        if not create_result:
            return create_result

        results.append(create_result.message)

    return response.Response({'items': results})


def bulk_update_create_track_pricing_override(product_id, data):
    """Update and create new track pricing overrides.

    Args:
        product_id (int): the product id
        data (dict): dict
    Returns:
         response.Response: containing the track pricing overrides
    """
    if 'items' not in data:
        return response.create_error_response(
            400, error.ERROR_MESSAGE_EMPTY_BODY)

    tracks_response = ows_track.get_tracks_by_product_id(product_id)

    if tracks_response.status != 200:
        return tracks_response

    track_ids = convert_ows_track_response(tracks_response)

    for item in data['items']:
        if 'track_id' not in item:
            return response.create_error_response(
                400, error.ERROR_MESSAGE_EMPTY_BODY)

        if not item['track_id'] in track_ids:
            return response.create_error_response(
                400, error.ERROR_MESSAGE_EMPTY_BODY)

    results = []
    for item in data['items']:
        if 'track_pricing_override_id' in item:
            if 'created_date' in item:
                del item['created_date']
            update_result = update_track_pricing_override(
                item['track_id'], item['track_pricing_override_id'], item)
            if not update_result:
                return update_result
            results.append(update_result.message)
        else:
            create_result = create_track_pricing_override(
                item['track_id'], item)
            if not create_result:
                return create_result
            results.append(create_result.message)

    return response.Response({'items': results})


def update_track_pricing_override(
        track_id, track_pricing_override_id, data):
    """Update a track pricing override.

    Args:
        track_id (int): the ID of a track.
        track_pricing_override_id (int): track pricing override id
        data (dict): dict
    Returns:
         response.Response: containing the updated track pricing override
    """
    if 'track_id' in data:
        del data['track_id']

    if 'created_date' in data:
        del data['created_date']

    territories = []
    if 'territories' in data:
        territories = data['territories']
        del data['territories']

    stores = []
    if 'stores' in data:
        stores = data['stores']
        del data['stores']

    update_result = track_pricing_override.update_track_pricing_override(
        track_id, track_pricing_override_id, data)

    if update_result.status != 200 or \
            (len(territories) == 0 and len(stores) == 0):
        return update_result

    if len(territories) > 0:
        territories_result = \
            track_pricing_override_territory.update_territories(
                track_pricing_override_id, territories)

        if territories_result.status != 200:
            return territories_result

        updated_territories = territories_result.message['created']
        update_result.message['territories'] = [item['territory_code'] for item
                                                in updated_territories]

    if len(stores) > 0:
        stores_result = \
            track_pricing_override_store.update_stores(
                track_pricing_override_id, stores)

        if stores_result.status != 200:
            return stores_result

        updated_stores = stores_result.message['created']
        update_result.message['stores'] = [item['store_id'] for item in
                                           updated_stores]

    return update_result


def has_duplicate(track_id, data, territories, stores):
    """Try to find an identical track pricing override in the DB.

    Args:
        track_id (int): the ID of the track.
        data (dict): the data to use to find the duplicate.
        territories ([string]): the list of territory codes to use to find the
            duplicate.
        stores ([string]): the list of store_ids to use to find the
            duplicate.

    Returns:
        boolean: True if a duplicate was found, False if not.
    """
    find_result = track_pricing_override.find_duplicate(
        track_id, data)

    if find_result.status != 200:
        raise Exception()

    if find_result.message['found'] is False:
        return False

    found = find_result.message['item']

    find_territories_result = \
        track_pricing_override_territory.get_by_track_pricing_override_id(
            found['track_pricing_override_id'])

    if find_territories_result.status != 200:
        raise Exception()

    find_stores_result = \
        track_pricing_override_store.get_by_track_pricing_override_id(
            found['track_pricing_override_id'])

    if find_stores_result.status != 200:
        raise Exception()

    found_territories = find_territories_result.message['items']
    found_territory_codes = [i['territory_code'] for i in found_territories]

    found_stores = find_stores_result.message['items']
    found_store_ids = [i['store_id'] for i in found_stores]

    if set(found_territory_codes) == set(territories) and \
            set(found_store_ids) == set(stores):
        return True
    else:
        return False


def convert_ows_track_response(response):
    """Convert an OWS Tracks response to a list of strings.

    Args:
        response (response.Response): the response to convert.

    Returns:
        [string]: a list of track ID strings.
    """
    result = [track['tuid'] for track
              in response.message['items']]
    return result