import logging
from datetime import datetime, timedelta
from typing import Dict, TypeVar

import pytz
import requests

logger = logging.getLogger("waa_cube.vm_backend.getters.misc")

R = TypeVar("Rule")

day_of_week_mapping = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri", 5: "Sat", 6: "Sun"}

month_mapping = {
    1: "Jan",
    2: "Feb",
    3: "Mar",
    4: "Apr",
    5: "May",
    6: "Jun",
    7: "Jul",
    8: "Aug",
    9: "Sep",
    10: "Oct",
    11: "Nov",
    12: "Dec",
}

Month_Mapping_Full = {
    1: "January",
    2: "February",
    3: "March",
    4: "April",
    5: "May",
    6: "June",
    7: "July",
    8: "August",
    9: "September",
    10: "October",
    11: "November",
    12: "December",
}

month_mapping_full = {
    1: "january",
    2: "february",
    3: "march",
    4: "april",
    5: "may",
    6: "june",
    7: "july",
    8: "august",
    9: "september",
    10: "october",
    11: "november",
    12: "december",
}

relativeTime_to_IntDay = {
    "tomorrow": 1,
    "5th next month": "special",
    "10th next month": "special",
    "11th next month": "special",
    "this month": "special",
    "this Saturday": "special",
    "this Sunday": "special",
    "next Monday": "special",
    "next Friday": "special",
    "next Saturday": "special",
    "next Sunday": "special",
    "next week Friday": "special",
    "next week Saturday": "special",
    "next week Sunday": "special",
    "first monday four months later": "special",
    "first monday eight months later": "special",
    "next Monday split": "special",
    "next Friday split": "special",
}


def get_rule(env, config: Dict[str, R]) -> R:
    """
    Returns the rule as-is.
    """
    return config["rules"]


