import hashlib
import json
from typing import List, Dict, Any, Tuple

class LoopBreakerException(Exception):
    pass

class AgentLoopEngine:
    def __init__(self, max_steps: int = 8, max_repeated_actions: int = 2):
        self.max_steps = max_steps
        self.max_repeated_actions = max_repeated_actions
        self.action_history: List[str] = []

    def _compute_fingerprint(self, tool_name: str, args: Dict[str, Any]) -> str:
        serialized = json.dumps({"tool": tool_name, "args": args}, sort_keys=True)
        return hashlib.md5(serialized.encode("utf-8")).hexdigest()

    def check_loop_safety(self, tool_name: str, args: Dict[str, Any]) -> None:
        fp = self._compute_fingerprint(tool_name, args)
        self.action_history.append(fp)
        
        # 检查尾部连续相同动作次数
        recent_matches = 0
        for past_fp in reversed(self.action_history):
            if past_fp == fp:
                recent_matches += 1
            else:
                break
                
        if recent_matches > self.max_repeated_actions:
            raise LoopBreakerException(
                f"检测到死循环风险：连续 {recent_matches} 次尝试执行相同工具及入参 [{tool_name}]，执行已熔断。"
            )

    def external_verify(self, solution_artifact: str) -> Tuple[bool, str]:
        # 模拟确定性外部断言（例如执行编译器编译或单元测试）
        if "assert result == 42" in solution_artifact:
            return True, "All tests passed."
        return False, "AssertionError: Expected 42, but got invalid output."

    def run(self, user_goal: str) -> Dict[str, Any]:
        print(f"[Loop Engine] 启动任务循环: {user_goal}")
        messages: List[Dict[str, Any]] = [
            {"role": "user", "content": user_goal}
        ]
        
        current_step = 0
        while current_step < self.max_steps:
            current_step += 1
            print(f"\n--- [Step {current_step}/{self.max_steps}] ---")
            
            # 模拟模型在第 1 步产出错误方案，在第 2 步收到验证失败反馈后纠偏成功
            if current_step == 1:
                model_proposal = "def solve(): return 0  # assert result == 0"
                tool_call = ("run_eval", {"code": model_proposal})
            else:
                model_proposal = "def solve(): return 42  # assert result == 42"
                tool_call = ("run_eval", {"code": model_proposal})

            # 1. 死循环指纹拦截
            try:
                self.check_loop_safety(tool_call[0], tool_call[1])
            except LoopBreakerException as e:
                print(f"[熔断拦截]: {e}")
                return {"status": "FAILED", "reason": "LOOP_DETECTED"}

            # 2. 外部确定性验证驱动退出
            passed, feedback = self.external_verify(tool_call[1]["code"])
            
            if passed:
                print(f"[外部验证通过]: 业务断言成功，允许收敛。")
                return {"status": "SUCCESS", "step": current_step, "solution": model_proposal}
            else:
                print(f"[外部验证驳回]: {feedback}")
                # 将真实的验证器错误写入上下文，驱动下一轮自我修复
                messages.append({
                    "role": "system",
                    "content": f"外部验证失败反馈:\n{feedback}\n请根据上述断言失败信息调整代码方案。"
                })

        return {"status": "FAILED", "reason": "STEP_BUDGET_EXCEEDED"}

if __name__ == "__main__":
    engine = AgentLoopEngine()
    result = engine.run("编写求解核心指标的算法函数并确保满足断言")
    print(f"\n最终执行状态: {result}")