"""Functional tests for updating a role for all tracks in product.

Test endpoint:
    PATCH /product/<product_id>/tracks/<role_type>
"""

import json

from oto import status as response_code

from backend.constants import track_field as tf
from tests.testutils import db
from tests.testutils import mocks
from tests.testutils.functions import make_localization_dict
from tests.testutils.functions import validate_artists_persister_response
from tests.testutils.functions import wrap_api_results


@db.test_schema
def test_update_role_for_all_tracks_in_product(
        client_patch_product_tracks_roles, client_get_product_tracks,
        product_role_apply_to_all_data, product_role_apply_to_all_role_type,
        test_product_id, test_product_tracks_response):
    """Test PATCH product's track role is successful."""
    res = client_patch_product_tracks_roles(
        product_id=test_product_id,
        role_type=product_role_apply_to_all_role_type,
        data=product_role_apply_to_all_data)
    res_json = json.loads(res.data.decode())

    assert res.status_code == response_code.OK

    validate_artists_persister_response(
        before_apply_response=test_product_tracks_response,
        names_list=product_role_apply_to_all_data['names'],
        deltas_list=res_json['items'],
        role_type=product_role_apply_to_all_role_type)


@db.test_schema_no_seed
def test_update_for_all_tracks_in_product_with_localization(
        mocker, logic_headers, client_patch_product_tracks_roles,
        track_factory, track_role_localization_data):
    """Verify artist localizations are applied."""
    db.merge_model_objects([
        track_factory.create(product_id=1),
        track_factory.create(product_id=1, performer__count=1),
        track_factory.create(product_id=1, performer__count=2)])

    data = track_role_localization_data
    names = data['names']
    loc_names = data[tf.LOCALIZATIONS][0]['names']

    expected_artist_locs = {
        4: {
            'tuid': 1, 'track_artist_id': 4,
            'type': 'performer', 'name': loc_names[0]},
        5: {
            'tuid': 1, 'track_artist_id': 5,
            'type': 'performer', 'name': loc_names[1]},
        1: {
            'tuid': 2, 'track_artist_id': 1,
            'type': 'performer', 'name': loc_names[0]},
        6: {
            'tuid': 2, 'track_artist_id': 6,
            'type': 'performer', 'name': loc_names[1]},
        2: {
            'tuid': 3, 'track_artist_id': 2,
            'type': 'performer', 'name': loc_names[0]},
        3: {
            'tuid': 3, 'track_artist_id': 3,
            'type': 'performer', 'name': loc_names[1]}
    }

    localization_dict = make_localization_dict(tuid=3, language_id=2)
    localization_dict[tf.ARTISTS] = {
        2: 'Old Artist Name 1'
    }
    ows_product_response_data = [localization_dict]

    # Mock OWS Product
    mocks.head_response(mocker)
    mocks.put_response(mocker)
    mocks.ows_product_get_track_localizations(
        mocker, wrap_api_results(ows_product_response_data))
    mocks.ows_product_get_localization_languages(mocker)

    res = client_patch_product_tracks_roles(
        product_id=1,
        role_type='performer',
        data=data)

    assert res.status_code == response_code.OK
    res_json = json.loads(res.data.decode())

    # Validates dictionary
    for track_delta in res_json['items']:
        artists = track_delta[tf.ARTISTS]
        assert len(track_delta[tf.LOCALIZATIONS]) == 1
        localization = track_delta[tf.LOCALIZATIONS][0]
        assert localization[tf.LANGUAGE_ID] == 2
        loc_artists = localization[tf.ARTISTS]
        assert len(artists) == 2
        assert artists[0][tf.NAME] == names[0]
        assert artists[1][tf.NAME] == names[1]

        for artist in loc_artists:
            expected_artist = expected_artist_locs[artist[tf.TRACK_ARTIST_ID]]
            assert track_delta[tf.TUID] == expected_artist[tf.TUID]
            assert artist[tf.TRACK_ARTIST_ID] == \
                expected_artist[tf.TRACK_ARTIST_ID]
            assert artist[tf.NAME] == \
                expected_artist[tf.NAME]