# 安装依赖
!pip install -q hello-agents[all]

# 导入必要的库
from hello_agents import SimpleAgent, HelloAgentsLLM
from hello_agents.tools import Tool, ToolParameter
from hello_agents.tools.builtin.search_tool import SearchTool
from typing import Dict, Any, List
import os
os.environ['HTTPS_PROXY'] = 'http://127.0.0.1:8800'  # 你的代理地址
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# 版本: v2.0 - 2026-04-09
# 更新说明: DataProcessorTool 和 ReportGeneratorTool 现在真正处理数据，不再返回固定字符串

class CompetitiveInfoSearchTool(Tool):
    """竞品信息搜索工具 - 使用真实搜索API"""
    
    def __init__(self):
        super().__init__(
            name="competitive_info_search",
            description="搜索指定竞品的产品信息、功能特性、定价策略等"
        )
        # 初始化内置搜索工具，使用 Tavily 后端
        self.search = SearchTool(backend="tavily")
    
    def get_parameters(self) -> List[ToolParameter]:
        """获取工具参数定义"""
        return [
            ToolParameter(
                name="product_name",
                type="string",
                description="要搜索的竞品名称",
                required=True
            )
        ]
    
    def run(self, parameters: Dict[str, Any]) -> str:
        """执行工具，使用真实搜索"""
        product_name = parameters.get("product_name", "")
        print(f"🔍 正在搜索 {product_name} 的竞品信息...")
        
        # 使用真实搜索API
        try:
            search_query = f"{product_name} 产品功能介绍 定价 优缺点 2024"
            result = self.search.run({
                "query": search_query,
                "max_results": 5
            })
            
            # 格式化搜索结果
            return f"""
【{product_name} 搜索结果】
{result}
"""
        except Exception as e:
            print(f"⚠️ 搜索失败: {e}，使用备用数据")
            # 如果搜索失败，返回提示信息
            return f"""
【{product_name} 信息】
- 搜索遇到问题，请检查网络或API配置
- 产品名称: {product_name}
- 建议手动补充信息
"""


