"""Tests for sync artist url task."""
from unittest.mock import MagicMock

from oto import response

import pytest

from social_analytics.constants import error
from social_analytics.tasks import sync_artist_url


@pytest.fixture(params=[
    {'site_id': 2},
    {'site_id': 46},
    {'site_id': 47}
])
def get_recommended_profile_params(request):
    """Fixture for get recommended profile params."""
    return request.param


@pytest.fixture(params=[
    {'site_id': 1},
    {'site_id': 10},
    {'site_id': 11}
])
def get_recommended_profile_bad_params(request):
    """Fixture for get recommended profile bad params."""
    return request.param


@pytest.fixture(params=[
    {
        'platform': 'test',
        'platform_id': 'test'
    },
    {
        'platform_id': 'test',
        'platform_name': 'test',
    },
    {
        'platform': 'test',
        'platform_name': 'test',
    },
    {}
])
def create_social_profile_bad_params(request):
    """Fixture for create social profile bad params."""
    return request.param


@pytest.fixture
def tokens():
    """Fixture for tokens."""
    return {
        'facebook': 'test',
        'instagram': 'test',
        'spotify': 'test'
    }


@pytest.fixture
def create_social_profile_params():
    """Fixture for create social profile params."""
    return {
        'platform': 'test',
        'platform_id': 'test',
        'platform_name': 'test'
    }


@pytest.fixture(params=[
    '#!/pages/Test-Artist/112312415',
    '5-TestArtist-3453460633431840/',
    'pages/Test-Artist/175587235021',
    'profile.php?id=576713340',
    'Artist-Name-576713340',
    'test/artist/page/Artist-Name-576713340'])
def match_facebook_url_patterns_params(request):
    """Fixture for validate url params."""
    return request.param


@pytest.fixture(params=[
    {
        'url': 'pages/Test-Artist/175',
        'site_id': 2
    },
    {
        'url': 'profile.php?id=576',
        'site_id': 2
    }
])
def validate_url_too_few_id_digits(request):
    """Fixture for validate url params."""
    return request.param


@pytest.fixture(params=[
    'pages-false/Test-Artist/175587235021',
    'false-profile.php?id=576713340',
    'false-profile12345678a'
])
def match_facebook_url_patterns_bad_params(request):
    """Fixture for validate url bad params."""
    return request.param


@pytest.fixture(params=[
    {
        'url': '#!/pages/Test-Artist/112312415',
        'site_id': 2
    },
    {
        'url': '5-TestArtist-3453460633431840/',
        'site_id': 2
    },
    {
        'url': 'pages/Test-Artist/175587235021',
        'site_id': 2
    },
    {
        'url': 'profile.php?id=576713340',
        'site_id': 2
    },
    {
        'url': 'Artist-Name-576713340',
        'site_id': 2
    },
    {
        'url': 'test/artist/page/Artist-Name-576713340',
        'site_id': 2
    }
])
def validate_url_params(request):
    """Fixture for validate url params."""
    return request.param


@pytest.fixture(params=[
    {
        'url': 'pages-false/Test-Artist/175587235021',
        'site_id': 2
    },
    {
        'url': 'false-profile.php?id=576713340',
        'site_id': 2
    },
    {
        'url': 'false-profile.php?id=576713340',
        'site_id': 1
    },
])
def validate_url_bad_params(request):
    """Fixture for validate url bad params.

    This is a superset of match_facebook_url_patterns_bad_params because
    we have to also test the wrong site_id.
    """
    return request.param


@pytest.fixture
def get_artist_urls_for_sync_response():
    """Fixture for get artist urls for sync."""
    return response.Response(
        {'items': [
            {
                'url_id': 5,
                'site_id': 2,
                'url': 'profile.php?id=576713340'
            },
            {
                'url_id': 6,
                'site_id': 2,
                'url': 'profile.php?id=42'
            },
            {
                'url_id': 7,
                'site_id': 2,
                'url': 'pages/Test-Artist/175587235021',
            },
            {
                'url_id': 8,
                'site_id': 2,
                'url': 'Test-Artist-234562345101789/',
            },
            {
                'url_id': 8,
                'site_id': 2,
                'url': 'Test-Artist-234562345101789/',
            },
            {
                'url_id': 8,
                'site_id': 2,
                'url': 'Test-Artist-234562345101789/',
            }
        ]})


@pytest.fixture
def sync_urls_response():
    """Fixture for sync url response."""
    return [
        {
            'artist_url': MagicMock(),
            'social_profile': MagicMock()
        },
        {
            'artist_url': MagicMock(),
            'social_profile': MagicMock()
        },
        {
            'artist_url': MagicMock(),
            'social_profile': MagicMock()
        },
        {
            'artist_url': MagicMock(),
            'social_profile': MagicMock(),
            'error': error.SYNC_ARTIST_URL_UPDATE
        },
        {
            'artist_url': MagicMock(),
            'error': error.SYNC_ARTIST_SOCIAL_PROFILE_CREATE
        },
        {
            'artist_url': MagicMock(),
            'error': error.SYNC_ARTIST_INVALID_URL
        }
    ]


def test_sync_artist_urls_not_found(monkeypatch):
    """Test get new artist urls not found."""
    monkeypatch.setattr(
        sync_artist_url.artist_url_model, 'get_artist_urls_for_syncing',
        MagicMock(return_value=response.create_not_found_response()))

    result = sync_artist_url.sync_artist_urls()
    assert not result


