import time
import os
import random
import json
import re

try:
    # 'regex' on PyPI supports `\p{L}`, `\p{N}`, etc. 
    import regex
    USE_REGEX_LIB = True
except ImportError:
    # Fallback to Python's built-in 're' if 'regex' isn't installed
    USE_REGEX_LIB = False

DICTIONARY_PATH = "dictionary/"  # Path to dictionary files

def format_uptime(seconds: float) -> tuple[str, int]:
    """
    Convert seconds into a human-readable string:
    - Example outputs:
      "32 minutes"
      "8 days, 4 hours"
      "1 year, 3 months"
    - Returns a tuple:
      (Human-readable string, total seconds)
    """
    seconds = int(seconds)  # Ensure integer seconds

    # Define time units
    units = [
        ("year", 31536000),   # 365 days
        ("month", 2592000),   # 30 days
        ("day", 86400),       # 24 hours
        ("hour", 3600),       # 60 minutes
        ("minute", 60),
        ("second", 1)
    ]

    # Compute time breakdown
    time_values = []
    for unit_name, unit_seconds in units:
        value, seconds = divmod(seconds, unit_seconds)
        if value > 0:
            time_values.append(f"{value} {unit_name}{'s' if value > 1 else ''}")  # Auto pluralize

    # Return only the **two most significant** time units (e.g., "3 days, 4 hours")
    return (", ".join(time_values[:2]), seconds) if time_values else ("0 seconds", 0)
    
def get_random_reply(dictionary_name: str, category: str, **variables) -> str:
    """
    Fetches a random string from a given dictionary and category.
    Supports variable substitution using keyword arguments.

    :param dictionary_name: The name of the dictionary file (without .json)
    :param category: The category (key) inside the dictionary to fetch a response from
    :param variables: Keyword arguments to replace placeholders in the string
    :return: A formatted string with the variables replaced
    """
    file_path = os.path.join(DICTIONARY_PATH, f"{dictionary_name}.json")

    # Ensure file exists
    if not os.path.exists(file_path):
        return f"[Error: Missing {dictionary_name}.json]"

    try:
        with open(file_path, "r", encoding="utf-8") as file:
            data = json.load(file)
    except json.JSONDecodeError:
        return f"[Error: Failed to load {dictionary_name}.json]"

    # Ensure category exists
    if category not in data or not isinstance(data[category], list):
        return f"[Error: No valid entries for {category} in {dictionary_name}.json]"

    # Select a random reply
    response = random.choice(data[category])

    # Replace placeholders with provided variables
    return response.format(**variables)

