"""
ReAct智能体实现：Thought → Action → Observation → ...
- 搜索工具
- 计算工具
- 文件读取工具
- 智能体核心逻辑
"""
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from enum import Enum
import json
import math
import re

class ActionType(Enum):
    SEARCH = "search"
    CALCULATE = "calculate"
    READ_FILE = "read_file"
    LIST_FILES = "list_files"
    FINISH = "finish"

@dataclass
class Action:
    type: ActionType
    input: str

@dataclass
class Step:
    thought: str
    action: Optional[Action]
    observation: str

class Tool:
    """工具基类"""
    
    @property
    def name(self) -> str:
        raise NotImplementedError
    
    @property
    def description(self) -> str:
        raise NotImplementedError
    
    def execute(self, input: str) -> str:
        raise NotImplementedError

class SearchTool(Tool):
    """搜索工具（模拟）"""
    
    @property
    def name(self) -> str:
        return "search"
    
    @property
    def description(self) -> str:
        return "搜索网络信息，返回相关结果"
    
    def execute(self, query: str) -> str:
        # 模拟搜索结果
        knowledge_base = {
            "人工智能": "AI是 Artificial Intelligence 的缩写，研究让机器具有智能的科学。",
            "机器学习": "Machine Learning，让计算机从数据中学习规律的技术。",
            "深度学习": "Deep Learning，使用多层神经网络的机器学习方法。",
            "python": "Python是一种流行的编程语言，适合AI开发。",
            "langchain": "LangChain是一个LLM应用开发框架。"
        }
        
        for key, value in knowledge_base.items():
            if key in query.lower():
                return value
        return f"关于'{query}'的搜索结果：这是一条模拟的搜索结果。"

class CalculatorTool(Tool):
    """计算工具"""
    
    @property
    def name(self) -> str:
        return "calculate"
    
    @property
    def description(self) -> str:
        return "执行数学计算，支持四则运算和函数"
    
    def execute(self, expression: str) -> str:
        try:
            # 安全计算
            allowed_chars = set("0123456789+-*/(). ")
            if not all(c in allowed_chars for c in expression):
                return "错误：包含不允许的字符"
            
            result = eval(expression)
            return f"计算结果: {result}"
        except Exception as e:
            return f"计算错误: {e}"

class FileTool(Tool):
    """文件操作工具"""
    
    def __init__(self):
        self.files = {
            "readme.txt": "这是一个示例文件。\n包含多行文本。",
            "notes.txt": "待办事项：\n1. 学习AI\n2. 实践项目"
        }
    
    @property
    def name(self) -> str:
        return "read_file"
    
    @property
    def description(self) -> str:
        return "读取文件内容"
    
    def execute(self, filename: str) -> str:
        if filename in self.files:
            return self.files[filename]
        return f"文件不存在: {filename}"

class ListFilesTool(Tool):
    """列出文件工具"""
    
    @property
    def name(self) -> str:
        return "list_files"
    
    @property
    def description(self) -> str:
        return "列出可用文件"
    
    def execute(self, input: str) -> str:
        return "可用文件: readme.txt, notes.txt"

class ReActAgent:
    """ReAct智能体 - Reasoning + Acting"""
    
    def __init__(self, tools: List[Tool], max_steps: int = 10):
        self.tools = {tool.name: tool for tool in tools}
        self.max_steps = max_steps
        self.history: List[Step] = []
    
    def think(self, query: str) -> str:
        """生成思考（使用LLM时这里是LLM调用）"""
        # 简化版：基于规则生成思考
        history_text = "\n".join([
            f"思考: {step.thought}\n行动: {step.action}\n观察: {step.observation}"
            for step in self.history[-3:]
        ]) if self.history else "无历史"
        
        prompt = f"""你是一个ReAct智能体，需要通过思考和行动来回答问题。

任务：{query}

历史：
{history_text}

请按照以下格式思考下一步：
Thought: [分析当前情况，决定下一步行动]
Action: [工具名称]([参数]) 或 Finish([最终答案])

可用的工具：
{self._format_tools()}"""

        # 这里简化处理，实际应调用LLM
        return self._simple_reasoning(query)
    
    def _simple_reasoning(self, query: str) -> str:
        """简化推理逻辑（实际使用LLM）"""
        query_lower = query.lower()
        
        # 检查是否需要搜索
        if any(kw in query_lower for kw in ["什么", "定义", "解释", "介绍"]):
            if "计算" in query or any(op in query for op in ["+", "-", "*", "/", "×", "÷"]):
                return "我需要先提取表达式，然后使用计算工具。"
            return "我需要搜索相关信息来回答这个问题。"
        
        # 检查是否需要文件
        if any(kw in query_lower for kw in ["文件", "内容", "read"]):
            return "我需要读取文件来获取信息。"
        
        # 检查是否完成
        if any(kw in query_lower for kw in ["谢谢", "好的", "明白了"]):
            return "Finish(任务完成)"
        
        return "我需要搜索更多信息来回答这个问题。"
    
    def _format_tools(self) -> str:
        return "\n".join([f"- {t.name}: {t.description}" for t in self.tools.values()])
    
    def parse_action(self, thought: str) -> Tuple[Optional[Action], str]:
        """解析行动"""
        # 检查是否结束
        if "Finish(" in thought:
            answer = re.search(r'Finish\((.+?)\)', thought)
            return Action(ActionType.FINISH, answer.group(1) if answer else ""), "finished"
        
        # 解析行动
        for tool_name in self.tools:
            if f"{tool_name}(" in thought:
                param = re.search(rf'{tool_name}\((.+?)\)', thought)
                return Action(ActionType(tool_name), param.group(1) if param else ""), tool_name
        
        return None, "continue"
    
    def run(self, query: str) -> str:
        """执行ReAct循环"""
        self.history = []
        current_query = query
        
        for step_num in range(self.max_steps):
            print(f"\n🔄 步骤 {step_num + 1}")
            
            # 1. Thought
            thought = self.think(current_query)
            print(f"💭 Thought: {thought}")
            
            # 2. Parse Action
            action, status = self.parse_action(thought)
            observation = ""
            
            # 3. Action & Observation
            if action and action.type != ActionType.FINISH:
                print(f"⚡ Action: {action.type.value}[{action.input}]")
                
                tool = self.tools.get(action.type.value)
                if tool:
                    observation = tool.execute(action.input)
                else:
                    observation = "未知工具"
                
                print(f"👀 Observation: {observation}")
            elif status == "finished":
                print(f"✅ 完成: {action.input}")
                return action.input
            
            # 4. 记录步骤
            self.history.append(Step(thought, action, observation))
            
            # 5. 更新查询（包含观察结果）
            current_query = f"基于观察：{observation}\n继续回答：{query}"
        
        return "达到最大步数限制"


# 使用示例
def main():
    # 1. 创建工具
    tools = [
        SearchTool(),
        CalculatorTool(),
        FileTool(),
        ListFilesTool()
    ]
    
    # 2. 创建智能体
    agent = ReActAgent(tools, max_steps=6)
    
    # 3. 测试不同任务
    test_queries = [
        "什么是人工智能？",
        "计算 25 * 4 + 10",
        "readme.txt的内容是什么？"
    ]
    
    for query in test_queries:
        print(f"\n{'='*50}")
        print(f"📝 任务: {query}")
        print("="*50)
        result = agent.run(query)
        print(f"\n🎯 最终答案: {result}")

main()