"""Test for track_localized_metadata model."""
from oto import response as oto_response

from product.connectors import mysql
from product.models import track_artist
from product.models import track_artist_localized_metadata
from product.models import track_localized_metadata
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_tracks_localizations():
    """Test get_tracks_localizations with valid ids."""
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(2, tuid=1001))
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(3, tuid=1002))

    with mysql.db_session() as session:
        response = track_localized_metadata.get_tracks_localizations(
            [1001, 1002], session)

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


@db.test_schema
def test_get_tracks_localization_response():
    """Test get_tracks_localizations with valid ids."""
    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))

    with mysql.db_session() as session:
        response = track_localized_metadata.get_tracks_localizations(
            [1001, 1002], session)
    assert response.status == 200
    assert 1 in response.message
    assert 2 in response.message
    assert list(response.message[1].keys()) == [1001, 1002]
    assert list(response.message[2].keys()) == [1001]


@db.test_schema
def test_get_tracks_localizations_no_data():
    """Test get_tracks_localizations when no localized data found."""
    with mysql.db_session() as session:
        response = track_localized_metadata.get_tracks_localizations(
            [100], session)

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


@db.test_schema
def test_get_track_localization_by_id():
    """Test get_track_localization_by_id with single track id."""
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(2, tuid=1001))

    response = track_localized_metadata.get_track_localization_by_id(1001)
    assert response.status == 200
    assert len(response.message) == 2


@db.test_schema
def test_get_track_localization_by_id_no_data():
    """Test get_track_localization_by_id when no localized data found."""
    response = track_localized_metadata.get_track_localization_by_id(100)

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


@db.test_schema
def test_update_metadata(mocker):
    """Test update_metadata with valid id."""
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))

    data = {'track_name': 'name in afr', 'version': 'version in afr',
            'artists': {100: 'artist name'}}
    mocker.patch.object(
        track_artist_localized_metadata, 'synchronize_artist_localizations',
        return_value=oto_response.Response(message=data['artists']))
    mocker.patch.object(
        track_artist, 'validate_artists_belong_to_tuid',
        return_value=oto_response.Response(message=True))

    response = track_localized_metadata.update_metadata(
        tuid=1001, language_id=1, data=data)

    assert response.status == 200
    assert 'track_name' in response.message
    assert response.message.get('track_name') == data['track_name']
    assert response.message.get('artists') == data['artists']


@db.test_schema
def test_update_metadata_all_combinations():
    """Test update_metadata with all artist and language combinations.

    In this scenario it would update track_name and version and
    - artist 100 & language 1 => update artist name
    - artist 200 & language 1 => delete artist localization
    - artist 300 & language 1 => no change as it is in diff track
    - artist 100 & language 2 => no change as it is in diff language

    """
    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=1002))
    # with existing localizations
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=1, track_name='old name for 1001',
        version='old ver for 1001'))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1002, language_id=1, track_name='old name for 1002',
        version='old ver for 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))
    db.seed_models(TrackArtistLocalizedMetadataFactory.build(
        track_artist_id=300, language_id=1))

    data = {'track_name': 'name in afr', 'version': 'version in afr',
            'artists': {'100': 'artist name'}}
    response = track_localized_metadata.update_metadata(
        tuid=1001, language_id=1, data=data)

    assert response.status == 200
    assert 'track_name' in response.message
    assert response.message.get('track_name') == data['track_name']
    assert response.message.get('artists') == data['artists']

    with mysql.db_session() as session:
        response = track_localized_metadata.get_tracks_localizations(
            [1001, 1002], session)
    assert response.message == {
        1: {1001: {'version': 'version in afr', 'track_name': 'name in afr',
                   'language_id': 1, 'tuid': 1001},
            1002: {'version': 'old ver for 1002',
                   'track_name': 'old name for 1002', 'language_id': 1,
                   'tuid': 1002}}}

    with mysql.db_session() as session:
        response = track_artist_localized_metadata.get_metadata_by_id(
            [1001, 1002], session)
    assert list(response.message.keys()) == [1, 2]  # diff languages
    # no delete for lang 2
    assert list(response.message[2].keys()) == [1001]
    assert list(response.message[2][1001].keys()) == [100]
    # 200 gets deleted
    assert list(response.message[1].keys()) == [1001, 1002]
    assert list(response.message[1][1001].keys()) == [100]
    assert list(response.message[1][1002].keys()) == [300]