##############################
# Basic sanitization
# DO NOT RELY SOLELY ON THIS
##############################
def sanitize_user_input(
    user_input: str,
    usage: str = "GENERAL",
    max_length: int = 500
):
    """
    A whitelisting-based function for sanitizing user input.

    Returns a tuple of:
      (sanitized_str, sanitization_applied_bool, sanitization_reason, original_str)

    :param user_input: The raw string from the user (e.g., from Twitch or Discord).
    :param usage: 
        - 'CALC': Keep digits, math operators, parentheses, etc.
        - 'GENERAL': Keep typical readable characters & punctuation.
    :param max_length: Truncate the input if it exceeds this length.
    :return: (sanitized_str, bool, reason_string, original_str)

    ======================
    SECURITY RECOMMENDATIONS
    ======================
    1) For database storage (MariaDB, etc.):
       - **Always** use parameterized queries or an ORM with bound parameters.
       - Do not rely solely on string sanitization to prevent SQL injection.
    
    2) For code execution (e.g., 'eval'):
       - Avoid using eval/exec on user input.
       - If you must, consider a restricted math parser or an audited sandbox.
    
    3) For HTML sanitization:
       - Bleach is deprecated; research modern alternatives or frameworks that
         safely sanitize HTML output. This function does *not* sanitize HTML tags.
    """

    original_string = str(user_input)
    reasons = []
    sanitization_applied = False

    # 1. Truncate and remove newlines, tabs, etc.
    truncated = original_string[:max_length]
    truncated = re.sub(r"[\r\n\t]+", " ", truncated)

    sanitized = truncated

    # 2. Choose how to filter based on usage
    usage = usage.upper()

    if usage == "CALC":
        # Allow digits, +, -, *, /, %, parentheses, decimal points, ^ for exponent, spaces
        # Remove everything else
        pattern = r"[^0-9+\-*/%().^ \t]"
        new_sanitized = re.sub(pattern, "", sanitized)
        if new_sanitized != sanitized:
            sanitization_applied = True
            reasons.append("CALC: Removed non-math characters.")
        sanitized = new_sanitized

    else:  # GENERAL usage
        if USE_REGEX_LIB:
            # Remove ASCII control chars (0-31, 127) first
            step1 = re.sub(r"[\x00-\x1F\x7F]", "", sanitized)
            # Then apply a fairly broad whitelist:
            # \p{L}: letters; \p{N}: numbers; \p{P}: punctuation; \p{S}: symbols; \p{Z}: separators (including spaces).
            # This keeps emojis, foreign characters, typical punctuation, etc.
            pattern = r"[^\p{L}\p{N}\p{P}\p{S}\p{Z}]"
            new_sanitized = regex.sub(pattern, "", step1)

            if new_sanitized != sanitized:
                sanitization_applied = True
                reasons.append("GENERAL: Removed disallowed chars via regex.")
            sanitized = new_sanitized
        else:
            # Fallback: If 'regex' is not installed, remove control chars and keep ASCII printable only.
            step1 = re.sub(r"[\x00-\x1F\x7F]", "", sanitized)
            pattern = r"[^ -~]"  # Keep only ASCII 32-126
            new_sanitized = re.sub(pattern, "", step1)

            if new_sanitized != sanitized:
                sanitization_applied = True
                reasons.append("GENERAL: Removed non-ASCII or control chars (fallback).")
            sanitized = new_sanitized

    # 3. Final trim
    sanitized = sanitized.strip()

    # 4. Prepare output
    reason_string = "; ".join(reasons)
    return (sanitized, sanitization_applied, reason_string, original_string)

#####################
# Help command logic
#####################

async def handle_help_command(ctx, command_name, bot, is_discord, log_func):
    """
    Called by the platform-specific help commands to provide the help text.
    :param ctx: discord.py or twitchio context
    :param command_name: e.g. "quote" or None if user typed just "!help"
    :param bot: The current bot instance
    :param is_discord: True for Discord, False for Twitch
    :param log_func: The logging function
    """

    # If there's no loaded help_data, we can't do much
    if not hasattr(bot, "help_data") or not bot.help_data:
        return await send_message(ctx, "No help data found.")

    help_data = bot.help_data  # The parsed JSON from e.g. help_discord.json
    if "commands" not in help_data:
        return await send_message(ctx, "Invalid help data structure (no 'commands' key).")

    if not command_name:
        # User typed just "!help" => list all known commands from this bot
        loaded_cmds = get_loaded_commands(bot)
        if not loaded_cmds:
            return await send_message(ctx, "I have no commands loaded.")
        else:
            short_list = ", ".join(loaded_cmds)
            # We can also mention "Use !help [command] for more info."
            return await send_message(
                ctx,
                f"I currently offer these commands: {short_list}\nUse '!help <command>' for details."
            )

    # 1) Check if the command is loaded
    loaded = (command_name in get_loaded_commands(bot))
    # 2) Check if it has help info in the JSON
    cmd_help = help_data["commands"].get(command_name, None)

    if loaded and cmd_help:
        # The command is loaded, and we have help info => show it
        if is_discord:
            msg = build_discord_help_message(command_name, cmd_help)
        else:
            msg = build_twitch_help_message(command_name, cmd_help)
        await send_message(ctx, msg)

    elif loaded and not cmd_help:
        # The command is loaded but no help info => mention that
        await send_message(ctx, f"The '{command_name}' command is loaded but has no help info yet.")
    elif (not loaded) and cmd_help:
        # The command is not loaded, but we have an entry => mention it's unloaded/deprecated
        await send_message(ctx, f"The '{command_name}' command is not currently loaded (deprecated or unavailable).")
    else:
        # Not loaded, no help info => not found at all
        await send_message(ctx, f"I'm sorry, I don't offer a command named '{command_name}'.")


