"""Test for the Chart Handler."""
import datetime
from unittest.mock import patch

import pytest
from charts.logic import artist


def test_get_artist_aggregated_rankings(mock_get_all_feature_flags):
    """Test get_charts."""
    mock_fetchall_result = [
        ('98fb3642-2799-49b9-91c4-d5956b2dbead', 'QMFME2040289', '3lCbsHaN1wCxyDzcNN2x4N', datetime.date(2021, 2, 13),
         170, datetime.date(2021, 2, 13), 170, datetime.date(2021, 2, 13), 170, datetime.date(2021, 2, 13), 170,
         2, 170, 1000000000, None),
        ('c8bcf457-e551-49fb-94a5-0356e409f9d7', 'QMFME2089999', '7oySelE0Cb5q1TBBSPZJT2', datetime.date(2021, 2, 13),
         49, datetime.date(2021, 2, 13), 49, datetime.date(2021, 2, 13), 49, datetime.date(2021, 2, 13), 49,
         6, 49, 1000000000, None)
    ]
    expected_response = [
        {'change': 1000000000,
         'chartId': '98fb3642-2799-49b9-91c4-d5956b2dbead',
         'daysOnChart': 2,
         'exitTimestamp': None,
         'firstPosition': 170,
         'firstTimestamp': datetime.date(2021, 2, 13),
         'isrc': 'QMFME2040289',
         'mostRecentPosition': 170,
         'mostRecentTimestamp': datetime.date(2021, 2, 13),
         'peakPosition': 170,
         'peakTimestamp': datetime.date(2021, 2, 13),
         'position': 170,
         'previousPosition': 170,
         'previousTimestamp': datetime.date(2021, 2, 13),
         'trackId': '3lCbsHaN1wCxyDzcNN2x4N'},
        {'change': 1000000000,
         'chartId': 'c8bcf457-e551-49fb-94a5-0356e409f9d7',
         'daysOnChart': 6,
         'exitTimestamp': None,
         'firstPosition': 49,
         'firstTimestamp': datetime.date(2021, 2, 13),
         'isrc': 'QMFME2089999',
         'mostRecentPosition': 49,
         'mostRecentTimestamp': datetime.date(2021, 2, 13),
         'peakPosition': 49,
         'peakTimestamp': datetime.date(2021, 2, 13),
         'position': 49,
         'previousPosition': 49,
         'previousTimestamp': datetime.date(2021, 2, 13),
         'trackId': '7oySelE0Cb5q1TBBSPZJT2'},
    ]
    with patch.object(artist.snowflake, 'fetchall', return_value=mock_fetchall_result):
        response = artist.get_artist_aggregated_rankings(
            artist_id=3377728,
            chart_filter={},
            limit=100,
            offset=0,
            order_by='POSITION',
            order_direction='ASC',
            isrc=None,
            public_sound_recording_id=None,
            only_current=False
        )
        assert response == expected_response


@pytest.mark.parametrize(
    'chart_filter, expected_params, expected_sql', [
        (
            {'platform': 'plat'},
            {'chart_platform': 'plat'},
            'AND dc.platform = :chart_platform'
        ),
        (
            {'platform': 'plat'},
            {'chart_platform': 'plat'},
            'AND dc.platform = :chart_platform'
        ),
        (
            {'id': '123', 'platform': 'plat'},
            {'chart_platform': 'plat', 'chart_id': '123'},
            'AND dc.chartid = :chart_id AND dc.platform = :chart_platform'
        ),
        (
            {'genre': 'sample_genre', 'country': 'US', 'target': 'daily'},
            {'chart_genre': 'sample_genre', 'chart_country': 'US', 'chart_target': 'daily'},
            'AND dc.country = :chart_country AND dc.genre = :chart_genre AND dc.target = :chart_target'
        ),
        (
            {'type': 'sample_type', 'other': 'something irrelevant'},
            {'chart_type': 'sample_type'},
            'AND dc.type = :chart_type'
        ),
        (
            {'type': 'SELECT hack_not_appear_at_sql_will_be_quoted'},
            {'chart_type': 'SELECT hack_not_appear_at_sql_will_be_quoted'},
            'AND dc.type = :chart_type'
        ),
    ])
def test_get_artist_aggregated_rankings_filter_chart(chart_filter, expected_params, expected_sql, mock_get_all_feature_flags):
    with patch.object(artist.snowflake, 'fetchall') as fetchall_mock:
        artist.get_artist_aggregated_rankings(
            artist_id=3377728,
            chart_filter=chart_filter,
            limit=100,
            offset=0,
            order_by='POSITION',
            order_direction='ASC',
            isrc=None,
            public_sound_recording_id=None,
            only_current=False
        )
        assert fetchall_mock.called
        sql, params = fetchall_mock.call_args[0]
        assert expected_sql in sql, sql
        assert all(item in params.items() for item in expected_params.items())


@pytest.mark.parametrize(
    'kwargs, expected_sql', [
        (
            {'isrc': 'XZ1234', 'public_sound_recording_id': None},
            'AND isrc = :isrc'
        ),
        (
            {'isrc': None, 'public_sound_recording_id': 'XXXX-CCCC-VVVVV'},
            'AND public_sound_recording_id = :public_sound_recording_id'
        ),
        (
            {'isrc': 'XC12333', 'public_sound_recording_id': 'XXXX-CCCC-VVVVV'},
            'AND isrc = :isrc AND public_sound_recording_id = :public_sound_recording_id'
        ),
    ])
