from typing import Dict, Any
from datetime import datetime
import uuid
from appPublic.uniqueID import getID


async def hermes_get_reasoning_config(context: Dict[str, Any]) -> Dict[str, Any]:
    """
    Get reasoning configuration for current user

    Args:
        context: Request context containing user information

    Returns:
        Configuration data for the current user
    """
    from .core import HermesReasoningEngine
    engine = HermesReasoningEngine()
    user_id = engine._get_current_user_id(context)

    # Query database for user configuration
    sql = """
        SELECT * FROM harnessed_reasoning_config
        WHERE user_id = %(user_id)s
        ORDER BY created_at DESC
        LIMIT 1
    """
    try:
        rows = await engine.db.sql(sql, {"user_id": user_id})
        if rows:
            config = rows[0]
            # Convert string booleans to actual booleans for UI
            config["enable_cross_session_search"] = config["enable_cross_session_search"] == "1"
            config["enable_skill_auto_loading"] = config["enable_skill_auto_loading"] == "1"
            config["enable_error_recovery"] = config["enable_error_recovery"] == "1"
            return {"success": True, "config": config}
        else:
            # Return default configuration
            default_config = {
                "id": f"default_{user_id}",
                "user_id": user_id,
                "max_reasoning_steps": 10,
                "max_tool_calls_per_step": 5,
                "enable_cross_session_search": True,
                "enable_skill_auto_loading": True,
                "safety_mode": "strict",
                "max_context_tokens": 4000,
                "enable_error_recovery": True,
                "max_recovery_attempts": 3,
                "created_at": datetime.now().isoformat(),
                "updated_at": datetime.now().isoformat()
            }
            return {"success": True, "config": default_config}
    except Exception as e:
        return {"success": False, "error": str(e)}


async def hermes_save_reasoning_config(context: Dict[str, Any], config_data: Dict[str, Any]) -> Dict[str, Any]:
    """
    Save reasoning configuration for current user

    Args:
        context: Request context containing user information
        config_data: Configuration data to save

    Returns:
        Success status
    """
    from .core import HermesReasoningEngine
    engine = HermesReasoningEngine()
    user_id = engine._get_current_user_id(context)

    # Convert boolean to string for database storage
    config_data["enable_cross_session_search"] = "1" if config_data.get("enable_cross_session_search") else "0"
    config_data["enable_skill_auto_loading"] = "1" if config_data.get("enable_skill_auto_loading") else "0"
    config_data["enable_error_recovery"] = "1" if config_data.get("enable_error_recovery") else "0"
    config_data["user_id"] = user_id
    config_data["updated_at"] = datetime.now().isoformat()

    # Check if config already exists
    sql_check = "SELECT id FROM harnessed_reasoning_config WHERE user_id = %(user_id)s"
    try:
        rows = await engine.db.sql(sql_check, {"user_id": user_id})
        if rows:
            # Update existing config
            config_data["id"] = rows[0]["id"]
            config_data["created_at"] = rows[0]["created_at"]  # Keep original created_at
            sql_update = """
                UPDATE harnessed_reasoning_config SET
                    max_reasoning_steps = %(max_reasoning_steps)s,
                    max_tool_calls_per_step = %(max_tool_calls_per_step)s,
                    enable_cross_session_search = %(enable_cross_session_search)s,
                    enable_skill_auto_loading = %(enable_skill_auto_loading)s,
                    safety_mode = %(safety_mode)s,
                    max_context_tokens = %(max_context_tokens)s,
                    enable_error_recovery = %(enable_error_recovery)s,
                    max_recovery_attempts = %(max_recovery_attempts)s,
                    updated_at = %(updated_at)s
                WHERE id = %(id)s
            """
            await engine.db.sql(sql_update, config_data)
        else:
            # Create new config
            config_data["id"] = getID()[:32]
            config_data["created_at"] = config_data["updated_at"]
            sql_insert = """
                INSERT INTO harnessed_reasoning_config (
                    id, user_id, max_reasoning_steps, max_tool_calls_per_step,
                    enable_cross_session_search, enable_skill_auto_loading, safety_mode,
                    max_context_tokens, enable_error_recovery, max_recovery_attempts,
                    created_at, updated_at
                ) VALUES (
                    %(id)s, %(user_id)s, %(max_reasoning_steps)s, %(max_tool_calls_per_step)s,
                    %(enable_cross_session_search)s, %(enable_skill_auto_loading)s, %(safety_mode)s,
                    %(max_context_tokens)s, %(enable_error_recovery)s, %(max_recovery_attempts)s,
                    %(created_at)s, %(updated_at)s
                )
            """
            await engine.db.sql(sql_insert, config_data)

        return {"success": True}
    except Exception as e:
        return {"success": False, "error": str(e)}