class DataProcessorTool(Tool):
    """
    数据处理工具 v2.0 - 真正解析搜索返回的文本，提取结构化信息
    
    更新日志:
    - v2.0 (2026-04-09): 实现真正的数据解析，使用正则提取关键信息
    - v1.0: 返回固定字符串（PoC阶段）
    """
    
    def __init__(self):
        super().__init__(
            name="data_processor",
            description="将原始竞品数据清洗并构建对比矩阵，提取结构化信息"
        )
    
    def get_parameters(self) -> List[ToolParameter]:
        """获取工具参数定义"""
        return [
            ToolParameter(
                name="raw_data",
                type="string",
                description="原始收集的竞品数据（搜索返回的文本）",
                required=True
            )
        ]
    
    def run(self, parameters: Dict[str, Any]) -> str:
        """
        执行数据处理 - 真正解析搜索文本，提取结构化信息
        
        提取字段:
        - 产品名称
        - 产品定位
        - 核心功能 (列表)
        - 定价策略
        - 主要优势
        - 主要劣势
        """
        import json
        import re
        
        raw_data = parameters.get("raw_data", "")
        print("📊 正在解析并结构化数据...")
        
        # 初始化结构化数据结构
        structured_data = {
            "产品名称": "",
            "产品定位": "",
            "核心功能": [],
            "定价策略": "",
            "主要优势": "",
            "主要劣势": "",
            "原始摘要": raw_data[:500] + "..." if len(raw_data) > 500 else raw_data
        }
        
        # 提取产品名称（从标题中提取）
        name_match = re.search(r'【(.+?) 搜索', raw_data)
        if name_match:
            structured_data["产品名称"] = name_match.group(1)
        
        # 提取产品定位（查找包含"定位"、"是"等关键词的句子）
        position_patterns = [
            r'(?:是|作为|定位为)[一个款]*(\S{2,20}?)(?:工具|软件|平台|应用)',
            r'(?:用于|专为)(.+?)(?:设计|打造|提供)',
        ]
        for pattern in position_patterns:
            match = re.search(pattern, raw_data)
            if match:
                structured_data["产品定位"] = match.group(1).strip()
                break
        
        # 提取核心功能（查找列表、逗号分隔的功能描述）
        function_patterns = [
            r'功能[:：](.+?)(?:\n|定价|价格|$)',
            r'支持(.+?)(?:等功能|等特性)',
            r'(?:包括|包含)(.+?)(?:等功能)',
        ]
        for pattern in function_patterns:
            match = re.search(pattern, raw_data)
            if match:
                functions_text = match.group(1)
                # 分割功能列表
                functions = [f.strip() for f in re.split(r'[,，、\/]', functions_text) if len(f.strip()) > 1 and len(f.strip()) < 20]
                structured_data["核心功能"] = functions[:6]  # 最多取6个
                break
        
        # 提取定价策略
        price_patterns = [
            r'(?:定价|价格|费用)[:：](.+?)(?:\n|元|\$|USD)',
            r'(免费|付费|订阅|一次性购买)',
            r'(\d+\.?\d*\s*(?:元|\$|USD|美元)/(?:月|年|用户))',
        ]
        for pattern in price_patterns:
            match = re.search(pattern, raw_data, re.IGNORECASE)
            if match:
                structured_data["定价策略"] = match.group(1).strip()
                break
        
        # 提取优势和劣势（查找包含"优势"、"优点"、"缺点"、"不足"等的句子）
        advantage_patterns = [
            r'(?:优势|优点|特色)[:：](.+?)(?:\n|劣势|缺点|不足|$)',
        ]
        for pattern in advantage_patterns:
            match = re.search(pattern, raw_data)
            if match:
                structured_data["主要优势"] = match.group(1).strip()[:100]
                break
        
        disadvantage_patterns = [
            r'(?:劣势|缺点|不足|局限)[:：](.+?)(?:\n|优势|总结|$)',
        ]
        for pattern in disadvantage_patterns:
            match = re.search(pattern, raw_data)
            if match:
                structured_data["主要劣势"] = match.group(1).strip()[:100]
                break
        
        # 如果没有提取到，从文本中智能推断
        if not structured_data["主要优势"] and "优势" in raw_data:
            # 查找"优势"后面的一句话
            match = re.search(r'优势[是为:]+(.+?)[。\.\n]', raw_data)
            if match:
                structured_data["主要优势"] = match.group(1).strip()[:100]
        
        if not structured_data["主要劣势"] and ("劣势" in raw_data or "缺点" in raw_data):
            match = re.search(r'(?:劣势|缺点)[是为:]+(.+?)[。\.\n]', raw_data)
            if match:
                structured_data["主要劣势"] = match.group(1).strip()[:100]
        
        print(f"✅ 结构化完成: {structured_data['产品名称'] or '未知产品'}")
        print(f"   - 提取功能: {len(structured_data['核心功能'])} 项")
        
        # 返回 JSON 格式的结构化数据
        return json.dumps(structured_data, ensure_ascii=False, indent=2)


