"""Test Songwhip model."""
from unittest.mock import call
from urllib.parse import urlencode

import pytest
import responses

from src import config
from src.config import app_logger
from src.config import SONGWHIP_LOOKUP_API_HOST
from src.model import songwhip as songwhip_model


@pytest.mark.parametrize(
    (
        'test_description',
        'test_spotify_id',
        'test_deezer_id',
        'test_youtube_id',
        'expected_music_service_url'
    ),
    [
        (
            'spotify url to call lookup api',
            'spotify_id',
            'deezer_id',
            'youtube_id',
            'https://open.spotify.com/album/spotify_id'
        ),
        (
            'Deezer url to call lookup api',
            None,
            'deezer_id',
            'youtube_id',
            'https://www.deezer.com/album/deezer_id'
        ),
        (
            'YouTube url to call lookup api',
            None,
            None,
            'youtube_id',
            'https://www.youtube.com/watch?v=youtube_id'
        )
    ]
)
def test_songwhip_lookup_success(
    mocker,
    test_description,
    test_spotify_id,
    test_deezer_id,
    test_youtube_id,
    expected_music_service_url
):
    """Test lookup_songwhip_links success."""
    mocker.patch.object(config, 'SONGWHIP_LOOKUP_TOKEN', 'TEST_TOKEN')

    expected_songwhip_result = {'links': {
        'some-dms': [{'link': 'test url', 'countries': None}]
    }}

    with responses.RequestsMock() as requests_mock:
        request_params = urlencode({
            'country': 'US',
            'url': expected_music_service_url
        })
        requests_mock.get(
            url=SONGWHIP_LOOKUP_API_HOST,
            match=[responses.matchers.query_string_matcher(request_params)],
            json=expected_songwhip_result
        )

        result = songwhip_model.lookup_songwhip_links(
            spotify_id=test_spotify_id,
            deezer_id=test_deezer_id,
            youtube_id=test_youtube_id
        )

        assert len(requests_mock.calls) == 1
        assert requests_mock.calls[0].request.headers['Authorization'] == 'Bearer TEST_TOKEN'

    assert result == {'some-dms': [{'link': 'test url', 'countries': None}]}


def test_songwhip_lookup_success_no_music_service_ids(mocker):
    """Verify None response when there are no music service ids."""
    result = songwhip_model.lookup_songwhip_links(
        spotify_id=None,
        deezer_id=None,
        youtube_id=None
    )

    assert result is None


def test_songwhip_lookup_failure_tried_all_music_service_urls(mocker):
    """Test failure to create songwhip url with all music service urls."""
    mocker.patch.object(app_logger, 'info')

    with responses.RequestsMock() as requests_mock:
        query_params_spotify = urlencode({
            'country': 'US',
            'url': 'https://open.spotify.com/album/ghi'
        })
        requests_mock.get(
            url=SONGWHIP_LOOKUP_API_HOST,
            status=404,
            match=[responses.matchers.query_string_matcher(query_params_spotify)]
        )
        query_params_deezer = urlencode({
            'country': 'US',
            'url': 'https://www.deezer.com/album/def'
        })
        requests_mock.get(
            url=SONGWHIP_LOOKUP_API_HOST,
            status=404,
            match=[responses.matchers.query_string_matcher(query_params_deezer)]
        )
        query_params_youtube = urlencode({
            'country': 'US',
            'url': 'https://www.youtube.com/watch?v=abc'
        })
        requests_mock.get(
            url=SONGWHIP_LOOKUP_API_HOST,
            status=404,
            match=[responses.matchers.query_string_matcher(query_params_youtube)]
        )

        result = songwhip_model.lookup_songwhip_links(
            spotify_id='ghi',
            deezer_id='def',
            youtube_id='abc'
        )

    assert app_logger.info.mock_calls == [
        call(
            'Songwhip-lookup failed for: '
            'spotify_id=ghi, deezer_id=def, youtube_id=abc'
        )
    ]
    assert result is None