"""Test for Track Persister."""

from collections import defaultdict

from oto.response import status as response_code

from backend.connectors import mysql
from backend.models.performer_persister import PerformerPersister
from backend.utils import api as api_utils
from tests.testutils import db
from tests.testutils.fixtures import performer_roles_fixture


@db.test_schema_no_seed
def test_get_performers_by_tuid(performer_factory):
    """Test get performers for a tuid."""
    test_tuid = 1
    existing_performers = [
        performer_factory(tuid=test_tuid, performer_type='primary'),
        performer_factory(tuid=test_tuid, performer_type='non-featured'),
        performer_factory(tuid=test_tuid + 1, performer_type='primary')]
    db.merge_ows_track_model_objects(existing_performers)

    result = PerformerPersister.get_performers_by_tuid(test_tuid)
    assert result
    assert result.message['pagination']['total_records'] == 2
    assert result.message['items'][0]['tuid'] == 1
    assert result.message['items'][1]['tuid'] == 1


@db.test_schema_no_seed
def test_get_performers_by_tuid_empty_result():
    """Test get performers when there are no performers for a tuid."""
    test_tuid = 1

    result = PerformerPersister.get_performers_by_tuid(test_tuid)
    assert result
    assert result.message['pagination']['total_records'] == 0


@db.test_schema_no_seed
def test_sync_track_performers_adds_performers():
    """Test adding performers for track."""
    tuid = 1
    updated_performers = [
        {
            'type': 'primary',
            'birth_name': 'Snowball',
            'performer_role_id': 1,
        },
        {
            'type': 'featured',
            'birth_name': 'Pumpkin',
            'performer_role_id': 5,
        }]

    res = PerformerPersister.sync_track_performers(tuid, updated_performers)
    assert res
    assert res.message['pagination']['total_records'] == 2

    with mysql.ows_track_db_session() as session:
        saved_performers = PerformerPersister._get_performers_by_tuid(
            tuid, session).all()
        assert len(saved_performers) == 2

        for i in (0, 1):
            assert saved_performers[i].performer_id == i + 1
            assert saved_performers[i].birth_name == \
                updated_performers[i]['birth_name']
            assert saved_performers[i].performer_role_id == \
                updated_performers[i]['performer_role_id']
            assert saved_performers[i].performer_type == \
                updated_performers[i]['type']


@db.test_schema_no_seed
def test_sync_track_performers_updates_performers(performer_factory):
    """Test updating performers for track."""
    tuid = 1
    existing_performers = [
        performer_factory(tuid=1, performer_type='primary'),
        performer_factory(tuid=1, performer_type='non-featured')]
    db.merge_ows_track_model_objects(existing_performers)

    updated_performers = [
        {
            'type': 'primary',
            'birth_name': 'Snowball',
            'performer_role_id': 1,
        },
        {
            'type': 'featured',
            'birth_name': 'Pumpkin',
            'performer_role_id': 5,
        }]

    res = PerformerPersister.sync_track_performers(tuid, updated_performers)
    assert res
    assert res.message['pagination']['total_records'] == 2
    assert res.message['items'][0]['performer_id'] == 1

    with mysql.ows_track_db_session() as session:
        saved_performers = PerformerPersister._get_performers_by_tuid(
            tuid, session).all()
        assert len(saved_performers) == 2

        for i in (0, 1):
            assert saved_performers[i].performer_id == i + 1
            assert saved_performers[i].birth_name == \
                updated_performers[i]['birth_name']
            assert saved_performers[i].performer_role_id == \
                updated_performers[i]['performer_role_id']
            assert saved_performers[i].performer_type == \
                updated_performers[i]['type']


@db.test_schema_no_seed
def test_get_performers_by_tuids(performer_factory):
    """Test get performers by a list of tuids."""
    tuids = [1, 2]
    existing_performers = [
        performer_factory(tuid=1, performer_type='primary'),
        performer_factory(tuid=1, performer_type='non-featured'),
        performer_factory(tuid=2, performer_type='non-featured')]
    db.merge_ows_track_model_objects(existing_performers)

    result = PerformerPersister.get_performers_by_tuids(tuids)
    assert result
    assert result.message['pagination']['total_records'] == 3
    assert result.message['items'][0]['tuid'] == 1
    assert result.message['items'][1]['tuid'] == 1
    assert result.message['items'][2]['tuid'] == 2


@db.test_schema_no_seed
def test_get_performers_by_tuids_empty_result():
    """Test get performers by a list of tuids with no performers."""
    tuids = [1, 2]

    result = PerformerPersister.get_performers_by_tuids(tuids)
    assert result
    assert result.message['pagination']['total_records'] == 0