def test_sync_artist_urls(
        monkeypatch, get_artist_urls_for_sync_response, sync_urls_response,
        tokens):
    """Test get new artist urls."""
    monkeypatch.setattr(
        sync_artist_url.artist_url_model, 'get_artist_urls_for_syncing',
        MagicMock(return_value=get_artist_urls_for_sync_response))
    monkeypatch.setattr(sync_artist_url, 'get_tokens', MagicMock(
        return_value=tokens))
    monkeypatch.setattr(sync_artist_url, 'sync_url', MagicMock(
        side_effect=sync_urls_response))

    errors = list(filter(lambda x: 'error' in x.keys(), sync_urls_response))

    expected = {
        'expected_urls_count': 6,
        'actual_urls_count': 3,
        'urls_data': sync_urls_response,
        'errors_count': len(errors),
        'errors_logging': errors
    }

    result = sync_artist_url.sync_artist_urls()
    assert result
    assert result == expected


def test_sync_url(monkeypatch):
    """Test sync url."""
    params = {
        'artist_url': {
            'site_id': 2,
            'url': 'profile.php?id=4231'
        },
        'tokens': tokens
    }

    recommended_profile = {
        'platform_id': 4231,
        'platform': 'facebook'
    }
    found_profile_response = response.Response({
        'social_profile_id': 1
    })

    monkeypatch.setattr(
        sync_artist_url, 'get_recommended_profile', MagicMock(
            return_value=recommended_profile))
    monkeypatch.setattr(
        sync_artist_url.social_profile,
        'get_social_profile_with_platform_id_and_platform', MagicMock(
            return_value=found_profile_response))
    monkeypatch.setattr(
        sync_artist_url.artist_url_model, 'update_artist_url', MagicMock())

    result = sync_artist_url.sync_url(params)
    assert 'social_profile' in result
    assert 'artist_url' in result
    assert 'error' not in result


def test_sync_url_error_invalid_url(tokens):
    """Test sync url error invalid url."""
    params = {
        'artist_url': {
            'site_id': 2,
            'url': 'profile.php?id=423'
        },
        'tokens': tokens
    }

    result = sync_artist_url.sync_url(params)
    assert 'error' in result
    assert result['error'] == error.SYNC_ARTIST_INVALID_URL


def test_sync_url_error_found_no_profile(monkeypatch, tokens):
    """Test sync url error found no profile."""
    params = {
        'artist_url': {
            'site_id': 2,
            'url': 'profile.php?id=4231'
        },
        'tokens': tokens
    }

    monkeypatch.setattr(sync_artist_url, 'get_recommended_profile', MagicMock(
        return_value=None))

    result = sync_artist_url.sync_url(params)
    assert 'error' in result
    assert result['error'] == error.SYNC_ARTIST_NO_PROFILE


def test_match_facebook_url_patterns(match_facebook_url_patterns_params):
    """Test match facebook url patterns."""
    result = sync_artist_url.match_facebook_url_patterns(
        match_facebook_url_patterns_params)

    assert result


def test_match_facebook_url_patterns_bad_params(
        match_facebook_url_patterns_bad_params):
    """Test match facebook url patterns bad params."""
    result = sync_artist_url.match_facebook_url_patterns(
        match_facebook_url_patterns_bad_params)

    assert not result


def test_validate_url(validate_url_params):
    """Test validate url."""
    url = validate_url_params['url']
    site_id = validate_url_params['site_id']

    result = sync_artist_url.validate_url(url, site_id)

    assert result


def test_validate_url_bad_params(validate_url_bad_params):
    """Test validate url bad params."""
    url = validate_url_bad_params['url']
    site_id = validate_url_bad_params['site_id']

    result = sync_artist_url.validate_url(url, site_id)

    assert not result


def test_validate_url_too_few_id_digits(validate_url_too_few_id_digits):
    """Test validate url too few id digits."""
    url = validate_url_too_few_id_digits['url']
    site_id = validate_url_too_few_id_digits['site_id']

    result = sync_artist_url.validate_url(url, site_id)

    assert not result


def test_get_recommended_profile(
        monkeypatch, get_recommended_profile_params, tokens):
    """Test get recommended profile."""
    platform_id = '1234'
    site_id = get_recommended_profile_params['site_id']

    monkeypatch.setattr(
        sync_artist_url.facebook_collector, 'recommend_facebook_profile',
        MagicMock())
    monkeypatch.setattr(
        sync_artist_url.instagram_collector, 'recommend_instagram_profile',
        MagicMock())
    monkeypatch.setattr(
        sync_artist_url.spotify_collector, 'recommend_spotify_profile',
        MagicMock())

    result = sync_artist_url.get_recommended_profile(
        platform_id, site_id, tokens)
    assert result


def test_get_recommended_profile_bad_params(
        get_recommended_profile_bad_params, tokens):
    """Test get recommended profile bad params."""
    platform_id = '1234'
    site_id = get_recommended_profile_bad_params['site_id']

    result = sync_artist_url.get_recommended_profile(
        platform_id, site_id, tokens)
    assert not result


def test_create_social_profile_bad_params(create_social_profile_bad_params):
    """Test create social profile."""
    result = sync_artist_url.create_social_profile(
        create_social_profile_bad_params)
    assert not result


def test_create_social_profile_create_error(
        monkeypatch, create_social_profile_params):
    """Test create social profile."""
    monkeypatch.setattr(
        sync_artist_url.social_profile, 'create_social_profile', MagicMock(
            return_value=response.create_fatal_response()))

    result = sync_artist_url.create_social_profile(
        create_social_profile_params)
    assert not result


def test_create_social_profile(monkeypatch, create_social_profile_params):
    """Test create social profile."""
    monkeypatch.setattr(
        sync_artist_url.social_profile, 'create_social_profile', MagicMock(
            return_value=response.Response('success')))
    result = sync_artist_url.create_social_profile(
        create_social_profile_params)
    assert result