"""Tests for performer-related logic."""

from oto import status as response_code
import pytest

from backend.logic import performer as performer_logic
from backend.models.performer_persister import PerformerPersister
from tests.testutils import mocks


def test_get_performers_for_track_is_sorted(
        mocker, track_factory, performer_factory, logic_headers):
    """Verify performer type of 'primary' is moved to the top."""
    mocks.ows_product_verify_product_ownership(mocker)

    track = track_factory()
    performers = [
        performer_factory(tuid=track.tuid, performer_type='featured'),
        performer_factory(tuid=track.tuid, performer_type='featured'),
        performer_factory(tuid=track.tuid, performer_type='primary'),
        performer_factory(tuid=track.tuid, performer_type='non-featured')
    ]

    mocks.track_persister.get_by_tuid(mocker, track)
    mocks.performer_persister.get_performers_by_tuid(mocker, performers)

    res = performer_logic.get_for_track(tuid=track.tuid, **logic_headers)
    assert res

    returned_performers = res.message['performers']
    assert returned_performers[0]['type'] == 'primary'
    assert returned_performers[1]['type'] == 'featured'
    assert returned_performers[2]['type'] == 'featured'
    assert returned_performers[3]['type'] == 'non-featured'


def test_get_performers_for_tracks_in_product(
        mocker, track_factory, performer_factory, logic_headers):
    """Expect to get performers data for tuids in given product_id."""
    mocks.ows_product_verify_product_ownership(mocker)

    tracks = [track_factory(), track_factory(), track_factory()]
    performers = [
        performer_factory(tuid=tracks[0].tuid, performer_type='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='featured'),
        performer_factory(tuid=tracks[1].tuid, performer_type='primary')
    ]
    product_id = tracks[0].product_id
    mocks.track_persister.get_all_by_product_id(mocker, tracks)
    mocks.performer_persister.get_performers_by_tuids(mocker, performers)

    res = performer_logic.get_all_for_product(
        product_id=product_id, **logic_headers)

    assert res
    assert len(res.message['items'][0]['performers']) == 1
    assert len(res.message['items'][1]['performers']) == 2
    assert len(res.message['items'][2]['performers']) == 0


def test_group_performers_by_tuid(mocker, performer_factory):
    """Test helper function for grouping performers."""
    tuids = [1, 2]
    performers = [
        performer_factory(tuid=1, performer_type='primary'),
        performer_factory(tuid=2, performer_type='featured'),
        performer_factory(tuid=2, performer_type='primary')
    ]
    mocks.performer_persister.get_performers_by_tuids(mocker, performers)
    performers = PerformerPersister.get_performers_by_tuids(tuids)

    res = performer_logic._make_get_by_product_id_response(
        tuids, performers)
    returned_performers = res.message['items']
    assert len(returned_performers) == 2
    assert len(returned_performers[0]['performers']) == 1
    assert len(returned_performers[1]['performers']) == 2

    assert returned_performers[1]['performers'][0]['type'] == 'primary'


@pytest.mark.parametrize('invalid_type', ['invalid', '', ' '])
def test_update_by_performer_type_for_product_invalid_type(
        mocker, logic_headers, invalid_type):
    """Test invalid performer type returns error response."""
    mocks.ows_product_verify_product_ownership(mocker)
    performers_data = [{
        'birth_name': 'Test performer',
        'performer_role_id': 1,
    }]

    res = performer_logic.update_by_performer_type_for_product(
        product_id=1, performer_type=invalid_type, performers=performers_data,
        **logic_headers)

    assert res.status == response_code.BAD_REQUEST
    assert res.errors == {
        'code': 'invalid',
        'message': 'Invalid performer type'
    }


@pytest.mark.parametrize('invalid_birth_name', [None, '', ' '])
def test_update_by_performer_type_for_product_invalid_birth_name(
        mocker, logic_headers, invalid_birth_name):
    """Test invalid birth_name returns error response."""
    mocks.ows_product_verify_product_ownership(mocker)
    performers_data = [{
        'birth_name': invalid_birth_name,
        'performer_role_id': 1,
    }]

    res = performer_logic.update_by_performer_type_for_product(
        product_id=1, performer_type='primary', performers=performers_data,
        **logic_headers)

    assert res.status == response_code.BAD_REQUEST
    assert res.errors == {
        'code': 'required',
        'message': 'Birth name is required'
    }


def test_get_performer_roles(mocker):
    """Expect to call persister layer."""
    mock_get_roles = mocker.patch.object(
        performer_logic.PerformerPersister, 'get_performer_roles')

    performer_logic.get_performer_roles()

    assert mock_get_roles.called