#!/usr/bin/env python3
"""
GOFAI Static Analyzer — Deterministic risk assessment for autonomous code.

Detects high-risk patterns like infinite loops, resource exhaustion, 
and circular dependencies using AST analysis.
"""

import ast
import logging
import os
from typing import List, Dict, Any
from tools.registry import registry, tool_error, tool_result

logger = logging.getLogger(__name__)

STATIC_ANALYZE_SCHEMA = {
    "name": "static_analyze",
    "description": "Perform an advanced GOFAI static analysis of code. Detects infinite loops, potential memory leaks (unbounded collections), and circular dependency risks without using an LLM. Use this to ensure your code is 'Fleet-Safe'.",
    "parameters": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Path to the file to analyze."}
        },
        "required": ["path"]
    }
}

class RiskAnalyzer(ast.NodeVisitor):
    def __init__(self):
        self.risks = []
        self.current_function = None

    def visit_FunctionDef(self, node):
        old_func = self.current_function
        self.current_function = node.name
        self.generic_visit(node)
        self.current_function = old_func

    def visit_While(self, node):
        # Check for 'while True' or 'while 1'
        if isinstance(node.test, ast.Constant) and node.test.value is True:
            # Look for 'break' or 'return' inside the loop
            has_exit = any(isinstance(child, (ast.Break, ast.Return)) for child in ast.walk(node))
            if not has_exit:
                self.risks.append({
                    "type": "Infinite Loop Risk",
                    "location": f"{self.current_function or 'module'} (line {node.lineno})",
                    "severity": "HIGH",
                    "message": "Potential infinite loop: 'while True' found without clear break/return path."
                })
        self.generic_visit(node)

    def visit_For(self, node):
        # Basic check for modifying the sequence being iterated (common error)
        if isinstance(node.target, ast.Name):
            for child in ast.walk(node.body):
                if isinstance(child, ast.Call) and isinstance(child.func, ast.Attribute):
                    if child.func.attr in ['append', 'extend', 'pop', 'remove']:
                        if isinstance(child.func.value, ast.Name) and child.func.value.id == node.target.id:
                            self.risks.append({
                                "type": "Mutation Risk",
                                "location": f"{self.current_function or 'module'} (line {node.lineno})",
                                "severity": "MEDIUM",
                                "message": f"Loop modifies iterator variable '{node.target.id}'."
                            })
        self.generic_visit(node)

def run_analysis(path: str):
    """Run the static analysis pipeline."""
    try:
        source = open(path, "r").read()
        tree = ast.parse(source)
        
        analyzer = RiskAnalyzer()
        analyzer.visit(tree)
        
        if not analyzer.risks:
            return tool_result(
                status="Verified Safe",
                message="No high-risk GOFAI patterns detected. Code appears compliant with Fleet execution safety standards."
            )
        
        summary = "GOFAI RISK ASSESSMENT REPORT:\n"
        for risk in analyzer.risks:
            summary += f"- [{risk['severity']}] {risk['type']} in {risk['location']}: {risk['message']}\n"
            
        return tool_result(
            status="Risk Detected",
            summary=summary,
            risks=analyzer.risks,
            recommendation="Address the identified risks before deploying this code to the fleet."
        )

    except Exception as e:
        return tool_error(f"Static analysis failed: {str(e)}")

def _handle_static_analyze(args, **kwargs):
    return run_analysis(args.get("path"))

registry.register(
    name="static_analyze",
    toolset="qa",
    schema=STATIC_ANALYZE_SCHEMA,
    handler=_handle_static_analyze,
    emoji="🛡️"
)