from datetime import datetime

import pytest
import pytz

from delphi_api.core.caches import CompositeRangeCache, ItemKeysCache
from delphi_api.errors import RangeError
from delphi_api.utils import DateUtils, QueryUtils, Strings


@pytest.fixture(autouse=True)
def clear_cache():
    yield
    CompositeRangeCache.clear()
    ItemKeysCache.clear()


class TestDateUtils:
    @pytest.mark.parametrize('start,end,expected', [
        ('2019-01-01', '2019-01-01', ['2019-01-01']),
        ('2019-01-01', '2019-01-05', [
            '2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04', '2019-01-05']),
    ])
    def test_date_range(self, start, end, expected):
        assert DateUtils.date_range(start, end) == expected

    def test_date_range_invalid_range_raises(self):
        with pytest.raises(RangeError) as e:
            DateUtils.date_range('2019-01-05', '2019-01-01')

    def test_valid_range(self):
        assert DateUtils.valid_range(start='2019-01-01', end='2019-01-05')

    def test_valid_range_invalid_raises(self):
        with pytest.raises(RangeError) as e:
            DateUtils.valid_range('2019-01-05', '2019-01-01')

    def test_today(self):
        result = DateUtils.today()
        assert result.tzinfo == pytz.utc

    @pytest.mark.parametrize('date,fmt,expected', [
        (datetime(2019, 1, 2, tzinfo=pytz.utc), '%Y-%m-%d', '2019-01-02'),
        (datetime(2019, 1, 2, tzinfo=pytz.utc), '%m/%d/%Y', '01/02/2019'),
    ])
    def test_as_str(self, date, fmt, expected):
        assert DateUtils.as_str(date, fmt) == expected

    @pytest.mark.parametrize('date,fmt,expected', [
        ('2019-01-02', '%Y-%m-%d', datetime(2019, 1, 2, tzinfo=pytz.utc)),
        ('01/02/2019', '%m/%d/%Y', datetime(2019, 1, 2, tzinfo=pytz.utc)),
    ])
    def test_from_str(self, date, fmt, expected):
        assert DateUtils.from_str(date, fmt) == expected

    @pytest.mark.parametrize('date1,date2,expected', [
        (datetime(2019, 1, 2, tzinfo=pytz.utc), datetime(2019, 1, 3, tzinfo=pytz.utc), True),
        (datetime(2019, 1, 2, tzinfo=None), datetime(2019, 1, 3, tzinfo=pytz.utc), True),
        (datetime(2019, 1, 3, tzinfo=pytz.utc), datetime(2019, 1, 2, tzinfo=pytz.utc), False),
        (datetime(2019, 1, 3, tzinfo=None), datetime(2019, 1, 2, tzinfo=pytz.utc), False),
    ])
    def test_before(self, date1, date2, expected):
        assert DateUtils.before(date1, date2) == expected


class TestQueryUtils:
    def test_build_item_keys(self, mock_hash_keys_set, mock_range_keys_set, mock_item_keys):
        assert QueryUtils.build_item_keys(mock_hash_keys_set, mock_range_keys_set) == mock_item_keys

    def test_build_item_keys_level_3(self, mock_hash_keys_set,
                                     mock_range_keys_set,
                                     mock_dsp_slugs_set,
                                     mock_item_keys_level_3):
        result = QueryUtils.build_item_keys(mock_hash_keys_set, mock_range_keys_set,
                                            mock_dsp_slugs_set)
        assert result == mock_item_keys_level_3

    def test_build_composite_range_keys_2_params(self):
        dates = frozenset(DateUtils.date_range('2019-01-01', '2019-01-06', '%Y-%m-%d'))
        countries = frozenset(['us', 'gb'])
        expected = []
        for date in sorted(dates):
            for country in sorted(countries):
                expected.append(f'{date}_{country}')
        assert QueryUtils.build_composite_range_keys(dates, countries) == expected

    def test_build_composite_range_keys_3_params(self):
        dates = frozenset(DateUtils.date_range('2019-01-01', '2019-01-06', '%Y-%m-%d'))
        countries = frozenset(['us', 'gb'])
        set3 = frozenset(['foobar'])
        expected = []
        for date in sorted(dates):
            for country in sorted(countries):
                for item in sorted(set3):
                    expected.append(f'{date}_{country}_{item}')
        assert QueryUtils.build_composite_range_keys(dates, countries, set3) == expected


class TestStringUtils:
    @pytest.mark.parametrize('name,expected', [
        ('ListenersGenderFemaleAge25_34', 'listeners_gender_female_age_25_34'),
        ('ListenersGenderFemaleAge_25_34', 'listeners_gender_female_age_25_34'),
        ('ListenersGenderFemale', 'listeners_gender_female'),
    ])
    def test_camel_to_snake_case(self, name, expected):
        assert Strings.camel_to_snake_case(name) == expected

    @pytest.mark.parametrize('name,expected', [
        ('AR-F47-1100050', 'ARF471100050'),
        ('ARF471100050', 'ARF471100050'),
    ])
    def test_camel_to_snake_case(self, name, expected):
        assert Strings.normalize_isrc(name) == expected