"""Test Get a track localization from the tuids."""
import json

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_get_track_localization(client):
    """Test get_track_localization is successful for 1 tuid."""
    db.insert_itunes_languages()
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(3, tuid=1001))

    server_response = client.get('/localization/track/1001')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert 'items' in actual_result
    for track in actual_result['items']:
        assert 'track_name' in track
        assert 'version' in track
        assert 'language_id' in track
        assert track['tuid'] == 1001
        assert len(track['artists']) == 0

    # all 3 diff languages
    assert actual_result['pagination']['total_records'] == 3


@db.test_schema
def test_get_track_localization_with_artist(client):
    """Test get_track_localization with artist data."""
    db.insert_itunes_languages()
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=2))
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=1))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=2))

    server_response = client.get('/localization/track/1001')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    for track in actual_result['items']:
        assert 'track_name' in track
        assert 'version' in track
        assert 'language_id' in track
        assert track['tuid'] == 1001
        assert 'artists' in track
        assert list(track['artists'].keys()) == ['100']


@db.test_schema
def test_get_track_localization_multiple_tuids(client):
    """Test get_track_localization is successful for multiple tuids."""
    db.insert_itunes_languages()
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=2))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1002, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1002, language_id=3))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1003, language_id=1))

    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=1002))

    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=1))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=2))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=200, language_id=1))

    server_response = client.get('/localization/track/1001,1002,1003')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert 'items' in actual_result
    expected_artist_count = {1: {1001: 1, 1002: 1, 1003: 0},
                             2: {1001: 1, 1002: 0, 1003: 0},
                             3: {1001: 0, 1002: 0, 1003: 0}}
    for track in actual_result['items']:
        assert 'track_name' in track
        assert 'version' in track
        assert track['tuid'] in [1001, 1002, 1003]
        assert track['language_id'] in [1, 2, 3]
        assert len(track['artists']) == \
            expected_artist_count[track['language_id']][track['tuid']]
    # all diff languages for all 3 tracks
    assert actual_result['pagination']['total_records'] == 5


@db.test_schema
def test_get_track_localization_no_data(client):
    """Test get_track_localization for tuids with no localization data."""
    server_response = client.get('/localization/track/1001,1002,1003')
    assert server_response.status_code == 200
    actual_result = json.loads(server_response.data.decode())
    assert 'items' in actual_result
    assert actual_result['items'] == []
    assert actual_result['pagination']['total_records'] == 0


@db.test_schema
def test_get_track_localization_bad_input(client):
    """Test get_track_localization when bad data is sent for tuids."""
    server_response = client.get('/localization/track/{1001,1002,1003}')
    assert server_response.status_code == 404  # invalid URL error