"""Module that copies product assets."""

from oto import response

from assets.constants import asset_legacy
from assets.constants import error
from assets.logic.legacy import import_asset
from assets.logic.legacy import track
from assets.models import ows_product
from assets.models import ows_track


def _get_product_tracks(product_id):
    """Get all tracks for product.

    Args:
        product_id (int): product id.
    Returns:
        response.Response: Response with tracks data or error message.
    """
    tracks_result = ows_track.get_tracks_by_product_id(product_id)
    if not tracks_result:
        return tracks_result

    track_data = tracks_result.message['items']

    result = []
    for track_details in track_data:
        result.append({
            'track_unique_id': track_details['tuid'],
            'volume': track_details['volume_number'],
            'track': track_details['track_number']
        })

    return response.Response(message=result)


def _match_tracks(from_product_tracks, to_product_tracks):
    """Match tracks for source and dest products.

    Args:
        from_product_tracks (list): List of source product tracks.
        to_product_tracks (list): List of dest product tracks.
    Returns:
        response.Response: Response with tracks mapping or error message
    """
    if len(from_product_tracks) != len(to_product_tracks):
        error = 'Number of tracks are not equal: {from_number} <> {to_number}'
        return response.create_fatal_response(
            error.format(
                from_number=len(from_product_tracks),
                to_number=len(to_product_tracks)
            )
        )

    from_tracks = {}
    for track_data in from_product_tracks:
        key = (track_data['volume'], track_data['track'])
        from_tracks[key] = track_data['track_unique_id']

    to_tracks = {}
    for track_data in to_product_tracks:
        key = (track_data['volume'], track_data['track'])
        to_tracks[key] = track_data['track_unique_id']

    track_ids_mapping = {}

    for track_key, track_id in from_tracks.items():
        track_to_id = to_tracks.get(track_key)
        if track_to_id is None:
            return response.create_fatal_response(
                'Failed to match tracks for products.'
            )
        track_ids_mapping[track_id] = {
            'to_tuid': track_to_id,
            'volume': track_key[0],
            'number': track_key[1]
        }

    return response.Response(message=track_ids_mapping)


def copy_product_assets(from_product_id, to_product_id, full_user_id):
    """Copy product assets.

    Args:
        from_product_id (int): Source product id.
        to_product_id (int): Destination product id.
        full_user_id (str): User id.
    Returns:
        response.Response: Response with success or error message.
    """
    if not full_user_id:
        return response.create_error_response(
            code=error.ERROR_CODE_WRONG_VALUE,
            message=error.ERROR_MESSAGE_USER_ID_IS_REQUIRED)

    from_product_data_response = ows_product.get_product_by_id(
        from_product_id)
    if not from_product_data_response:
        return from_product_data_response
    from_product = from_product_data_response.message

    to_product_data_response = ows_product.get_product_by_id(to_product_id)
    if not to_product_data_response:
        return to_product_data_response
    to_product = to_product_data_response.message

    if to_product['status'] == asset_legacy.PRODUCT_STATUS_IN_CONTENT:
        return response.create_error_response(
            code=error.ERROR_CODE_WRONG_VALUE,
            message=error.ERROR_MESSAGE_PRODUCT_IN_CONTENT)

    from_tracks_response = _get_product_tracks(from_product_id)
    if not from_tracks_response:
        return from_tracks_response
    from_tracks = from_tracks_response.message

    to_tracks_response = _get_product_tracks(to_product_id)
    if not to_tracks_response:
        return to_tracks_response
    to_tracks = to_tracks_response.message

    tracks_mapping_response = _match_tracks(from_tracks, to_tracks)
    if not tracks_mapping_response:
        return tracks_mapping_response
    tracks_mapping = tracks_mapping_response.message

    asset_batch = import_asset.create_import_asset_batch(
        full_user_id, import_type=asset_legacy.IMPORT_TYPE_COPY
    )

    if _need_track_copy(from_product) and _need_track_copy(to_product):
        copy_product_tracks_response = track.copy_product_track_assets(
            tracks_mapping, from_product, to_product, full_user_id,
            asset_batch_data=asset_batch.message)
        if not copy_product_tracks_response:
            return copy_product_tracks_response
    copy_product_image_response = track.copy_product_image_asset(
        from_product.get('upc'), to_product.get('upc'), full_user_id,
        asset_batch_data=asset_batch.message)

    if not copy_product_image_response:
        return copy_product_image_response

    return response.Response({'status': error.SUCCESS_CODE})


def _need_track_copy(product):
    """Check if a product needs track asset copy operation.

    Args:
        product (dict): product information
    Returns:
        response.Response: Successful response if track copy is needed.
    """
    if product.get('context_type') == 'digital':
        return response.Response(error.SUCCESS_CODE)
    return response.create_error_response(
        error.ERROR_CODE_NO_TRACK_COPY, error.ERROR_MESSAGE_NO_TRACK_COPY)