# ===== FILE: services/tool_meta_optimizer.py =====
import os
import json
import datetime
import traceback

class ToolMetaOptimizer:
    def __init__(self, data_directory="/data/Memories/"):
        self.data_directory = data_directory
        self.log_dir = os.path.join(self.data_directory, "ToolUsage")
        self.log_file = os.path.join(self.log_dir, "tool_usage_log.jsonl")
        self.report_file = os.path.join(self.log_dir, "optimization_report.jsonl")
        
        # Ensure target directories exist inside the bucket mount immediately
        os.makedirs(self.log_dir, exist_ok=True)

    def log_invocation(self, tool_name: str, args_summary: dict, outcome: str, duration_ms: float, success: bool):
        """Appends an unalterable transaction entry to the JSONL logging stream."""
        log_entry = {
            "timestamp": datetime.datetime.utcnow().isoformat(),
            "tool_name": tool_name,
            "arguments": args_summary,
            "duration_ms": duration_ms,
            "success": success,
            "outcome_summary": str(outcome)[:500]  # Cap length to maintain clean log strings
        }
        try:
            with open(self.log_file, "a", encoding="utf-8") as f:
                f.write(json.dumps(log_entry) + "
")
        except Exception as e:
            print(f"[Meta-Optimizer] Critical Failure writing log entry: {e}", flush=True)

    def analyze_tool_patterns(self) -> dict:
        """Reads transaction metadata to isolate systemic inefficiencies and bottlenecks."""
        if not os.path.exists(self.log_file):
            return {"status": "No log historical matrix compiled yet."}

        usage_counts = {}
        failure_counts = {}
        durations = {}

        try:
            with open(self.log_file, "r", encoding="utf-8") as f:
                for line in f:
                    if not line.strip():
                        continue
                    entry = json.loads(line)
                    t_name = entry["tool_name"]
                    
                    usage_counts[t_name] = usage_counts.get(t_name, 0) + 1
                    if not entry["success"]:
                        failure_counts[t_name] = failure_counts.get(t_name, 0) + 1
                    
                    durations.setdefault(t_name, []).append(entry["duration_ms"])

            analytics = []
            for name, count in usage_counts.items():
                avg_time = sum(durations[name]) / len(durations[name]) if durations[name] else 0.0
                fails = failure_counts.get(name, 0)
                analytics.append({
                    "tool_name": name,
                    "total_invocations": count,
                    "failure_count": fails,
                    "failure_rate": fails / count,
                    "average_latency_ms": avg_time
                })

            report = {
                "report_timestamp": datetime.datetime.utcnow().isoformat(),
                "metrics_summary": analytics
            }

            with open(self.report_file, "a", encoding="utf-8") as rf:
                rf.write(json.dumps(report) + "
")

            return report
        except Exception as e:
            return {"error": f"Failed compiling usage optimization report: {str(e)}"}