"""Test for track_artist_localized_metadata model."""
from product.connectors import mysql
from product.models import track_artist_localized_metadata
from tests.factories.track_artist import TrackArtistFactory
from tests.factories.track_artist_localized_metadata import \
    TrackArtistLocalizedMetadataFactory
from tests.testutils import db


@db.test_schema
def test_get_metadata_by_id():
    """Test get_metadata_by_id with valid id."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=2))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build_batch(
        3, track_artist_id=100))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build_batch(
        2, track_artist_id=200))

    with mysql.db_session() as session:
        response = track_artist_localized_metadata.get_metadata_by_id(
            [1, 2], session)
    assert response.status == 200
    assert len(response.message) == 5
    assert len(response.message.keys()) == 5  # all diff languages

    with mysql.db_session() as session:
        response = track_artist_localized_metadata.get_metadata_by_id(
            [1], session)
    assert response.status == 200
    assert len(response.message) == 3


@db.test_schema
def test_get_metadata_by_id_no_localization():
    """Test get_metadata_by_id for no localization data."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=2))
    with mysql.db_session() as session:
        response = track_artist_localized_metadata.get_metadata_by_id(
            [1, 2], session)

    assert response.status == 200
    assert len(response.message) == 0
    assert response.message == {}


@db.test_schema
def test_get_artist_ids():
    """Test get_artist_ids succeed."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=1))
    db.seed_models(TrackArtistFactory.build(track_artist_id=300, tuid=2))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=100, language_id=1))
    response = track_artist_localized_metadata.get_artist_ids([1, 2], 1)

    assert response.status == 200
    assert response.message == [100]


@db.test_schema
def test_update_metadata():
    """Test update_metadata with valid id."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200))
    data = {100: 'one name', 200: 'two name'}
    response = track_artist_localized_metadata.update_metadata(1, data)

    assert response.status == 200
    assert len(response.message) == 2


@db.test_schema
def test_update_metadata_invalid():
    """Test update_metadata with invalid data."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200))
    data = None
    response = track_artist_localized_metadata.update_metadata(1, data)

    assert response.status == 400
    assert response.errors['message'] == \
        'Invalid data sent for save track artist localization.'


@db.test_schema
def test_update_metadata_empty():
    """Test update_metadata with empty data."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200))
    data = {}
    response = track_artist_localized_metadata.update_metadata(1, data)

    assert response.status == 200
    assert response.message == {}


def setup_data_for_delete():
    """Setup sample data for delete scenarios below."""
    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=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))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=200, language_id=2))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=300, language_id=1))


@db.test_schema
def test_delete_all_metadata_without_language():
    """Test delete_all_metadata for valid ids without language filter."""
    setup_data_for_delete()
    response = track_artist_localized_metadata.delete_all_metadata(
        track_artist_ids=[100, 200])

    assert response.status == 200
    assert response.message == '4 artist localizations deleted.'


@db.test_schema
def test_delete_all_metadata_with_language():
    """Test delete_all_metadata for valid ids with language filter."""
    setup_data_for_delete()
    response = track_artist_localized_metadata.delete_all_metadata(
        track_artist_ids=[100, 200], language_id=1)

    assert response.status == 200
    assert response.message == '2 artist localizations deleted.'


@db.test_schema
def test_delete_all_metadata_no_data():
    """Test delete_all_metadata for valid ids with no localization."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100))
    response = track_artist_localized_metadata.delete_all_metadata(
        track_artist_ids=[100], language_id=1)

    assert response.status == 200
    assert response.message == '0 artist localizations deleted.'


@db.test_schema
def test_delete_all_metadata_invalid():
    """Test delete_all_metadata when no tuids passed."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100))
    response = track_artist_localized_metadata.delete_all_metadata(
        track_artist_ids=None, language_id=1)

    assert response.status == 400
    assert response.errors['message'] == \
        'No artist ids sent for delete track artist localization.'


@db.test_schema
def test_synchronize_artist_localizations():
    """Test synchronize_artist_localizations succeed.

    Check the before and after sync results. Artist_ids that are not in data
    should be deleted from after_call_response for that language.
    Other language data should remain un-affected.
    """
    setup_data_for_delete()
    data = {'100': 'new name for artist 100'}

    with mysql.db_session() as session:
        before_call_response = track_artist_localized_metadata \
            .get_metadata_by_id(
                [1001], session)
    assert 1001 in before_call_response.message[1]
    assert 100 in before_call_response.message[1][1001]
    assert 200 in before_call_response.message[1][1001]
    assert 300 in before_call_response.message[1][1001]
    assert 100 in before_call_response.message[2][1001]
    assert 200 in before_call_response.message[2][1001]

    response = \
        track_artist_localized_metadata.synchronize_artist_localizations(
            language_id=1, tuids=[1001], data=data)

    assert response.status == 200
    assert response.message == data

    with mysql.db_session() as session:
        after_call_response = track_artist_localized_metadata \
            .get_metadata_by_id(
                [1001], session)

    assert before_call_response.message[1] != after_call_response.message[1]
    assert 1001 in after_call_response.message[1]
    assert 100 in after_call_response.message[1][1001]
    assert 200 not in after_call_response.message[1][1001]  # got deleted
    assert 300 not in after_call_response.message[1][1001]  # got deleted
    # other language no change
    assert 100 in after_call_response.message[2][1001]
    assert 200 in after_call_response.message[2][1001]


def test_format_artist_results():
    """."""
    raw_data = [
        {
            'artist_name': 'Translated name 100',
            'track_artist_id': 100,
            'language_id': 1,
            'tuid': 10001
        },
        {
            'artist_name': 'Translated name 200',
            'track_artist_id': 200,
            'language_id': 1,
            'tuid': 10001
        },
        {
            'artist_name': 'Translated name 300',
            'track_artist_id': 300,
            'language_id': 1,
            'tuid': 10002
        },
        {
            'artist_name': 'Translated name 100 2',
            'track_artist_id': 100,
            'language_id': 2,
            'tuid': 10001
        },
    ]
    expected = {
        1: {
            10001: {
                100: 'Translated name 100',
                200: 'Translated name 200'
            },
            10002: {
                300: 'Translated name 300'
            }
        },
        2: {
            10001: {
                100: 'Translated name 100 2'
            }
        }
    }
    response = track_artist_localized_metadata._format_artist_results(raw_data)
    assert response.message == expected