"""Functional tests for getting performers data."""

import json

from oto import status as response_code

from backend.utils import api as api_utils
from backend.constants import error
from tests.testutils import db
from tests.testutils.fixtures import performer_roles_fixture
from unittest.mock import MagicMock, patch


@db.test_schema_no_seed
def test_get_perfomer_roles(client):
    """Expect to get list of performer roles."""
    expected_res = api_utils.create_get_list_response(
        performer_roles_fixture.expected_prioritized_performer_roles)

    res = client.get('/performer/roles')
    res_data = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_data == expected_res.message


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.utils.handlers.is_jwt_identity_authorized')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_perfomer_roles_with_valid_jwt(
    mock_rule_access: MagicMock,
    mock_is_jwt_identity_authorized: MagicMock,
    mock_g: MagicMock,
    client,
    fixture_app
):
    """Expect to get list of performer roles."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = 'dummy_token'
    mock_is_jwt_identity_authorized.return_value = True
    expected_res = api_utils.create_get_list_response(
        performer_roles_fixture.expected_prioritized_performer_roles)

    res = client.get('/performer/roles')
    res_data = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_data == expected_res.message
    mock_is_jwt_identity_authorized.assert_called_once_with('dummy_token')


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.utils.handlers.is_jwt_identity_authorized')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_perfomer_roles_with_invalid_jwt(
    mock_rule_access: MagicMock,
    mock_is_jwt_identity_authorized: MagicMock,
    mock_g: MagicMock,
    client,
    fixture_app
):
    """Expect to get list of performer roles."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = 'dummy_token'
    mock_is_jwt_identity_authorized.return_value = False

    res = client.get('/performer/roles')
    res_data = json.loads(res.data.decode())

    assert res.status_code == 403
    assert res_data['code'] == error.ERROR_CODE_AUTHORIZATION
    mock_is_jwt_identity_authorized.assert_called_once_with('dummy_token')


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_perfomer_roles_with_no_jwt(
    mock_rule_access: MagicMock,
    mock_g: MagicMock,
    client,
    fixture_app
):
    """Expect to get list of performer roles."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = ''

    res = client.get('/performer/roles')
    res_data = json.loads(res.data.decode())

    assert res.status_code == 401
    assert res_data['code'] == error.ERROR_CODE_NOT_FOUND


@db.test_schema_no_seed
def test_get_performers_for_track(
        client_get_performers_for_track, track_factory, performer_factory):
    """Test get performers for a track."""
    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='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='featured')
    ]
    db.merge_model_objects(tracks)
    db.merge_ows_track_model_objects(performers)

    roles = {role['performer_role_id']: role['performer_role']
             for role in performer_roles_fixture.performer_roles}
    result = []
    for performer in performers[1:]:
        performer_dict = performer.to_dict()
        performer_dict['performer_role'] = \
            roles[performer_dict['performer_role_id']]
        result.append(performer_dict)

    track_performers = {
        'tuid': tracks[1].tuid,
        'performers': result}
    _fix_performer_response([track_performers])

    res = client_get_performers_for_track(tracks[1].tuid)
    res_data = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_data == track_performers


@db.test_schema_no_seed
def test_get_performers_for_tracks(
        client_get_performers_for_tracks, track_factory, performer_factory):
    """Test get performers for tracks."""
    tracks = [track_factory(product_id=1), track_factory(product_id=2)]
    performers = [
        performer_factory(tuid=tracks[0].tuid, performer_type='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='featured')
    ]
    db.merge_model_objects(tracks)
    db.merge_ows_track_model_objects(performers)

    tracks_performers = [
        {'tuid': track.tuid, 'performers': []} for track in tracks]
    tracks_performers[0]['performers'] = [performers[0].to_dict()]
    tracks_performers[1]['performers'] = [
        performers[1].to_dict(), performers[2].to_dict()]
    _fix_performer_response(tracks_performers)

    expected_res = api_utils.create_get_list_response(tracks_performers)

    tracks_data = {'tuids': '{},{}'.format(
        str(tracks[0].tuid), str(tracks[1].tuid))}
    res = client_get_performers_for_tracks(tracks_data)
    res_data = json.loads(res.data.decode())
    assert res.status_code == response_code.OK
    assert res_data == expected_res.message


@db.test_schema_no_seed
def test_get_performers_for_product(
        client_get_performers_for_product, track_factory, performer_factory):
    """Expect to get response with performers data for tracks in product."""
    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='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='featured')
    ]
    db.merge_model_objects(tracks)
    db.merge_ows_track_model_objects(performers)

    tracks_performers = [
        {'tuid': track.tuid, 'performers': []} for track in tracks]
    tracks_performers[0]['performers'] = [performers[0].to_dict()]
    tracks_performers[1]['performers'] = [
        performers[1].to_dict(), performers[2].to_dict()]
    _fix_performer_response(tracks_performers)

    expected_res = api_utils.create_get_list_response(tracks_performers)

    res = client_get_performers_for_product(product_id=tracks[0].product_id)
    res_data = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_data == expected_res.message


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.utils.handlers.is_jwt_identity_authorized')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_performers_for_product_with_valid_jwt(
    mock_rule_access: MagicMock,
    mock_is_jwt_identity_authorized: MagicMock,
    mock_g: MagicMock,
    client_get_performers_for_product, track_factory, performer_factory,
    fixture_app):
    """Expect to get response with performers data for tracks in product."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = 'dummy_token'
    mock_is_jwt_identity_authorized.return_value = True
    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='primary'),
        performer_factory(tuid=tracks[1].tuid, performer_type='featured')
    ]
    db.merge_model_objects(tracks)
    db.merge_ows_track_model_objects(performers)

    tracks_performers = [
        {'tuid': track.tuid, 'performers': []} for track in tracks]
    tracks_performers[0]['performers'] = [performers[0].to_dict()]
    tracks_performers[1]['performers'] = [
        performers[1].to_dict(), performers[2].to_dict()]
    _fix_performer_response(tracks_performers)

    expected_res = api_utils.create_get_list_response(tracks_performers)

    res = client_get_performers_for_product(product_id=tracks[0].product_id)
    res_data = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_data == expected_res.message


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.utils.handlers.is_jwt_identity_authorized')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_performers_for_product_with_invalid_jwt(
    mock_rule_access: MagicMock,
    mock_is_jwt_identity_authorized: MagicMock,
    mock_g: MagicMock,
    client_get_performers_for_product, track_factory, performer_factory,
    fixture_app):
    """Expect performers by product with invalid jwt."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = 'dummy_token'
    mock_is_jwt_identity_authorized.return_value = False
    tracks = [track_factory(), track_factory(), track_factory()]

    res = client_get_performers_for_product(product_id=tracks[0].product_id)

    assert res.status_code == 403
    res_data = json.loads(res.data.decode())
    assert res_data['code'] == error.ERROR_CODE_AUTHORIZATION
    mock_is_jwt_identity_authorized.assert_called_once_with('dummy_token')


@db.test_schema_no_seed
@patch('backend.handlers.performer_handlers.g')
@patch('backend.handlers.performer_handlers.flask_request.verify_rules_access_standalone')
def test_get_performers_for_product_without_jwt(
    mock_rule_access, mock_g: MagicMock,
    client_get_performers_for_product, track_factory, performer_factory,
    fixture_app):
    """Expect performers by product without jwt."""
    mock_rule_access.return_value = False
    mock_g.request_context.jwt_identity_id = ''
    tracks = [track_factory(), track_factory(), track_factory()]

    res = client_get_performers_for_product(product_id=tracks[0].product_id)

    assert res.status_code == 401
    res_data = json.loads(res.data.decode())
    assert res_data['code'] == error.ERROR_CODE_NOT_FOUND
    mock_rule_access.assert_called_once()


def _fix_performer_response(tracks_performers):
    """Make performer response dict without tuid."""
    for track_performers in tracks_performers:
        for performer in track_performers['performers']:
            del performer['tuid']