"""Test update_track_localization with tuid+language."""
import json

from tests.factories.itunes_languages import ItunesLanguagesFactory
from tests.factories.track_artist import TrackArtistFactory
from tests.factories.track_artist_localized_metadata import \
    TrackArtistLocalizedMetadataFactory
from tests.factories.track_localized_metadata import \
    TrackLocalizedMetadataFactory
from tests.testutils import db


@db.test_schema
def test_update_track_localization(client):
    """Test update_track_localization is successful for a fresh track."""
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    data = {'track_name': 'trans name', 'version': 'trans version'}
    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(data), content_type='application/json')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert actual_result['language_id'] == 12
    assert actual_result['track_name'] == data['track_name']
    assert actual_result['version'] == data['version']
    assert 'artists' not in actual_result  # artist data is not mandatory


@db.test_schema
def test_update_track_localization_with_artist(client):
    """Test update_track_localization is successful for a fresh track."""
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=300, tuid=1001))
    data = {'track_name': 'trans name', 'version': 'trans version',
            'artists': {'100': 'trans 100'}}
    expected_result = data.copy()
    expected_result['language_id'] = 12
    expected_result['tuid'] = 1001

    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(data), content_type='application/json')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert actual_result == expected_result


@db.test_schema
def test_update_track_localization_missing_mandatory(client):
    """Test update_track_localization for missing track_name or version."""
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))
    db.seed_models(
        TrackArtistFactory.build(track_artist_id=100, tuid=1001))

    server_response = client.put(
        '/localization/track/1001/language/12',
        data='{}', content_type='application/json')
    assert server_response.status_code == 400
    actual_result = json.loads(server_response.data.decode())
    assert actual_result['code'] == 'bad_request'

    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps({'track_name': 'test'}),
        content_type='application/json')
    assert server_response.status_code == 400
    actual_result = json.loads(server_response.data.decode())
    assert actual_result['code'] == 'bad_request'
    assert actual_result['message'] == \
        {'version': "\'version\' is a required property"}


@db.test_schema
def test_update_track_localization_with_empty_values(client):
    """Test update_track_localization with empty version and track_name."""
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))

    expected_result = {'track_name': '', 'version': ''}
    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(expected_result),
        content_type='application/json')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert actual_result['track_name'] == expected_result['track_name']
    assert actual_result['version'] == expected_result['version']


@db.test_schema
def test_update_track_localization_overwrite(client):
    """Test update_track_localization.

    Track 1001 has 2 artists 100,200 and 300. Track has localization for
    language 12. All 3 artists have localization for language 12.
    This test will,
    - update track's localization data for track_name and version
    - update artist 100's localization
    - delete localization for artist 200 and 300.
    """
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=12))
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=300, tuid=1001))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=12))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=200, language_id=12))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=300, language_id=12))

    data = {'track_name': 'trans name', 'version': 'trans version',
            'artists': {'100': 'trans 100'}}
    expected_result = data.copy()
    expected_result['language_id'] = 12
    expected_result['tuid'] = 1001
    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(data), content_type='application/json')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert actual_result == expected_result


@db.test_schema
def test_update_track_localization_delete_artists(client):
    """Test update_track_localization to delete all artist localization."""
    db.seed_models(ItunesLanguagesFactory.build(language_id=12))
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=12))

    data = {'track_name': 'trans name', 'version': 'trans version',
            'artists': {}}
    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(data), content_type='application/json')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert actual_result['artists'] == {}

    # make a get to double check if the artist were deleted
    server_response = client.get('/localization/track/1001')
    assert server_response.status_code == 200
    after_delete = json.loads(server_response.data.decode())
    assert after_delete['items'] == [
        {'language_id': 12, 'tuid': 1001, 'track_name': data['track_name'],
         'version': data['version'], 'artists': {}}]


@db.test_schema
def test_update_track_localization_invalid_language(client):
    """Test update_track_localization with invalid language."""
    data = {'track_name': 'trans name', 'version': 'trans version',
            'artists': {}}
    server_response = client.put(
        '/localization/track/1001/language/12',
        data=json.dumps(data), content_type='application/json')
    assert server_response.status_code == 404