"""Code execution tools"""
import json
import traceback
from typing import Dict, Any

from luxx.tools.factory import tool


@tool(
    name="python_execute",
    description="Execute Python code and return the result",
    parameters={
        "type": "object",
        "properties": {
            "code": {
                "type": "string",
                "description": "Python code to execute"
            },
            "timeout": {
                "type": "integer",
                "description": "Execution timeout in seconds",
                "default": 30
            }
        },
        "required": ["code"]
    },
    category="code"
)
def python_execute(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    Execute Python code
    
    Note: This is a simplified executor, production environments should use safer isolated environments
    such as: Docker containers, Pyodide, etc.
    """
    code = arguments.get("code", "")
    timeout = arguments.get("timeout", 30)
    
    if not code:
        return {"error": "Code is required"}
    
    # Create execution environment
    namespace = {
        "__builtins__": __builtins__
    }
    
    try:
        # Compile and execute code
        compiled = compile(code, "<string>", "exec")
        
        # Capture output
        import io
        from contextlib import redirect_stdout
        
        output = io.StringIO()
        
        with redirect_stdout(output):
            exec(compiled, namespace)
        
        result = output.getvalue()
        
        # Try to extract variables
        result_vars = {k: v for k, v in namespace.items() 
                      if not k.startswith("_") and k != "__builtins__"}
        
        return {
            "output": result,
            "variables": {k: repr(v) for k, v in result_vars.items()}
        }
    except SyntaxError as e:
        return {"error": f"Syntax error: {e}"}
    except Exception as e:
        return {"error": f"Runtime error: {type(e).__name__}: {str(e)}"}


@tool(
    name="python_eval",
    description="Evaluate a Python expression and return the result",
    parameters={
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Python expression to evaluate"
            }
        },
        "required": ["expression"]
    },
    category="code"
)
def python_eval(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """Evaluate Python expression"""
    expression = arguments.get("expression", "")
    
    if not expression:
        return {"error": "Expression is required"}
    
    try:
        result = eval(expression)
        return {
            "result": repr(result),
            "type": type(result).__name__
        }
    except Exception as e:
        return {"error": f"Evaluation error: {str(e)}"}