@db.test_schema
def test_update_metadata_rollback_artist(mocker):
    """Test update_metadata when artist update fails and it rollbacks.

    This updates For tuid 1001 - track_name and version successfully,
    but fails to update artist localization, so all changes are rollback and
    now
    - track 1001 : track_name and version as same as they were before call.
    - no artists are added/updated/deleted

    """
    db.seed_models(TrackArtistFactory.build(track_artist_id=100, tuid=1001))
    db.seed_models(TrackArtistFactory.build(track_artist_id=200, tuid=1001))
    # with existing localizations
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1001, language_id=1, track_name='old name for 1001',
        version='old ver for 1001'))
    db.seed_models(TrackLocalizedMetadataFactory.build(
        tuid=1002, language_id=1, track_name='old name for 1002',
        version='old ver for 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))
    mocker.patch.object(
        track_artist, 'validate_artists_belong_to_tuid',
        return_value=oto_response.create_error_response(
            'test-code', 'test error message'))

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

    data = {'track_name': 'name in afr', 'version': 'version in afr',
            'artists': {}}
    response = track_localized_metadata.update_metadata(
        tuid=1001, language_id=1, data=data)

    assert response.status == 400
    assert response.errors['message'] == 'test error message'
    with mysql.db_session() as session:
        response = track_localized_metadata.get_tracks_localizations(
            [1001], session)
    assert response.message == {
        1: {1001: {'language_id': 1, 'version': 'old ver for 1001',
                   'tuid': 1001, 'track_name': 'old name for 1001'}}}

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


@db.test_schema
def test_update_metadata_invalid(fixture_language):
    """Test update_metadata when invalid data is sent for save."""
    response = track_localized_metadata.update_metadata(
        tuid=1001, language_id=fixture_language, data={'bad': 'data'})

    assert response.status == 400
    assert response.errors['code'] == 'invalid_data'


@db.test_schema
def test_delete_track_metadata_without_language(mocker):
    """Test delete_track_metadata for valid ids without language filter."""
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(2, tuid=10))
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(3, tuid=20))
    mocker.patch.object(
        track_artist_localized_metadata, 'synchronize_artist_localizations',
        return_value=oto_response.Response(message={100: 'artist name'}))

    response = track_localized_metadata.delete_track_metadata([10, 20])

    assert response.status == 200
    assert response.message == '5 track localizations deleted.'


@db.test_schema
def test_delete_track_metadata_rollback(mocker):
    """Test delete_track_metadata for when artist delete fails."""
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(2, tuid=10))
    db.seed_models(TrackLocalizedMetadataFactory.build_batch(3, tuid=20))
    mocker.patch.object(
        track_artist_localized_metadata, 'synchronize_artist_localizations',
        return_value=oto_response.create_error_response(
            'test-code', 'test error message'))
    response = track_localized_metadata.delete_track_metadata([10, 20])

    assert response.status == 400
    assert response.errors['message'] == 'test error message'


@db.test_schema
def test_delete_track_metadata_with_language():
    """Test delete_track_metadata for valid ids with language filter."""
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=10, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=10, language_id=2))
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=20, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=20, language_id=2))
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=30, language_id=1))
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=30, language_id=2))
    response = track_localized_metadata.delete_track_metadata([10, 20], 1)

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


@db.test_schema
def test_delete_track_metadata_no_data():
    """Test delete_track_metadata for valid ids with no localization."""
    db.seed_models(TrackLocalizedMetadataFactory.build(tuid=10, language_id=1))
    response = track_localized_metadata.delete_track_metadata([10], 5)

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


@db.test_schema
def test_delete_track_metadata_invalid():
    """Test delete_track_metadata when no tuids passed."""
    response = track_localized_metadata.delete_track_metadata([], 1)

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