"""Unit test for util functions for generic date and datetime operations."""
import calendar
from datetime import date
from datetime import datetime

import pytest

from feed_ingestion.util import dates_util


def test_calculate_first_and_last_day_of_release_week():
    """Test calculate_first_and_last_day_of_release_week."""
    res = dates_util.calculate_first_and_last_day_of_release_week(2017, 1)
    assert res['first_day'] == '2016-12-30'
    assert res['last_day'] == '2017-01-05'

    res = dates_util.calculate_first_and_last_day_of_release_week(2017, 52)
    assert res['first_day'] == '2017-12-22'
    assert res['last_day'] == '2017-12-28'

    res = dates_util.calculate_first_and_last_day_of_release_week(2025, 10)
    assert res['first_day'] == '2025-02-28'
    assert res['last_day'] == '2025-03-06'

    with pytest.raises(Exception):
        dates_util.calculate_first_and_last_day_of_release_week(2017, 120)


def test_calculate_release_week_number_from_date():
    """Test calculate_release_week_number_from_date."""
    date_obj = datetime(2017, 1, 1).date()
    res = dates_util.calculate_release_week_number_from_date(date_obj)
    assert res['year'] == '2017'
    assert res['week_number'] == '01'

    date_obj = datetime(2015, 12, 31).date()
    res = dates_util.calculate_release_week_number_from_date(date_obj)
    assert res['year'] == '2015'
    assert res['week_number'] == '53'

    date_obj = datetime(2018, 12, 30).date()
    res = dates_util.calculate_release_week_number_from_date(date_obj)
    assert res['year'] == '2019'
    assert res['week_number'] == '01'


def test_add_months():
    """Test add_months."""
    date_obj = datetime(2018, 11, 11)
    res = dates_util.add_months(date_obj, 3)
    assert res.year == 2019
    assert res.month == 2


@pytest.mark.parametrize(
    'weekday, expected', [
        (calendar.FRIDAY, datetime(2020, 11, 20)),
        (calendar.SATURDAY, datetime(2020, 11, 21)),
        (calendar.SUNDAY, datetime(2020, 11, 22)),
        (calendar.MONDAY, datetime(2020, 11, 23)),
        (calendar.TUESDAY, datetime(2020, 11, 24)),
        (calendar.WEDNESDAY, datetime(2020, 11, 25)),
        (calendar.THURSDAY, datetime(2020, 11, 26)),
    ]
)
def test_get_first_weekday_before_date(weekday, expected):
    """Test get_first_weekday_before_date."""
    dt = datetime(2020, 11, 26)

    assert (dates_util.
            get_first_weekday_before_date(dt=dt, weekday=weekday) == expected)


@pytest.mark.parametrize(
    'days, skip, initial_date, expected', [
        (1, 0, date(2024, 10, 15), [
            date(2024, 10, 15),
        ]),
        (2, 1, date(2024, 10, 15), [
            date(2024, 10, 14),
            date(2024, 10, 13),
        ]),
        (2, 2, date(2024, 10, 15), [
            date(2024, 10, 13),
            date(2024, 10, 12),
        ]),
    ]
)
def test_generate_dates(days, skip, initial_date, expected):
    returned = dates_util.generate_dates(
        days=days,
        skip=skip,
        initial_date=initial_date
    )

    assert list(returned) == expected


@pytest.mark.parametrize(
    'initial_date, end_date, expected', [
        (date(2024, 10, 15),
         date(2024, 10, 15),
         [
             date(2024, 10, 15),
         ],
         ),
        (date(2024, 10, 15),
         date(2024, 10, 16),
         [
             date(2024, 10, 15),
             date(2024, 10, 16),
         ],
         ),
        (date(2024, 10, 16),
         date(2024, 10, 15),
         [
             date(2024, 10, 16),
             date(2024, 10, 15),
         ],
         ),
        (None,
         None,
         ValueError,
         ),
    ]
)
def test_generate_dates_between(initial_date, end_date, expected):
    try:
        returned = dates_util.generate_dates_between(
            initial_date=initial_date,
            end_date=end_date
        )
        assert list(returned) == expected
    except BaseException as e:
        if not (isinstance(expected, type)
                and isinstance(e, expected)):
            raise


@pytest.mark.parametrize(
    'months, skip, initial_date, expected', [
        (1, 0, date(2024, 10, 15), [
            date(2024, 10, 1),
        ]),
        (2, 1, date(2024, 10, 15), [
            date(2024, 9, 1),
            date(2024, 8, 1),
        ]),
        (3, 2, date(2024, 10, 15), [
            date(2024, 8, 1),
            date(2024, 7, 1),
            date(2024, 6, 1),
        ]),
    ]
)
def test_generate_months(months, skip, initial_date, expected):
    returned = dates_util.generate_months(
        months=months,
        skip=skip,
        initial_date=initial_date
    )

    assert list(returned) == expected


@pytest.mark.parametrize(
    'weeks, skip, initial_date, weekday, expected', [
        (1, 0, date(2024, 10, 15),
         calendar.TUESDAY,
         [
            date(2024, 10, 15),
        ]),
        (1, 0, date(2024, 10, 15),
         calendar.WEDNESDAY,
         [
            date(2024, 10, 9),
        ]),
        (1, 0, date(2024, 10, 15),
         calendar.MONDAY,
         [
            date(2024, 10, 14),
        ]),
        (2, 0, date(2024, 10, 15),
         calendar.MONDAY,
         [
            date(2024, 10, 14),
            date(2024, 10, 7),
        ]),
        (2, 1, date(2024, 10, 15),
         calendar.MONDAY,
         [
            date(2024, 10, 7),
            date(2024, 9, 30),
        ]),
        (1, 0, date(2024, 10, 15),
         None,
         [
             date(2024, 10, 15),
         ]),
        (1, 1, date(2024, 10, 15),
         None,
         [
             date(2024, 10, 8),
         ]),
    ]
)
def test_generate_weeks(weeks, skip, initial_date, weekday, expected):
    returned = dates_util.generate_weeks(
        weeks=weeks,
        skip=skip,
        initial_date=initial_date,
        weekday=weekday
    )

    assert list(returned) == expected