"""Mocks for ows_product."""

from copy import deepcopy

from oto.response import create_error_response
from oto.response import Response

from backend.constants import error as error_consts
from tests.testutils import constants as test_consts
from tests.testutils.functions import wrap_api_results
from tests.testutils.seed.languages_seed import languages_seed_data


def ows_product_verify_product_ownership(mocker, owned_product_ids=None):
    """Mock OWS Product verify ownership response.

    If a list of owned_product_ids is passed, only those product_ids will
    return a 200 Response. An empty list can be used if no products are to
    be verified.
    """
    def _side_effect(account_type, account_id, product_id):
        if owned_product_ids is not None \
                and product_id not in owned_product_ids:
            return create_error_response(
                code=error_consts.OWS_PRODUCT_ERROR_CODE,
                message=error_consts.OWS_PRODUCT_FORBIDDEN_MESSAGE, status=400)
        else:
            return Response()

    mocker.patch(
        'backend.models.ows_product.verify_product_ownership',
        side_effect=_side_effect)


def ows_product_get_product_by_id(
        mocker, product_id, upc, product_name=test_consts.TEST_PRODUCT_NAME, vendor_id=test_consts.TEST_VENDOR_ID):
    """Mock OWS Product get_product_by_product_id."""
    response_data = {
        'product_id': product_id, 'upc': upc,
        'product_name': product_name,
        'vendor_id': vendor_id, 'status': 'in_content'}

    res = Response(message=response_data)
    mocker.patch(
        'backend.models.ows_product.get_product_by_product_id',
        return_value=res)


def ows_product_get_localization_languages(mocker):
    """Mock ows_product get_localization_languages."""
    response = Response(wrap_api_results(languages_seed_data))
    mocker.patch(
        'backend.models.ows_product.get_localization_languages',
        return_value=response)


def ows_product_get_track_localizations(mocker, response_data=[]):
    """Mock OWS Product get_track_localizations."""
    response_data = deepcopy(response_data)

    # Normalize response
    if isinstance(response_data, list):
        response_data = wrap_api_results(response_data)

    # OWS Product returns artist data as a dict of artist ids and names
    for localization in response_data['items']:
        if isinstance(localization.get('artists'), list):
            artists = {
                artist['track_artist_id']: artist['name']
                for artist in localization.get('artists')}
            localization['artists'] = artists

    mocker.patch(
        'backend.models.ows_product.get_track_localizations',
        return_value=Response(response_data))


def ows_product_update_track_localizations(mocker, response=None):
    """Mock OWS Product update_track_localizations."""
    if response is None:
        response = Response()

    mocker.patch(
        'backend.models.ows_product.update_localizations',
        return_value=response)


def ows_product_update_track_localization(mocker, response=None):
    """Mock OWS Product update_track_localizations."""
    if response is None:
        response = Response()

    mocker.patch(
        'backend.models.ows_product.update_track_localization',
        return_value=response)


def ows_product_delete_track_localization(
        mocker, tuid, language_id, error=False):
    """Mock OWS Product update_track_localization."""
    if error:
        response = create_error_response(
            error_consts.OWS_PRODUCT_ERROR_CODE, 'Server error', 500)
    else:
        response = Response({'tuid': tuid, 'language_id': language_id})

    mocker.patch(
        'backend.models.ows_product.delete_track_localization',
        return_value=response)


def ows_product_delete_localizations_for_tracks(mocker, tuids):
    """Mock OWS Product delete_track_localizations."""
    mocker.patch(
        'backend.models.ows_product.delete_track_localizations',
        return_value=Response({'tuids': tuids.copy()}))