def test_get_artist_aggregated_rankings_filter(kwargs, expected_sql, mock_get_all_feature_flags):
    with patch.object(artist.snowflake, 'fetchall') as fetchall_mock:
        artist.get_artist_aggregated_rankings(
            3377728, chart_filter={}, offset=0, limit=10,
            order_by='POSITION', order_direction='asc',
            only_current=False, **kwargs)
        assert fetchall_mock.called
        sql, params = fetchall_mock.call_args[0]
        assert expected_sql in sql, sql


@pytest.mark.parametrize(
    'kwargs, expected_sql', [
        [
            {'order_by': order_by, 'order_direction': order_dir},
            f'ORDER BY {artist.artist_aggregated_rankings_order_by_mapping[order_by]} {artist.artist_aggregated_rankings_order_direction_mapping[order_dir]}'  # noqa
        ]
        for order_by in artist.artist_aggregated_rankings_order_by_mapping
        for order_dir in artist.artist_aggregated_rankings_order_direction_mapping
    ])
def test_get_artist_aggregated_rankings_ordering(kwargs, expected_sql, mock_get_all_feature_flags):
    with patch.object(artist.snowflake, 'fetchall') as fetchall_mock:
        artist.get_artist_aggregated_rankings(
            artist_id=3377728,
            chart_filter={},
            limit=100,
            offset=0,
            isrc=None,
            public_sound_recording_id=None,
            only_current=False,
            **kwargs
        )
        assert fetchall_mock.called
        sql, params = fetchall_mock.call_args[0]
        assert expected_sql in sql, sql


def test_artist_songs(mock_get_all_feature_flags):
    mock_fetchall_result = [
        ('QMFME2089999', 'Si Me Tomo una Cerveza - Remix', 'testid', 46),
        ('QMFME2040289', 'Si Me Tomo Una Cerveza', 'testid2', 92),
    ]
    expected_response = [
        {'count': 46,
         'isrc': 'QMFME2089999',
         'psrId': 'testid',
         'songName': 'Si Me Tomo una Cerveza - Remix',
         },
        {'count': 92,
         'isrc': 'QMFME2040289',
         'psrId': 'testid2',
         'songName': 'Si Me Tomo Una Cerveza'}
    ]
    with patch.object(artist.snowflake, 'fetchall', return_value=mock_fetchall_result):
        response = artist.artist_songs(
            artist_id=3377728,
            chart_filter={},
            isrc=None,
            public_sound_recording_id=None,
            only_current=False,
        )
        assert response == expected_response


def test_artist_charts(mock_get_all_feature_flags):
    mock_fetchall_result = [
        ('f7c3e9f1-1852-4e56-806e-4d57b3b1a3fa', 6),
        ('0be75e76-8018-4162-a7bf-ff761cf258d8', 2),
        ('f8d63b99-e49c-4a1e-8b83-676f22baddfc', 3),
    ]
    expected_response = [
        {'chartId': 'f7c3e9f1-1852-4e56-806e-4d57b3b1a3fa', 'count': 6},
        {'chartId': '0be75e76-8018-4162-a7bf-ff761cf258d8', 'count': 2},
        {'chartId': 'f8d63b99-e49c-4a1e-8b83-676f22baddfc', 'count': 3},
    ]
    with patch.object(artist.snowflake, 'fetchall', return_value=mock_fetchall_result):
        response = artist.artist_charts(
            artist_id=3377728,
            chart_filter={},
            isrc=None,
            public_sound_recording_id=None,
            only_current=False,
        )
        assert response == expected_response


def test_artist_countries(mock_get_all_feature_flags):
    mock_fetchall_result = [
        ('AR', 29),
        ('CR', 8),
        ('AD', 1),
    ]
    expected_response = [
        {'count': 29, 'countryCode': 'AR'},
        {'count': 8, 'countryCode': 'CR'},
        {'count': 1, 'countryCode': 'AD'},
    ]
    with patch.object(artist.snowflake, 'fetchall', return_value=mock_fetchall_result):
        response = artist.artist_countries(
            artist_id=3377728,
            chart_filter={},
            isrc=None,
            public_sound_recording_id=None,
            only_current=False,
        )
        assert response == expected_response


def test_artist_current_appearances(mock_get_all_feature_flags):
    mock_fetchall_result = [1234]
    expected_response = {'count': 1234}
    with patch.object(artist.snowflake, 'fetchone', return_value=mock_fetchall_result):
        response = artist.artist_current_appearances(
            3377728,
            None,
            None,
            chart_filter={},
            isrc=None,
            public_sound_recording_id=None,
            only_current=False,)
        assert response == expected_response


def test_artist_chart_highlights(mock_get_all_feature_flags):
    mock_fetchall_result = [
        (46, 30, 'QMFME2089999', 'testid', 'Si Me Tomo una Cerveza - Remix', 90, 62),
        (44, 32, 'QMFME2089998', 'testid2', 'Si Me Tomo una Cerveza - Remix2', 90, 62)]
    expected_response = {
        'items': [
            {
                'appearances': 46,
                'currentAppearances': 30,
                'isrc': 'QMFME2089999',
                'psrId': 'testid',
                'psrName': 'Si Me Tomo una Cerveza - Remix',
            },
            {
                'appearances': 44,
                'currentAppearances': 32,
                'isrc': 'QMFME2089998',
                'psrId': 'testid2',
                'psrName': 'Si Me Tomo una Cerveza - Remix2',
            }
        ],
        'totalAppearances': 90,
        'totalCurrentAppearances': 62
    }

    with patch.object(artist.snowflake, 'fetchall', return_value=mock_fetchall_result):
        response = artist.artist_chart_highlights(
            3377728, None, None)
        assert response == expected_response