"""Functional tests for updating a track localization.

Endpoint: PUT /track/<int:tuid>/localization/<int:language_id>
"""

import json

from oto import response
from oto import status as response_code
import pytest

from backend.constants import error
from backend.constants import track_field as tf
from tests.testutils import constants as test_consts
from tests.testutils import db
from tests.testutils import mocks

TRACK_NAME = 'Gangsta\'s Paradise'
JSON_DATA = json.dumps({
    'track_name': TRACK_NAME,
    'version': 'Explicit',
    'artists': [{'name': 'Coolio', 'track_artist_id': 4, 'type': 'performer'}]
})
LANGUAGE_ID = 1


def _update_track_localization(
        client, mocker, client_headers, model_response, test_track):
    """Call update track localization endpoint."""
    mocker.patch(
        'backend.models.ows_product.update_track_localization',
        return_value=model_response)
    tuid = test_track[tf.TUID]
    endpoint = '/track/{}/localization/{}'.format(tuid, LANGUAGE_ID)
    return client.put(endpoint, data=JSON_DATA, headers=client_headers)


@db.test_schema
def test_update_track_localization_success(
        client, mocker, client_headers, update_track_localization_response,
        test_track):
    """Test update track localization handler is successful."""
    expected_json = update_track_localization_response.message
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_verify_product_ownership(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    result = _update_track_localization(
        client, mocker, client_headers, update_track_localization_response,
        test_track)
    response_json = json.loads(result.data.decode())
    assert result
    assert response_json == expected_json


@db.test_schema
def test_update_track_localization_success_without_grass_headers(
        client, mocker, valid_headers, update_track_localization_response,
        test_track):
    """Test update track localization handler without grass headers."""
    expected_json = update_track_localization_response.message
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    result = _update_track_localization(
        client, mocker, valid_headers, update_track_localization_response,
        test_track)
    response_json = json.loads(result.data.decode())
    assert result
    assert response_json == expected_json


@db.test_schema
def test_update_track_localization_with_invalid_grass_headers(
        client, mocker, invalid_grass_headers,
        update_track_localization_response, test_track):
    """Test update track localization handler without grass headers."""
    mocks.ows_product_get_localization_languages(mocker)
    result = _update_track_localization(
        client, mocker, invalid_grass_headers,
        update_track_localization_response, test_track)
    assert result.status_code == response_code.BAD_REQUEST


@db.test_schema
def test_update_track_localization_failed(
        client, mocker, client_headers, track_localization_failed_response,
        test_track):
    """Test update track localization handler failed."""
    mocks.ows_product_verify_product_ownership(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    result = _update_track_localization(
        client, mocker, client_headers, track_localization_failed_response,
        test_track)

    response_json = json.loads(result.data.decode())
    assert result.status_code == 500
    assert response_json['code'] == error.OWS_PRODUCT_ERROR_CODE


@db.test_schema
@pytest.mark.parametrize('track_name', test_consts.TEST_INVALID_TRACK_NAMES)
def test_update_track_localization_invalid_name(
        client, client_headers, track_name):
    """Test update track localization fails on invalid track name."""
    json_data = json.dumps({
        'track_name': track_name,
        'version': ''
    })
    result = client.put(
        '/track/1/localization/2', data=json_data, headers=client_headers)
    response_json = json.loads(result.data.decode())

    assert result.status_code == response_code.BAD_REQUEST
    assert 'track_name' in response_json['message']


def test_update_track_localization_localized_values_mismatch(
        mocker, client, client_headers, track_factory):
    """Should return error because of number of localized values mismatch.

    Number of localized artists should be equal to number of track artists.
    """
    track = track_factory.create(performer__count=2)
    localized_artists = [
        {'type': 'performer', 'name': 'localized One', 'track_artist_id': 1}]
    json_data = json.dumps({
        'track_name': 'test_track',
        'version': '',
        'artists': localized_artists})
    mocker.patch(
        'backend.logic.track_localization.TrackPersister.get_by_tuid',
        return_value=response.Response(track.to_dict()))
    mocks.ows_product_verify_product_ownership(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    expected_error = {
        'code': 'validation_error',
        'message': error.LOCALIZATION_ERROR_LOCALIZED_VALUES_MISMATCH}

    update_repsonse = client.put(
        '/track/1/localization/2', data=json_data, headers=client_headers)
    response_body = json.loads(update_repsonse.data.decode())

    assert response_body == expected_error