#!/usr/bin/env python3

"""
date string helper test
"""

from datetime import datetime
from corelibs.datetime_handling.datetime_helpers import (
    get_datetime_iso8601, get_system_timezone, parse_timezone_data, validate_date,
    parse_flexible_date, compare_dates, find_newest_datetime_in_list,
    parse_day_of_week_range, parse_time_range, times_overlap_or_connect, is_time_in_range,
    reorder_weekdays_from_today
)


def __get_datetime_iso8601():
    """
    Comment
    """
    for tz in [
        '', 'Asia/Tokyo', 'UTC', 'Europe/Vienna',
        'America/New_York', 'Australia/Sydney',
        'invalid'
    ]:
        print(f"{tz} -> {get_datetime_iso8601(tz)}")


def __parse_timezone_data():
    for tz in [
        'JST', 'KST', 'UTC', 'CET', 'CEST',
    ]:
        print(f"{tz} -> {parse_timezone_data(tz)}")


def __validate_date():
    """
    Comment
    """

    test_dates = [
        "2024-01-01",
        "2024-02-29",  # Leap year
        "2023-02-29",  # Invalid date
        "2024-13-01",  # Invalid month
        "2024-00-10",  # Invalid month
        "2024-04-31",  # Invalid day
        "invalid-date"
    ]

    for date_str in test_dates:
        is_valid = validate_date(date_str)
        print(f"Date '{date_str}' is valid: {is_valid}")

    # also test not before and not after
    not_before_dates = [
        "2023-12-31",
        "2024-01-01",
        "2024-02-29",
    ]
    not_after_dates = [
        "2024-12-31",
        "2024-11-30",
        "2025-01-01",
    ]

    for date_str in not_before_dates:
        datetime.strptime(date_str, "%Y-%m-%d")  # Ensure valid date format
        is_valid = validate_date(date_str, not_before=datetime.strptime("2024-01-01", "%Y-%m-%d"))
        print(f"Date '{date_str}' is valid (not before 2024-01-01): {is_valid}")

    for date_str in not_after_dates:
        is_valid = validate_date(date_str, not_after=datetime.strptime("2024-12-31", "%Y-%m-%d"))
        print(f"Date '{date_str}' is valid (not after 2024-12-31): {is_valid}")

    for date_str in test_dates:
        is_valid = validate_date(
            date_str,
            not_before=datetime.strptime("2024-01-01", "%Y-%m-%d"),
            not_after=datetime.strptime("2024-12-31", "%Y-%m-%d")
        )
        print(f"Date '{date_str}' is valid (2024 only): {is_valid}")


def __parse_flexible_date():
    for date_str in [
        "2024-01-01",
        "01/02/2024",
        "February 29, 2024",
        "Invalid date",
        "2025-01-01 12:18:10",
        "2025-01-01 12:18:10.566",
        "2025-01-01T12:18:10.566",
        "2025-01-01T12:18:10.566+02:00",
    ]:
        print(f"{date_str} -> {parse_flexible_date(date_str)}")


def __compare_dates():

    for date1, date2 in [
        ("2024-01-01 12:00:00", "2024-01-01 15:30:00"),
        ("2024-01-02", "2024-01-01"),
        ("2024-01-01T10:00:00+02:00", "2024-01-01T08:00:00Z"),
        ("invalid-date", "2024-01-01"),
        ("2024-01-01", "invalid-date"),
        ("invalid-date", "also-invalid"),
    ]:
        result = compare_dates(date1, date2)
        print(f"Comparing '{date1}' and '{date2}': {result}")


def __find_newest_datetime_in_list():
    date_list = [
        "2024-01-01 12:00:00",
        "2024-01-02 09:30:00",
        "2023-12-31 23:59:59",
        "2024-01-02 15:45:00",
        "2024-01-02T15:45:00.001",
        "invalid-date",
    ]
    newest_date = find_newest_datetime_in_list(date_list)
    print(f"Newest date in list: {newest_date}")