@db.test_schema_no_seed
def test_sync_track_performers_delete_performers(performer_factory):
    """Test updating performers for track."""
    tuid = 1
    existing_performers = [
        performer_factory(tuid=1, performer_type='primary'),
        performer_factory(tuid=1, performer_type='non-featured')]
    db.merge_ows_track_model_objects(existing_performers)

    updated_performer = {
        'type': 'primary',
        'birth_name': 'Snowball',
        'performer_role_id': 1,
    }

    res = PerformerPersister.sync_track_performers(tuid, [updated_performer])
    assert res
    assert res.message['pagination']['total_records'] == 1
    assert res.message['items'][0]['performer_id'] == 1

    with mysql.ows_track_db_session() as session:
        saved_performers = PerformerPersister._get_performers_by_tuid(
            tuid, session).all()
        assert len(saved_performers) == 1
        performer = saved_performers[0]

        assert performer.performer_id == 1
        assert performer.birth_name == updated_performer['birth_name']
        assert performer.performer_role_id == \
            updated_performer['performer_role_id']
        assert performer.performer_type == updated_performer['type']


@db.test_schema_no_seed
def test_get_performer_roles_with_sorting(mock_app):
    """Expect to get performer ordered roles."""
    expected_roles = api_utils.create_get_list_response(
        performer_roles_fixture.expected_prioritized_performer_roles)
    performer_roles = PerformerPersister.get_performer_roles()

    assert performer_roles.message == expected_roles.message


@db.test_schema_no_seed
def test_sync_by_performer_type_for_tracks(performer_factory):
    """Test performers are synced for mulplite tracks of specific type."""
    tuids = [1, 2]
    existing_performers = [
        performer_factory(tuid=1, performer_type='primary'),
        performer_factory(tuid=2, performer_type='primary'),
        performer_factory(tuid=1, performer_type='non-featured'),
        performer_factory(tuid=2, performer_type='non-featured'),
        performer_factory(tuid=2, performer_type='featured')]
    db.merge_ows_track_model_objects(existing_performers)

    updated_performers = [
        {
            'birth_name': 'Snowball',
            'performer_role_id': 4
        },
        {
            'birth_name': 'Pumpkin',
            'performer_role_id': 15,
            'type': 'featured'
        }]

    res = PerformerPersister.sync_by_performer_type_for_tracks(
        tuids, 'featured', updated_performers)

    assert res
    assert res.message['pagination']['total_records'] == 4

    index = 0
    for performer_dict in res.message['items']:
        assert performer_dict['type'] == 'featured'
        for field in ('birth_name', 'performer_role_id'):
            assert performer_dict['performer_id']
            assert performer_dict[field] == \
                updated_performers[index % 2][field]
        index += 1

    # Verify other performers aren't deleted
    with mysql.ows_track_db_session() as session:
        saved_performers = PerformerPersister._get_performers_by_tuids(
            tuids, session).all()

        performer_tuid_type_count = defaultdict(int)
        for p in saved_performers:
            performer_tuid_type_count[(p.tuid, p.performer_type)] += 1

    assert performer_tuid_type_count == {
        (1, 'primary'): 1, (1, 'featured'): 2, (1, 'non-featured'): 1,
        (2, 'primary'): 1, (2, 'featured'): 2, (2, 'non-featured'): 1}


@db.test_schema_no_seed
def test_sync_by_performer_type_for_tracks_bad_type(
        performer_factory):
    """Test performers are synced for mulplite tracks of specific type."""
    tuids = [1, 2]

    updated_performers = [{
        'birth_name': 'Snowball',
        'type': 'primary',
        'performer_role_id': 4
    }]

    res = PerformerPersister.sync_by_performer_type_for_tracks(
        tuids, 'featured', updated_performers)

    assert not res
    assert res.errors['code'] == 'validation_error'


def test_sync_for_performer_type_no_tracks():
    """Test error returned with no tuids."""
    res = PerformerPersister.sync_by_performer_type_for_tracks(
        [], 'featured', [])

    assert not res
    assert res.errors['code'] == 'validation_error'


@db.test_schema_no_seed
def test_delete_performers_by_tuid(performer_factory):
    """Expect to delete performers by tuid."""
    performer = performer_factory.create(tuid=1, performer_type='primary')
    db.merge_ows_track_model_objects([performer])
    expected_get_response = api_utils.create_get_list_response([])

    delete_response = PerformerPersister.delete_performers_by_tuid(1)
    get_response = PerformerPersister.get_performers_by_tuids([1])

    assert delete_response.status == response_code.OK
    assert get_response.status == response_code.OK
    assert get_response.message == expected_get_response.message


@db.test_schema_no_seed
def test_bulk_delete_performers_by_tuids(performer_factory):
    """Expect to delete performers by given list of tuids."""
    all_tuids = list(range(1, 5))
    delete_tuids = [1, 2]
    performers = [
        performer_factory.create(tuid=i, performer_type='primary')
        for i in all_tuids]
    db.merge_ows_track_model_objects(performers)
    expected_get_response = api_utils.create_get_list_response(
        [p.to_dict() for p in performers if p.tuid not in delete_tuids])

    delete_response = PerformerPersister.bulk_delete_performers_by_tuids(
        delete_tuids)
    get_response = PerformerPersister.get_performers_by_tuids(all_tuids)
    assert delete_response.status == response_code.OK
    assert get_response.status == response_code.OK
    assert get_response.message == expected_get_response.message