"""Service handler tests."""

import json

import pytest
from owsresponse import response
from participant.constants import error
from participant.handlers import service as service_handlers  # noqa


@pytest.fixture
def service_artist_search_mock(mocker):
    """Artist search in services mock."""
    return {
        'spotify': mocker.patch(
            'participant.logic.service.spotify.artist_search',
            return_value=response.Response({'spotify': 'response'}),
        ),
        'apple-music': mocker.patch(
            'participant.logic.service.apple_music.artist_search',
            return_value=response.Response({'apple_music': 'response'}),
        ),
    }


@pytest.fixture
def service_get_artist_by_id_mock(mocker):
    """Artist by ID in services mock."""
    return {
        'spotify': mocker.patch(
            'participant.logic.service.spotify.get_artist_by_id',
            return_value=response.Response({'spotify': 'response'}),
        ),
        'apple-music': mocker.patch(
            'participant.logic.service.apple_music.get_artist_by_id',
            return_value=response.Response({'apple_music': 'response'}),
        ),
    }


@pytest.fixture
def service_get_artists_by_ids_mock(mocker):
    """Artists by IDs in services mock."""
    return {
        'spotify': mocker.patch(
            'participant.logic.service.spotify.get_artists_by_ids',
            return_value=response.Response({'spotify': 'response'}),
        ),
    }


@pytest.mark.parametrize(
    'service',
    ['apple-music'],
)
def test_participant_search(test_client, service_artist_search_mock, service):
    """Test participant search success."""
    query, limit, offset, localization = 'Danger Mouse', 10, 0, 'en'

    handler_response = test_client.get(
        f'/service/{service}/search?query={query}&limit={limit}'
        f'&offset={offset}&localization={localization}'
    )
    service_mock = service_artist_search_mock[service]

    result = json.loads(handler_response.data.decode())

    service_mock.assert_called_with(
        query=query, limit=limit, offset=offset, localization='en'
    )
    assert handler_response.status_code == 200
    assert result == service_mock.return_value.message


def test_participant_search_not_implemented_service(test_client):
    """Test participant search success."""
    query = 'Danger Mouse'

    handler_response = test_client.get(f'/service/notimplemented/search?query={query}')

    result = json.loads(handler_response.data.decode())

    assert handler_response.status_code == 400
    assert result['code'] == error.ERROR_CODE_INVALID_USAGE
    assert result['message'] == error.ERROR_MESSAGE_INVALID_USAGE


@pytest.mark.parametrize(
    'service',
    ['spotify', 'apple-music'],
)
@pytest.mark.parametrize(
    'params',
    [
        '?query=test&limit=10&offset=0',
        '?query=test&limit=10',
        '?query=test&offset=0',
        '?query=test',
    ],
)
def test_participant_search_acceptable_params(
    test_client, service_artist_search_mock, params, service
):
    """Test participant search success."""
    handler_response = test_client.get(f'/service/{service}/search{params}')
    assert handler_response.status_code == 200


@pytest.mark.parametrize(
    'service',
    ['spotify', 'apple-music'],
)
@pytest.mark.parametrize('params', ['?limit=10&offset=0', '?limit=10', '?offset=0', ''])
def test_participant_search_invalid_params(test_client, service, params):
    """Test participant search with invalid params."""
    handler_response = test_client.get(f'/service/{service}/search{params}')

    result = json.loads(handler_response.data.decode())

    assert handler_response.status_code == 400
    assert result['code'] == error.ERROR_CODE_INVALID_USAGE


@pytest.mark.parametrize(
    'service',
    ['spotify', 'apple-music'],
)
def test_participant_artist(test_client, service_get_artist_by_id_mock, service):
    """Test participant artist success."""
    artist_id = 'ARTIST_ID'

    handler_response = test_client.get(f'/service/{service}/artist/{artist_id}')
    service_mock = service_get_artist_by_id_mock[service]

    result = json.loads(handler_response.data.decode())

    service_mock.assert_called_with(artist_id)
    assert handler_response.status_code == 200
    assert result == service_mock.return_value.message


@pytest.mark.parametrize(
    'service',
    ['spotify'],
)
def test_participant_artist_dataloader(
    test_client, service_get_artists_by_ids_mock, service
):
    """Test participant artist success."""
    artist_ids = ['ARTIST_ID1', 'ARTIST_ID2']

    handler_response = test_client.post(
        f'/service/{service}/artist/dataloader', json={'ids': artist_ids}
    )
    service_mock = service_get_artists_by_ids_mock[service]

    result = json.loads(handler_response.data.decode())

    service_mock.assert_called_with(artist_ids=artist_ids)
    assert handler_response.status_code == 200
    assert result == service_mock.return_value.message


def test_participant_artist_not_implemented_service(test_client):
    """Test participant artist success."""
    artist_id = 'ARTIST_ID'

    handler_response = test_client.get(f'/service/notimplemented/artist/{artist_id}')

    result = json.loads(handler_response.data.decode())

    assert handler_response.status_code == 400
    assert result['code'] == error.ERROR_CODE_INVALID_USAGE
    assert result['message'] == error.ERROR_MESSAGE_INVALID_USAGE