class ReportGeneratorTool(Tool):
    """
    报告生成工具 v2.0 - 基于结构化数据生成报告
    
    更新日志:
    - v2.0 (2026-04-09): 基于真实结构化数据生成报告，支持多产品对比
    - v1.0: 返回固定字符串（PoC阶段）
    """
    
    def __init__(self):
        super().__init__(
            name="report_generator",
            description="基于结构化竞品数据生成专业的Markdown格式分析报告"
        )
    
    def get_parameters(self) -> List[ToolParameter]:
        """获取工具参数定义"""
        return [
            ToolParameter(
                name="analysis_data",
                type="string",
                description="结构化后的竞品数据（JSON格式）",
                required=True
            )
        ]
    
    def run(self, parameters: Dict[str, Any]) -> str:
        """
        基于结构化数据生成专业的竞品分析报告
        
        支持:
        - 单个产品详情报告
        - 多个产品对比报告
        """
        import json
        
        analysis_data = parameters.get("analysis_data", "")
        print("📝 正在基于结构化数据生成报告...")
        
        # 解析输入数据（支持多个产品的JSON数组或单个产品）
        try:
            # 尝试解析为JSON
            if isinstance(analysis_data, str):
                data = json.loads(analysis_data)
            else:
                data = analysis_data
            
            # 如果是单个产品，转换为列表
            if isinstance(data, dict):
                products = [data]
            elif isinstance(data, list):
                products = data
            else:
                products = []
        except json.JSONDecodeError:
            # 如果不是JSON，当作原始文本处理
            print("⚠️  输入数据不是JSON格式，生成简化报告")
            return self._generate_simple_report(analysis_data)
        
        if not products:
            return "# 竞品分析报告\n\n暂无有效数据。"
        
        # 生成完整的对比报告
        report_lines = []
        report_lines.append("# 竞品分析报告")
        report_lines.append("")
        report_lines.append("## 一、执行摘要")
        report_lines.append("")
        report_lines.append(f"本次分析共涉及 **{len(products)}** 款产品，")
        product_names = [p.get('产品名称', '未知') for p in products if p.get('产品名称')]
        if product_names:
            report_lines.append(f"包括：{', '.join(product_names)}。")
        report_lines.append("")
        report_lines.append("---")
        report_lines.append("")
        
        # 二、产品详情
        report_lines.append("## 二、产品详情")
        report_lines.append("")
        
        for i, product in enumerate(products, 1):
            name = product.get('产品名称', f'产品{i}')
            report_lines.append(f"### {i}. {name}")
            report_lines.append("")
            
            if product.get('产品定位'):
                report_lines.append(f"**产品定位**: {product['产品定位']}")
                report_lines.append("")
            
            if product.get('核心功能'):
                report_lines.append("**核心功能**:")
                for func in product['核心功能']:
                    report_lines.append(f"- {func}")
                report_lines.append("")
            
            if product.get('定价策略'):
                report_lines.append(f"**定价策略**: {product['定价策略']}")
                report_lines.append("")
            
            if product.get('主要优势'):
                report_lines.append(f"**主要优势**: {product['主要优势']}")
                report_lines.append("")
            
            if product.get('主要劣势'):
                report_lines.append(f"**主要劣势**: {product['主要劣势']}")
                report_lines.append("")
        
        # 三、对比矩阵（仅当有多个产品时）
        if len(products) > 1:
            report_lines.append("---")
            report_lines.append("")
            report_lines.append("## 三、对比矩阵")
            report_lines.append("")
            report_lines.append("| 维度 | " + " | ".join([p.get('产品名称', f'产品{i}') for i, p in enumerate(products, 1)]) + " |")
            report_lines.append("|------|" + "|".join(["------"] * len(products)) + "|")
            
            # 产品定位对比
            positions = [p.get('产品定位', '-')[:20] for p in products]
            report_lines.append("| 定位 | " + " | ".join(positions) + " |")
            
            # 定价对比
            prices = [p.get('定价策略', '-')[:15] for p in products]
            report_lines.append("| 定价 | " + " | ".join(prices) + " |")
            
            # 功能数量对比
            func_counts = [str(len(p.get('核心功能', []))) + " 项" for p in products]
            report_lines.append("| 功能数 | " + " | ".join(func_counts) + " |")
            report_lines.append("")
        
        # 四、总结与建议
        report_lines.append("---")
        report_lines.append("")
        report_lines.append("## 四、总结与建议")
        report_lines.append("")
        report_lines.append("基于以上分析，建议：")
        report_lines.append("")
        
        # 生成简单建议
        if len(products) == 1:
            report_lines.append(f"- {products[0].get('产品名称', '该产品')}适合需要{products[0].get('产品定位', '相关功能')}的用户")
        else:
            # 找出功能最多的
            max_func_product = max(products, key=lambda x: len(x.get('核心功能', [])))
            report_lines.append(f"- **功能最丰富**: {max_func_product.get('产品名称')}，提供 {len(max_func_product.get('核心功能', []))} 项核心功能")
            
            # 找出免费/开源的
            free_products = [p for p in products if '免费' in p.get('定价策略', '') or '开源' in p.get('定价策略', '')]
            if free_products:
                report_lines.append(f"- **预算有限首选**: {', '.join([p.get('产品名称') for p in free_products])}")
        
        report_lines.append("")
        report_lines.append("---")
        report_lines.append("")
        report_lines.append("*报告生成时间: 基于真实结构化数据*")
        
        return "\n".join(report_lines)
    
    def _generate_simple_report(self, raw_text: str) -> str:
        """当无法解析JSON时，生成简化报告"""
        return f"""# 竞品分析报告

## 执行摘要

基于收集的原始数据生成报告。

## 原始数据摘要

{raw_text[:800]}...

---

*注: 数据解析遇到问题，以上为原始数据摘要。*
"""