def get_rule_relativeTime(env, config: Dict[str, R]) -> R:
    """
    According to the rule definded in funciton "apply_rules_to_timeFormat", convert the relative time to absolute time.
    config:
        'relativeTime': {
            "from": must exist; indicates the relativeTime.
            "to": optional; indicates the relativeTime.
        }
        If relativeTime only has key "from", then the key of time in "expected" dict must be "time".
        If relativeTime has key "to", then the key of time in "expected" dict must be "from" and "to".

        Optional 'timezone': timezone string like 'Europe/Zurich', 'America/New_York', etc.
        If not specified, will try to get timezone from IP geolocation.
    """
    logger.info(f"[DEBUG] get_rule_relativeTime called with config: {config}")

    relativeRules = config["rules"]
    relativeTime = relativeRules["relativeTime"]  # int, "+" means future, "-" means past

    logger.info(f"[DEBUG] relativeTime: {relativeTime}")

    # Get timezone configuration
    timezone_str = get_timezone_from_config(config)
    try:
        timezone = pytz.timezone(timezone_str)
        logger.info(f"Successfully loaded timezone: {timezone_str}")
    except pytz.exceptions.UnknownTimeZoneError:
        logger.error(f"Unknown timezone: {timezone_str}, falling back to UTC")
        timezone = pytz.UTC

    # Get current time in the specified timezone
    now = datetime.now(timezone)
    logger.info(f"Current time in {timezone_str}: {now.strftime('%Y-%m-%d %H:%M:%S %Z')}")

    # calculate the relative time
    if "to" not in relativeTime.keys():
        start_relative_time = relativeTime["from"]
        logger.info(f"Processing single time: '{start_relative_time}'")

        if relativeTime_to_IntDay[start_relative_time] != "special":
            # relativeTime can be represented by actual int days
            start_relative_time_IntDat = relativeTime_to_IntDay[start_relative_time]
            timediff = timedelta(days=start_relative_time_IntDat)
            absoluteDay = now + timediff
            logger.info(
                f"Simple calculation: {start_relative_time} = {start_relative_time_IntDat} days → {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
            )
        else:
            # special case, you can add more special cases here
            if start_relative_time == "5th next month":
                next_year = now.year + 1 if now.month == 12 else now.year
                next_month = now.month + 1 if now.month < 12 else 1
                next_day = 5
                absoluteDay = timezone.localize(datetime(next_year, next_month, next_day))
                logger.info(f"5th next month: {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}")
            elif start_relative_time == "10th next month":
                next_year = now.year + 1 if now.month == 12 else now.year
                next_month = now.month + 1 if now.month < 12 else 1
                next_day = 10
                absoluteDay = timezone.localize(datetime(next_year, next_month, next_day))
                logger.info(f"10th next month: {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}")
            elif start_relative_time == "this month":
                absoluteDay = now
                logger.info(f"This month: {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}")
            elif start_relative_time == "next Monday":
                days_until_monday = (6 - now.weekday()) + 1
                absoluteDay = now + timedelta(days=days_until_monday)
                logger.info(
                    f"Next Monday: current weekday={now.weekday()}, days to add={days_until_monday} → {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif start_relative_time == "first monday four months later":
                next_year = now.year + 1 if now.month >= 9 else now.year
                next_month = (now.month + 4) % 12
                # get the first monday of the next_month
                temp_date = timezone.localize(datetime(next_year, next_month, 1))
                days_to_monday = ((6 - temp_date.weekday()) + 1) % 7
                absoluteDay = temp_date + timedelta(days=days_to_monday)
                logger.info(
                    f"First Monday 4 months later: {next_year}-{next_month:02d} → {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif start_relative_time == "first monday eight months later":
                next_year = now.year + 1 if now.month >= 5 else now.year
                next_month = (now.month + 8) % 12
                # get the first monday of the next_month
                temp_date = timezone.localize(datetime(next_year, next_month, 1))
                days_to_monday = ((6 - temp_date.weekday()) + 1) % 7
                absoluteDay = temp_date + timedelta(days=days_to_monday)
                logger.info(
                    f"First Monday 8 months later: {next_year}-{next_month:02d} → {absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
        regular_time = apply_rules_to_timeFormat(relativeRules["expected"]["time"], absoluteDay)
        logger.info(f"Final formatted time: {regular_time}")
        config["rules"]["expected"]["time"] = regular_time

    else:
        from_time = relativeTime["from"]
        to_time = relativeTime["to"]
        logger.info(f"Processing time range: from '{from_time}' to '{to_time}'")

        # deal with from_time first
        if relativeTime_to_IntDay[from_time] != "special":
            from_time_IntDat = relativeTime_to_IntDay[from_time]
            from_timediff = timedelta(days=from_time_IntDat)
            from_absoluteDay = now + from_timediff
            logger.info(
                f"From time calculation: {from_time} = {from_time_IntDat} days → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
            )
        else:
            if from_time == "this Saturday":
                days_until_saturday = 5 - now.weekday()
                from_absoluteDay = now + timedelta(days=days_until_saturday)
                logger.info(
                    f"This Saturday: current weekday={now.weekday()}, days to add={days_until_saturday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "10th next month":
                next_year = now.year + 1 if now.month == 12 else now.year
                next_month = now.month + 1 if now.month < 12 else 1
                next_day = 10
                from_absoluteDay = timezone.localize(datetime(next_year, next_month, next_day))
                logger.info(f"10th next month (from): {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}")
            elif from_time == "next Monday" or from_time == "next Monday split":
                days_until_monday = (6 - now.weekday()) + 1
                from_absoluteDay = now + timedelta(days=days_until_monday)
                logger.info(
                    f"Next Monday (from): current weekday={now.weekday()}, days to add={days_until_monday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "next Friday":
                # Next weekend Friday calculation
                if now.weekday() < 4:  # Monday to Thursday - use this weekend
                    days_until_friday = 4 - now.weekday()
                elif now.weekday() == 4:  # Today is Friday - use next weekend
                    days_until_friday = 7
                else:  # Saturday to Sunday - use next weekend
                    days_until_friday = (7 - now.weekday()) + 4  # Days to next Monday + 4 to get to Friday
                from_absoluteDay = now + timedelta(days=days_until_friday)
                logger.info(
                    f"Next Friday (from): current weekday={now.weekday()}, days to add={days_until_friday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "next Saturday":
                # Next weekend Saturday calculation
                if now.weekday() < 5:  # Monday to Friday - use this weekend
                    days_until_saturday = 5 - now.weekday()
                elif now.weekday() == 5:  # Today is Saturday - use next weekend
                    days_until_saturday = 7
                else:  # Sunday - use next weekend
                    days_until_saturday = 6  # 6 days to next Saturday
                from_absoluteDay = now + timedelta(days=days_until_saturday)
                logger.info(
                    f"Next Saturday (from): current weekday={now.weekday()}, days to add={days_until_saturday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "next week Friday":
                # Next week Friday - simple: go to next Monday, then +4 days
                days_to_next_monday = 7 - now.weekday()
                days_until_friday = days_to_next_monday + 4  # Monday + 4 = Friday
                from_absoluteDay = now + timedelta(days=days_until_friday)
                logger.info(
                    f"Next week Friday (from): current weekday={now.weekday()}, days to add={days_until_friday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "next week Saturday":
                # Next week Saturday - simple: go to next Monday, then +5 days
                days_to_next_monday = 7 - now.weekday()
                days_until_saturday = days_to_next_monday + 5  # Monday + 5 = Saturday
                from_absoluteDay = now + timedelta(days=days_until_saturday)
                logger.info(
                    f"Next week Saturday (from): current weekday={now.weekday()}, days to add={days_until_saturday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif from_time == "next week Sunday":
                # Next week Sunday - simple: go to next Monday, then +6 days
                days_to_next_monday = 7 - now.weekday()
                days_until_sunday = days_to_next_monday + 6  # Monday + 6 = Sunday
                from_absoluteDay = now + timedelta(days=days_until_sunday)
                logger.info(
                    f"Next week Sunday (from): current weekday={now.weekday()}, days to add={days_until_sunday} → {from_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            else:
                pass  # more rules here
        if from_time == "next Monday split":
            puday = apply_rules_to_timeFormat(relativeRules["expected"]["puDay"], from_absoluteDay)
            config["rules"]["expected"]["puDay"] = puday
            pumonth = apply_rules_to_timeFormat(relativeRules["expected"]["puMonth"], from_absoluteDay)
            config["rules"]["expected"]["puMonth"] = pumonth
            puyear = apply_rules_to_timeFormat(relativeRules["expected"]["puYear"], from_absoluteDay)
            config["rules"]["expected"]["puYear"] = puyear
            logger.info(f"Monday split formatting: puDay={puday}, puMonth={pumonth}, puYear={puyear}")
        else:
            regular_from_time = apply_rules_to_timeFormat(relativeRules["expected"]["from"], from_absoluteDay)
            config["rules"]["expected"]["from"] = regular_from_time
            logger.info(f"From time formatted: {regular_from_time}")

        # deal with to_time
        if relativeTime_to_IntDay[to_time] != "special":
            to_time_IntDat = relativeTime_to_IntDay[to_time]
            to_timediff = timedelta(days=to_time_IntDat)
            to_absoluteDay = now + to_timediff
            logger.info(
                f"To time calculation: {to_time} = {to_time_IntDat} days → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
            )
        else:
            if to_time == "this Sunday":
                days_until_sunday = 6 - now.weekday()
                to_absoluteDay = now + timedelta(days=days_until_sunday)
                logger.info(
                    f"This Sunday: current weekday={now.weekday()}, days to add={days_until_sunday} → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                )
            elif to_time == "11th next month":
                next_year = now.year + 1 if now.month == 12 else now.year
                next_month = now.month + 1 if now.month < 12 else 1
                next_day = 11
                to_absoluteDay = timezone.localize(datetime(next_year, next_month, next_day))
                logger.info(f"11th next month (to): {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}")
            elif to_time == "next Friday" or to_time == "next Friday split":
                # Check if from_time is any variant of "next Monday"
                if from_time in ["next Monday", "next Monday split"]:
                    # Calculate Friday of the same week as the Monday
                    # from_absoluteDay is already calculated as next Monday
                    # Friday is 4 days after Monday (Monday=0, Friday=4)
                    to_absoluteDay = from_absoluteDay + timedelta(days=4)
                    logger.info(
                        f"Next Friday (same week as Monday): from Monday {from_absoluteDay.strftime('%Y-%m-%d')} + 4 days → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
                else:
                    # Standalone "next Friday" calculation
                    if now.weekday() < 4:  # Monday to Thursday
                        days_to_friday = 4 - now.weekday()
                    else:  # Friday to Sunday
                        days_to_friday = (6 - now.weekday()) + 5
                    to_absoluteDay = now + timedelta(days=days_to_friday)
                    logger.info(
                        f"Next Friday (standalone): current weekday={now.weekday()}, days to add={days_to_friday} → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
            elif to_time == "next Sunday":
                # Next weekend Sunday calculation - should be the same weekend as the from_time
                if from_time in ["next Friday", "next Saturday"]:
                    # Calculate Sunday of the same weekend as from_time
                    # from_absoluteDay is already calculated, get the Sunday of that week
                    days_to_add_for_sunday = 6 - from_absoluteDay.weekday()  # Days from Friday/Saturday to Sunday
                    to_absoluteDay = from_absoluteDay + timedelta(days=days_to_add_for_sunday)
                    logger.info(
                        f"Next Sunday (to, same weekend as {from_time}): from {from_absoluteDay.strftime('%Y-%m-%d %A')} + {days_to_add_for_sunday} days → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
                else:
                    # Standalone next Sunday calculation
                    if now.weekday() < 6:  # Monday to Saturday - use this weekend
                        days_until_sunday = 6 - now.weekday()
                    else:  # Sunday - use next weekend
                        days_until_sunday = 7
                    to_absoluteDay = now + timedelta(days=days_until_sunday)
                    logger.info(
                        f"Next Sunday (to, standalone): current weekday={now.weekday()}, days to add={days_until_sunday} → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
            elif to_time == "next week Sunday":
                # Next week Sunday calculation - should be the same week as from_time if from_time is also "next week"
                if from_time in ["next week Friday", "next week Saturday"]:
                    # Calculate Sunday of the same week as from_time
                    # from_absoluteDay is already calculated, get the Sunday of that week
                    days_to_add_for_sunday = 6 - from_absoluteDay.weekday()  # Days from Friday/Saturday to Sunday
                    to_absoluteDay = from_absoluteDay + timedelta(days=days_to_add_for_sunday)
                    logger.info(
                        f"Next week Sunday (to, same week as {from_time}): from {from_absoluteDay.strftime('%Y-%m-%d %A')} + {days_to_add_for_sunday} days → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
                else:
                    # Standalone next week Sunday calculation - simple: go to next Monday, then +6 days
                    days_to_next_monday = 7 - now.weekday()
                    days_until_sunday = days_to_next_monday + 6  # Monday + 6 = Sunday
                    to_absoluteDay = now + timedelta(days=days_until_sunday)
                    logger.info(
                        f"Next week Sunday (to, standalone): current weekday={now.weekday()}, days to add={days_until_sunday} → {to_absoluteDay.strftime('%Y-%m-%d %H:%M:%S %Z')}"
                    )
            else:
                pass  # more rules here
        if to_time == "next Friday split":
            to_day = apply_rules_to_timeFormat(relativeRules["expected"]["doDay"], to_absoluteDay)
            config["rules"]["expected"]["doDay"] = to_day
            to_month = apply_rules_to_timeFormat(relativeRules["expected"]["doMonth"], to_absoluteDay)
            config["rules"]["expected"]["doMonth"] = to_month
            to_year = apply_rules_to_timeFormat(relativeRules["expected"]["doYear"], to_absoluteDay)
            config["rules"]["expected"]["doYear"] = to_year
            logger.info(f"Friday split formatting: doDay={to_day}, doMonth={to_month}, doYear={to_year}")
        else:
            regular_to_time = apply_rules_to_timeFormat(relativeRules["expected"]["to"], to_absoluteDay)
            config["rules"]["expected"]["to"] = regular_to_time
            logger.info(f"To time formatted: {regular_to_time}")

    logger.info(f"[DEBUG] Final config rules: {config['rules']}")
    return config["rules"]


def apply_rules_to_timeFormat(timeFormat: str, absoluteDay: datetime):
    timeFormat = timeFormat.replace("{DoW}", day_of_week_mapping[absoluteDay.weekday()], 1)
    timeFormat = timeFormat.replace("{Month}", month_mapping[absoluteDay.month], 1)
    timeFormat = timeFormat.replace("{DayD}", str(absoluteDay.day), 1)
    timeFormat = timeFormat.replace("{Year}", str(absoluteDay.year), 1)
    timeFormat = timeFormat.replace(
        "{Month0D}", "0" + str(absoluteDay.month) if absoluteDay.month < 10 else str(absoluteDay.month), 1
    )
    timeFormat = timeFormat.replace("{month}", month_mapping_full[absoluteDay.month], 1)
    timeFormat = timeFormat.replace("{MonthFull}", Month_Mapping_Full[absoluteDay.month], 1)
    timeFormat = timeFormat.replace(
        "{Day0D}", "0" + str(absoluteDay.day) if absoluteDay.day < 10 else str(absoluteDay.day), 1
    )
    timeFormat = timeFormat.replace("{MonthD}", str(absoluteDay.month), 1)
    # you can add other replace rules here

    return timeFormat


def get_accessibility_tree(env, *args) -> str:
    accessibility_tree: str = env.controller.get_accessibility_tree()
    logger.debug("AT@eval: %s", accessibility_tree)
    return accessibility_tree


def get_time_diff_range(env, config) -> str:
    try:
        return config["diff_range_in_minutes"]
    except Exception:
        logger.error("diff_range_in_minutes not found in config.")
        return None


def get_timezone_from_ip() -> str:
    """
    Get timezone from IP address using IP geolocation API
    Returns timezone string like 'Europe/Zurich' or 'UTC' as fallback
    """
    try:
        # Try ipapi.co first
        response = requests.get("https://ipapi.co/json/", timeout=5)
        if response.status_code == 200:
            data = response.json()
            timezone = data.get("timezone")
            if timezone:
                logger.info(f"Timezone from IP: {timezone}")
                return timezone
    except Exception as e:
        logger.warning(f"Failed to get timezone from IP: {e}")

    # Fallback to UTC
    logger.info("Using UTC as fallback timezone")
    return "UTC"


def get_timezone_from_config(config: Dict, default_timezone: str = None) -> str:
    """
    Get timezone from config, with fallback options
    Priority: config timezone > default_timezone > IP-based timezone > UTC
    """
    # Check if timezone is specified in config
    if "timezone" in config.get("rules", {}):
        timezone = config["rules"]["timezone"]
        logger.info(f"Using timezone from config: {timezone}")
        return timezone

    # Use provided default
    if default_timezone:
        logger.info(f"Using provided default timezone: {default_timezone}")
        return default_timezone

    # Get from IP
    return get_timezone_from_ip()