def initialize_help_data(bot, help_json_path, is_discord, log_func):
    """
    Loads help data from a JSON file, stores it in bot.help_data, 
    then verifies each loaded command vs. the help_data.
    Logs any mismatches:
      - Commands in help file but not loaded => "deprecated"
      - Loaded commands not in help file => "missing help"
    """

    if not os.path.exists(help_json_path):
        log_func(f"Help file '{help_json_path}' not found. No help data loaded.", "WARNING")
        bot.help_data = {}
        return

    # Load the JSON
    try:
        with open(help_json_path, "r", encoding="utf-8") as f:
            data = json.load(f)
    except Exception as e:
        log_func(f"Error parsing help JSON '{help_json_path}': {e}", "ERROR")
        data = {}

    bot.help_data = data

    # Now cross-check the loaded commands vs. the data
    loaded_cmds = set(get_loaded_commands(bot))
    if "commands" not in data:
        log_func(f"No 'commands' key in {help_json_path}, skipping checks.", "ERROR")
        return

    file_cmds = set(data["commands"].keys())

    # 1) Commands in file but not loaded
    missing_cmds = file_cmds - loaded_cmds
    for cmd in missing_cmds:
        log_func(f"Help file has '{cmd}', but it's not loaded on this {'Discord' if is_discord else 'Twitch'} bot (deprecated?).", "WARNING")

    # 2) Commands loaded but not in file
    needed_cmds = loaded_cmds - file_cmds
    for cmd in needed_cmds:
        log_func(f"Command '{cmd}' is loaded on {('Discord' if is_discord else 'Twitch')} but no help info is provided in {help_json_path}.", "WARNING")


def get_loaded_commands(bot):
    commands_list = []

    # For Discord.py
    if hasattr(bot, "commands"):
        for c_obj in bot.commands:
            commands_list.append(c_obj.name)

    # For TwitchIO
    if hasattr(bot, "all_commands"):
        # each item is (command_name_str, command_object)
        for cmd_name, cmd_obj in bot.all_commands.items():
            commands_list.append(cmd_name)

    return sorted(commands_list)


def build_discord_help_message(cmd_name, cmd_help_dict):
    """
    A verbose multi-line string for Discord.
    """
    description = cmd_help_dict.get("description", "No description available.\n")
    subcommands = cmd_help_dict.get("subcommands", {})
    examples = cmd_help_dict.get("examples", [])

    lines = [f"**Help for `!{cmd_name}`**:",
             f"Description: {description}"]

    if subcommands:
        lines.append("\n**Subcommands / Arguments:**")
        for sub, detail in subcommands.items():
            arg_part = detail.get("args", "")
            desc_part = detail.get("desc", "")
            lines.append(f"• **{sub}** {arg_part} **->** {desc_part}")
    else:
        lines.append("\n*No subcommands defined.*")

    if examples:
        lines.append("\nExample usage:")
        for ex in examples:
            ex_cmd = ex.split(" : ")[0]
            ex_note = ex.split(" : ")[1]
            lines.append(f"- `{ex_cmd}`\n   {ex_note}")

    return "\n".join(lines)


def build_twitch_help_message(cmd_name, cmd_help_dict):
    """
    A concise, possibly single-line help for Twitch.
    """
    description = cmd_help_dict.get("description", "No description available.")
    subcommands = cmd_help_dict.get("subcommands", {})
    sub_line_parts = []
    for sub, detail in subcommands.items():
        if sub == "no subcommand":
            sub_line_parts.append(f"!{cmd_name}")
        else:
            arg_part = detail.get("args", "")
            if arg_part:
                sub_line_parts.append(f"!{cmd_name} {sub} {arg_part}".strip())
            else:
                sub_line_parts.append(f"!{cmd_name} {sub}".strip())

    usage_line = " | ".join(sub_line_parts) if sub_line_parts else f"!{cmd_name}"

    return f"Help for !{cmd_name}: {description}. Usage: {usage_line}"


async def send_message(ctx, text):
    """
    Minimal helper to send a message to either Discord or Twitch.
    """
    await ctx.send(text)