print("✅ 三个核心工具已定义完成（v2.0 - 真正数据处理）")
print("   1. CompetitiveInfoSearchTool - 竞品信息搜索（真实API）")
print("   2. DataProcessorTool - 数据处理（真正解析结构化）✨ v2.0")
print("   3. ReportGeneratorTool - 报告生成（基于结构化数据）✨ v2.0")

# 创建LLM
llm = HelloAgentsLLM()

# 定义系统提示词 - Plan-and-Solve 范式
SYSTEM_PROMPT = """你是一位专业的竞品分析专家，擅长通过系统化的方法对多个竞品进行深度分析。

【Plan-and-Solve 工作范式】

你的任务执行流程：
1. 首先分析用户需求，提取需要对比的竞品名称
2. 制定详细的分析计划，将任务分解为可执行的步骤
3. 按计划逐步执行，收集每个竞品的信息
4. 对收集的数据进行处理和结构化
5. 生成完整的竞品对比分析报告

【分析维度要求】
- 产品定位与目标用户
- 核心功能对比
- 定价策略分析
- 优势与劣势(SWOT)
- 战略建议

【输出要求】
- 报告必须结构化、专业
- 对比必须基于实际数据
- 建议必须具体可行"""

# 定义 Plan-and-Solve 自定义提示词模板
CUSTOM_PROMPTS = {
    "planner": """
你是一位顶级的AI规划专家。你的任务是将竞品分析需求分解成一个由多个简单步骤组成的行动计划。

请确保计划中的每个步骤都是一个独立的、可执行的子任务，并且严格按照逻辑顺序排列。

对于竞品分析任务，典型的计划步骤包括：
1. 提取并确认需要分析的竞品名称
2. 搜索第一个竞品的基本信息
3. 搜索第二个竞品的基本信息
4. （如有更多竞品继续搜索）
5. 整理并对比各竞品的核心特性
6. 生成SWOT分析
7. 输出完整的竞品分析报告

问题: {question}

请严格按照以下格式输出你的计划:
```python
["步骤1", "步骤2", "步骤3", ...]

# 第5部分: 功能演示

```python
# 示例1: 基础竞品分析
import time
from datetime import datetime

print("="*70)
print("📊 示例1: Plan-and-Solve 竞品深度分析")
print("="*70)

target_products = ["盒马", "叮咚买菜", "盒马会员商店"]
print(f"\n🎯 分析目标: {', '.join(target_products)}")
print(f"⏰ 开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print("-"*70)

# 执行分析
start_time = time.time()
result = agent.run(
    f"请对以下竞品进行深度对比分析: {', '.join(target_products)}。"
)
elapsed_time = time.time() - start_time

# 美观的输出排版
print("\n" + "="*70)
print("📋 分析完成")
print("="*70)
print(f"⏱️  总耗时: {elapsed_time:.2f} 秒")
print(f"📝 报告长度: {len(result)} 字符")
print("-"*70)

# 显示报告摘要
print("\n📄 报告预览（前1000字符）:")
print("-"*70)
print(result[:1000] + "..." if len(result) > 1000 else result)
print("-"*70)

# 保存结果到文件
output_filename = f"outputs/demo_result_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
with open(output_filename, 'w', encoding='utf-8') as f:
    f.write(f"# 竞品分析报告\n\n")
    f.write(f"**分析时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
    f.write(f"**分析产品**: {', '.join(target_products)}\n\n")
    f.write(f"**分析耗时**: {elapsed_time:.2f} 秒\n\n")
    f.write("---\n\n")
    f.write(result)

print(f"\n💾 报告已保存至: {output_filename}")
print("="*70)

用户输入 → 制定计划 → 搜索工具(原始文本) → 数据处理工具(JSON结构化) → 报告生成工具(Markdown报告) → 输出结果