def __parse_day_of_week_range():
    ranges = [
        "Mon-Fri",
        "Saturday-Sunday",
        "Wed-Mon",
        "Fri-Fri",
        "mon-tue",
        "Invalid-Range"
    ]
    for range_str in ranges:
        try:
            days = parse_day_of_week_range(range_str)
            print(f"Day range '{range_str}' -> {days}")
        except ValueError as e:
            print(f"[!] Error parsing day range '{range_str}': {e}")


def __parse_time_range():
    ranges = [
        "08:00-17:00",
        "22:00-06:00",
        "12:30-12:30",
        "invalid-range"
    ]
    for range_str in ranges:
        try:
            start_time, end_time = parse_time_range(range_str)
            print(f"Time range '{range_str}' -> Start: {start_time}, End: {end_time}")
        except ValueError as e:
            print(f"[!] Error parsing time range '{range_str}': {e}")


def __times_overlap_or_connect():
    time_format = "%H:%M"
    time_ranges = [
        (("08:00", "12:00"), ("11:00", "15:00")),  # Overlap
        (("22:00", "02:00"), ("01:00", "05:00")),  # Overlap across midnight
        (("10:00", "12:00"), ("12:00", "14:00")),  # Connect
        (("09:00", "11:00"), ("12:00", "14:00")),  # No overlap
    ]
    for (start1, end1), (start2, end2) in time_ranges:
        start1 = datetime.strptime(start1, time_format).time()
        end1 = datetime.strptime(end1, time_format).time()
        start2 = datetime.strptime(start2, time_format).time()
        end2 = datetime.strptime(end2, time_format).time()
        overlap = times_overlap_or_connect((start1, end1), (start2, end2))
        overlap_connect = times_overlap_or_connect((start1, end1), (start2, end2), True)
        print(f"Time ranges {start1}-{end1} and {start2}-{end2} overlap/connect: {overlap}/{overlap_connect}")


def __is_time_in_range():
    time_format = "%H:%M:%S"
    test_cases = [
        ("10:00:00", "09:00:00", "11:00:00"),
        ("23:30:00", "22:00:00", "01:00:00"),  # Across midnight
        ("05:00:00", "06:00:00", "10:00:00"),  # Not in range
        ("12:00:00", "12:00:00", "12:00:00"),  # Exact match
    ]
    for (check_time, start_time, end_time) in test_cases:
        start_time = datetime.strptime(start_time, time_format).time()
        end_time = datetime.strptime(end_time, time_format).time()
        in_range = is_time_in_range(
            f"{check_time}", start_time.strftime("%H:%M:%S"), end_time.strftime("%H:%M:%S")
        )
        print(f"Time {check_time} in range {start_time}-{end_time}: {in_range}")


def __reorder_weekdays_from_today():
    for base_day in [
        "Tue", "Wed", "Sunday", "Fri", "InvalidDay"
    ]:
        try:
            reordered_days = reorder_weekdays_from_today(base_day)
            print(f"Reordered weekdays from {base_day}: {reordered_days}")
        except ValueError as e:
            print(f"[!] Error reordering weekdays from '{base_day}': {e}")


def main() -> None:
    """
    Comment
    """
    print("\nDatetime ISO 8601 tests:\n")
    __get_datetime_iso8601()
    print("\nSystem time test:")
    print(f"System time: {get_system_timezone()}")
    print("\nParse timezone data tests:\n")
    __parse_timezone_data()
    print("\nValidate date tests:\n")
    __validate_date()
    print("\nParse flexible date tests:\n")
    __parse_flexible_date()
    print("\nCompare dates tests:\n")
    __compare_dates()
    print("\nFind newest datetime in list tests:\n")
    __find_newest_datetime_in_list()
    print("\nParse day of week range tests:\n")
    __parse_day_of_week_range()
    print("\nParse time range tests:\n")
    __parse_time_range()
    print("\nTimes overlap or connect tests:\n")
    __times_overlap_or_connect()
    print("\nIs time in range tests:\n")
    __is_time_in_range()
    print("\nReorder weekdays from today tests:\n")
    __reorder_weekdays_from_today()


if __name__ == "__main__":
    main()

# __END__