import asyncio
import json
import os
import sys
import argparse
from datetime import datetime

from agents import Agent, Runner
from lib.my_trace import set_trace
from typing import Literal
from pydantic import BaseModel, Field

from lib.utils import read_file_as_string
from lib.client import get_model
MODEL_NAME = "google/gemini-2.5-flash"
from script.search_recommendations.xiaohongshu_search_recommendations import XiaohongshuSearchRecommendations
from script.search.xiaohongshu_search import XiaohongshuSearch


class RunContext(BaseModel):
    version: str = Field(..., description="当前运行的脚本版本（文件名）")
    input_files: dict[str, str] = Field(..., description="输入文件路径映射")
    q_with_context: str
    q_context: str
    q: str
    log_url: str
    log_dir: str

    # 步骤化日志
    steps: list[dict] = Field(default_factory=list, description="执行步骤的详细记录")

    # 探索阶段记录（保留用于向后兼容）
    keywords: list[str] | None = Field(default=None, description="提取的关键词")
    exploration_levels: list[dict] = Field(default_factory=list, description="每一层的探索结果")
    level_analyses: list[dict] = Field(default_factory=list, description="每一层的主Agent分析")

    # 最终结果
    final_candidates: list[str] | None = Field(default=None, description="最终选出的候选query")
    evaluation_results: list[dict] | None = Field(default=None, description="候选query的评估结果")
    optimization_result: dict | None = Field(default=None, description="最终优化结果对象")
    final_output: str | None = Field(default=None, description="最终输出结果（格式化文本）")


# ============================================================================
# Agent 1: 关键词提取专家
# ============================================================================
keyword_extraction_instructions = """
你是关键词提取专家。给定一个搜索问题（含上下文），提取出**最细粒度的关键概念**。

## 提取原则

1. **细粒度优先**：拆分成最小的有意义单元
   - 不要保留完整的长句
   - 拆分成独立的、有搜索意义的词或短语

2. **保留核心维度**：
   - 地域/对象
   - 时间
   - 行为/意图：获取、教程、推荐、如何等
   - 主题/领域
   - 质量/属性

3. **去掉无意义的虚词**：的、吗、呢等

4. **保留领域专有词**：不要过度拆分专业术语
   - 如果是常见的组合词，保持完整

## 输出要求

输出关键词列表，按重要性排序（最核心的在前）。
""".strip()

class KeywordList(BaseModel):
    """关键词列表"""
    keywords: list[str] = Field(..., description="提取的关键词，按重要性排序")
    reasoning: str = Field(..., description="提取理由")

keyword_extractor = Agent[None](
    name="关键词提取专家",
    instructions=keyword_extraction_instructions,
    model=get_model(MODEL_NAME),
    output_type=KeywordList,
)


# ============================================================================
# Agent 2: 层级探索分析专家
# ============================================================================
level_analysis_instructions = """
你是搜索空间探索分析专家。基于当前层级的探索结果，决定下一步行动。

## 你的任务

分析当前已探索的词汇空间，判断：
1. **发现了什么有价值的信号？**
2. **是否已经可以评估候选了？**
3. **如果还不够，下一层应该探索什么组合？**

## 分析维度

### 1. 信号识别（最重要）

看推荐词里**出现了什么主题**：

**关键问题：**
- 哪些推荐词**最接近原始需求**？
- 哪些推荐词**揭示了有价值的方向**（即使不完全匹配）？
- 哪些推荐词可以作为**下一层探索的桥梁**？
- 系统对哪些概念理解得好？哪些理解偏了？

### 2. 组合策略

基于发现的信号，设计下一层探索：

**组合类型：**

a) **关键词直接组合**
   - 两个关键词组合成新query

b) **利用推荐词作为桥梁**（重要！）
   - 发现某个推荐词很有价值 → 直接探索这个推荐词
   - 或在推荐词基础上加其他关键词

c) **跨层级组合**
   - 结合多层发现的有价值推荐词
   - 组合成更复杂的query

### 3. 停止条件

**何时可以评估候选？**

满足以下之一：
- 推荐词中出现了**明确包含原始需求多个核心要素的query**
- 已经探索到**足够复杂的组合**（3-4个关键词），且推荐词相关
- 探索了**3-4层**，信息已经足够丰富

**何时继续探索？**
- 当前推荐词太泛，没有接近原始需求
- 发现了有价值的信号，但需要进一步组合验证
- 层数还少（< 3层）

## 输出要求

### 1. key_findings
总结当前层发现的关键信息，包括：
- 哪些推荐词最有价值？
- 系统对哪些概念理解得好/不好？
- 发现了什么意外的方向？

### 2. promising_signals
列出最有价值的推荐词（来自任何已探索的query），每个说明为什么有价值

### 3. should_evaluate_now
是否已经可以开始评估候选了？true/false

### 4. candidates_to_evaluate
如果should_evaluate_now=true，列出应该评估的候选query
- 可以是推荐词
- 可以是自己构造的组合

### 5. next_combinations
如果should_evaluate_now=false，列出下一层应该探索的query组合

### 6. reasoning
详细的推理过程

## 重要原则

1. **不要过早评估**：至少探索2层，除非第一层就发现了完美匹配
2. **充分利用推荐词**：推荐词是系统给的提示，要善用
3. **保持探索方向的多样性**：不要只盯着一个方向
4. **识别死胡同**：如果某个方向的推荐词一直不相关，果断放弃
""".strip()

class PromisingSignal(BaseModel):
    """有价值的推荐词信号"""
    query: str = Field(..., description="推荐词")
    from_level: int = Field(..., description="来自哪一层")
    reason: str = Field(..., description="为什么有价值")

class LevelAnalysis(BaseModel):
    """层级分析结果"""
    key_findings: str = Field(..., description="当前层的关键发现")
    promising_signals: list[PromisingSignal] = Field(..., description="有价值的推荐词信号")
    should_evaluate_now: bool = Field(..., description="是否应该开始评估候选")
    candidates_to_evaluate: list[str] = Field(default_factory=list, description="如果should_evaluate_now=true，要评估的候选query列表")
    next_combinations: list[str] = Field(default_factory=list, description="如果should_evaluate_now=false，下一层要探索的query组合")
    reasoning: str = Field(..., description="详细的推理过程")

level_analyzer = Agent[None](
    name="层级探索分析专家",
    instructions=level_analysis_instructions,
    model=get_model(MODEL_NAME),
    output_type=LevelAnalysis,
)


# ============================================================================
# Agent 3: 评估专家（简化版：意图匹配 + 相关性评分）
# ============================================================================
eval_instructions = """
你是搜索query评估专家。给定原始问题和推荐query，评估两个维度。

## 评估目标

用这个推荐query搜索，能否找到满足原始需求的内容？

## 两层评分

### 1. intent_match（意图匹配）= true/false

推荐query的**使用意图**是否与原问题一致？

**核心问题：用户搜索这个推荐词，想做什么？**

**判断标准：**
- 原问题意图：找方法？找教程？找资源/素材？找工具？看作品？
- 推荐词意图：如果用户搜索这个词，他的目的是什么？

**示例：**
- 原问题意图="找素材"
  - ✅ true: "素材下载"、"素材网站"、"免费素材"（都是获取素材）
  - ❌ false: "素材制作教程"、"如何制作素材"（意图变成学习了）

- 原问题意图="学教程"
  - ✅ true: "教程视频"、"教学步骤"、"入门指南"
  - ❌ false: "成品展示"、"作品欣赏"（意图变成看作品了）

**评分：**
- true = 意图一致，搜索推荐词能达到原问题的目的
- false = 意图改变，搜索推荐词无法达到原问题的目的

### 2. relevance_score（相关性）= 0-1 连续分数

推荐query在**主题、要素、属性**上与原问题的相关程度？

**评估维度：**
- 主题相关：核心主题是否匹配？（如：摄影、旅游、美食）
- 要素覆盖：关键要素保留了多少？（如：地域、时间、对象、工具）
- 属性匹配：质量、风格、特色等属性是否保留？

**评分参考：**
- 0.9-1.0 = 几乎完美匹配，所有核心要素都保留
- 0.7-0.8 = 高度相关，核心要素保留，少数次要要素缺失
- 0.5-0.6 = 中度相关，主题匹配但多个要素缺失
- 0.3-0.4 = 低度相关，只有部分主题相关
- 0-0.2 = 基本不相关

## 评估策略

1. **先判断 intent_match**：意图不匹配直接 false，无论相关性多高
2. **再评估 relevance_score**：在意图匹配的前提下，计算相关性

## 输出要求

- intent_match: true/false
- relevance_score: 0-1 的浮点数
- reason: 详细的评估理由，需要说明：
  - 原问题的意图是什么
  - 推荐词的意图是什么
  - 为什么判断意图匹配/不匹配
  - 相关性分数的依据（哪些要素保留/缺失）
""".strip()

class RelevanceEvaluation(BaseModel):
    """评估反馈模型 - 意图匹配 + 相关性"""
    intent_match: bool = Field(..., description="意图是否匹配")
    relevance_score: float = Field(..., description="相关性分数 0-1，分数越高越相关")
    reason: str = Field(..., description="评估理由，需说明意图判断和相关性依据")

evaluator = Agent[None](
    name="评估专家",
    instructions=eval_instructions,
    model=get_model(MODEL_NAME),
    output_type=RelevanceEvaluation,
)


# ============================================================================
# Agent 4: 单个帖子需求满足度评估专家
# ============================================================================
note_evaluation_instructions = """
你是帖子需求满足度评估专家。给定原始问题和一个搜索到的帖子（标题+描述），判断这个帖子能否满足用户的需求。

## 你的任务

评估单个帖子的标题和描述，判断用户点开这个帖子后，能否找到满足原始需求的内容。

## 评估维度

### 1. 标题相关性（title_relevance）= 0-1 连续分数

**评估标准：**
- 标题是否与原始问题的主题相关？
- 标题是否包含原始问题的关键要素？
- 标题是否表明内容能解决用户的问题？

**评分参考：**
- 0.9-1.0 = 标题高度相关，明确表明能解决问题
- 0.7-0.8 = 标题相关，包含核心要素
- 0.5-0.6 = 标题部分相关，有关联但不明确
- 0.3-0.4 = 标题相关性较低
- 0-0.2 = 标题基本不相关

### 2. 内容预期（content_expectation）= 0-1 连续分数

**评估标准：**
- 从描述看，内容是否可能包含用户需要的信息？
- 描述是否展示了相关的要素或细节？
- 描述的方向是否与用户需求一致？

**评分参考：**
- 0.9-1.0 = 描述明确表明内容高度符合需求
- 0.7-0.8 = 描述显示内容可能符合需求
- 0.5-0.6 = 描述有一定相关性，但不确定
- 0.3-0.4 = 描述相关性较低
- 0-0.2 = 描述基本不相关

### 3. 需求满足度（need_satisfaction）= true/false

**核心问题：用户点开这个帖子后，能否找到他需要的内容？**

**判断标准：**
- 综合标题和描述，内容是否大概率能满足需求？
- 如果 title_relevance >= 0.7 且 content_expectation >= 0.6，一般判断为 true
- 否则判断为 false

### 4. 综合置信度（confidence_score）= 0-1 连续分数

**计算方式：**
- 可以是 title_relevance 和 content_expectation 的加权平均
- 标题权重通常更高（如 0.6 * title + 0.4 * content）

## 输出要求

- title_relevance: 0-1 的浮点数
- content_expectation: 0-1 的浮点数
- need_satisfaction: true/false
- confidence_score: 0-1 的浮点数
- reason: 详细的评估理由，需要说明：
  - 标题与原问题的相关性分析
  - 描述的内容预期分析
  - 为什么判断能/不能满足需求
  - 置信度分数的依据

## 重要原则

1. **独立评估**：只评估这一个帖子，不考虑其他帖子
2. **用户视角**：问"我会点开这个帖子吗？点开后能找到答案吗？"
3. **标题优先**：标题是用户决定是否点击的关键
4. **保守判断**：不确定时，倾向于给较低的分数
""".strip()

class NoteEvaluation(BaseModel):
    """单个帖子评估模型"""
    title_relevance: float = Field(..., description="标题相关性 0-1")
    content_expectation: float = Field(..., description="内容预期 0-1")
    need_satisfaction: bool = Field(..., description="是否满足需求")
    confidence_score: float = Field(..., description="综合置信度 0-1")
    reason: str = Field(..., description="详细的评估理由")

note_evaluator = Agent[None](
    name="帖子需求满足度评估专家",
    instructions=note_evaluation_instructions,
    model=get_model(MODEL_NAME),
    output_type=NoteEvaluation,
)


# ============================================================================
# Agent 5: 答案生成专家
# ============================================================================
answer_generation_instructions = """
你是答案生成专家。基于一组满足需求的帖子，为原始问题生成一个全面、准确、有价值的答案。

## 你的任务

根据用户的原始问题和一组相关帖子（包含标题、描述、置信度评分），生成一个高质量的答案。

## 输入信息

1. **原始问题**：用户提出的具体问题
2. **相关帖子列表**：每个帖子包含
   - 序号（索引）
   - 标题
   - 描述
   - 置信度分数

## 答案要求

### 1. 内容要求

- **直接回答问题**：开门见山，第一段就给出核心答案
- **结构清晰**：使用标题、列表、分段等组织内容
- **综合多个来源**：整合多个帖子的信息，不要只依赖一个
- **信息准确**：基于帖子内容，不要编造信息
- **实用性**：提供可操作的建议或具体的信息

### 2. 引用规范

- **必须标注来源**：每个关键信息都要标注帖子索引
- **引用格式**：使用 `[1]`、`[2]` 等标注帖子序号
- **多来源引用**：如果多个帖子支持同一观点，使用 `[1,2,3]`
- **引用位置**：在相关句子或段落的末尾标注

### 3. 置信度使用

- **优先高置信度**：优先引用置信度高的帖子
- **交叉验证**：如果多个帖子提到相同信息，可以提高可信度
- **标注不确定性**：如果信息来自低置信度帖子，适当标注

### 4. 答案结构建议

```
【核心答案】
直接回答用户的问题，给出最核心的信息。[引用]

【详细说明】
1. 第一个方面/要点 [引用]
   - 具体内容
   - 相关细节

2. 第二个方面/要点 [引用]
   - 具体内容
   - 相关细节

【补充建议/注意事项】（可选）
其他有价值的信息或提醒。[引用]

【参考帖子】
列出所有引用的帖子编号和标题。
```

## 输出格式

{
  "answer": "生成的答案内容（Markdown格式）",
  "cited_note_indices": [1, 2, 3],  # 引用的帖子序号列表
  "confidence": 0.85,  # 答案的整体置信度 (0-1)
  "summary": "一句话总结答案的核心内容"
}

## 重要原则

1. **忠于原文**：不要添加帖子中没有的信息
2. **引用透明**：让用户知道每个信息来自哪个帖子
3. **综合性**：尽可能整合多个帖子的信息
4. **可读性**：使用清晰的Markdown格式
5. **质量优先**：如果帖子质量不够，可以说明信息有限
""".strip()

class AnswerGeneration(BaseModel):
    """答案生成模型"""
    answer: str = Field(..., description="生成的答案内容（Markdown格式）")
    cited_note_indices: list[int] = Field(..., description="引用的帖子序号列表")
    confidence: float = Field(..., description="答案的整体置信度 0-1")
    summary: str = Field(..., description="一句话总结答案的核心内容")

answer_generator = Agent[None](
    name="答案生成专家",
    instructions=answer_generation_instructions,
    model=get_model(MODEL_NAME),
    output_type=AnswerGeneration,
)


# ============================================================================
# 日志辅助函数
# ============================================================================

def add_step(context: RunContext, step_name: str, step_type: str, data: dict):
    """添加步骤记录"""
    step = {
        "step_number": len(context.steps) + 1,
        "step_name": step_name,
        "step_type": step_type,
        "timestamp": datetime.now().isoformat(),
        "data": data
    }
    context.steps.append(step)
    return step


def process_note_data(note: dict) -> dict:
    """
    处理搜索接口返回的帖子数据，标准化为统一格式

    Args:
        note: 搜索接口返回的原始帖子数据

    Returns:
        标准化后的帖子数据字典
    """
    note_card = note.get("note_card", {})
    image_list = note_card.get("image_list", [])  # 已在搜索API层预处理为URL字符串列表
    interact_info = note_card.get("interact_info", {})
    user_info = note_card.get("user", {})

    return {
        "note_id": note.get("id", ""),
        "title": note_card.get("display_title", ""),
        "desc": note_card.get("desc", ""),
        "image_list": image_list,  # 第一张就是封面，已在XiaohongshuSearch.search()中预处理为URL字符串列表
        "interact_info": {
            "liked_count": interact_info.get("liked_count", 0),
            "collected_count": interact_info.get("collected_count", 0),
            "comment_count": interact_info.get("comment_count", 0),
            "shared_count": interact_info.get("shared_count", 0)
        },
        "user": {
            "nickname": user_info.get("nickname", ""),
            "user_id": user_info.get("user_id", "")
        },
        "type": note_card.get("type", "normal"),
        "note_url": f"https://www.xiaohongshu.com/explore/{note.get('id', '')}"
    }


# ============================================================================
# 核心函数
# ============================================================================

async def extract_keywords(q: str, context: RunContext) -> KeywordList:
    """提取关键词"""
    print("\n[步骤 1] 正在提取关键词...")
    result = await Runner.run(keyword_extractor, q)
    keyword_list: KeywordList = result.final_output
    print(f"提取的关键词：{keyword_list.keywords}")
    print(f"提取理由：{keyword_list.reasoning}")

    # 记录步骤
    add_step(context, "提取关键词", "keyword_extraction", {
        "input_question": q,
        "keywords": keyword_list.keywords,
        "reasoning": keyword_list.reasoning
    })

    return keyword_list


async def explore_level(queries: list[str], level_num: int, context: RunContext) -> dict:
    """探索一个层级（并发获取所有query的推荐词）"""
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] Level {level_num} 探索：{len(queries)} 个query")
    print(f"{'='*60}")

    xiaohongshu_api = XiaohongshuSearchRecommendations()

    # 并发获取所有推荐词
    async def get_single_sug(query: str):
        print(f"  探索: {query}")
        suggestions = xiaohongshu_api.get_recommendations(keyword=query)
        print(f"    → {len(suggestions) if suggestions else 0} 个推荐词")
        return {
            "query": query,
            "suggestions": suggestions or []
        }

    results = await asyncio.gather(*[get_single_sug(q) for q in queries])

    level_data = {
        "level": level_num,
        "timestamp": datetime.now().isoformat(),
        "queries": results
    }

    context.exploration_levels.append(level_data)

    # 记录步骤
    add_step(context, f"Level {level_num} 探索", "level_exploration", {
        "level": level_num,
        "input_queries": queries,
        "query_count": len(queries),
        "results": results,
        "total_suggestions": sum(len(r['suggestions']) for r in results)
    })

    return level_data


async def analyze_level(level_data: dict, all_levels: list[dict], original_question: str, context: RunContext) -> LevelAnalysis:
    """分析当前层级，决定下一步"""
    step_num = len(context.steps) + 1
    print(f"\n[步骤 {step_num}] 正在分析 Level {level_data['level']}...")

    # 构造输入
    analysis_input = f"""
<原始问题>
{original_question}
</原始问题>

<已探索的所有层级>
{json.dumps(all_levels, ensure_ascii=False, indent=2)}
</已探索的所有层级>

<当前层级>
Level {level_data['level']}
{json.dumps(level_data['queries'], ensure_ascii=False, indent=2)}
</当前层级>

请分析当前探索状态，决定下一步行动。
"""

    result = await Runner.run(level_analyzer, analysis_input)
    analysis: LevelAnalysis = result.final_output

    print(f"\n分析结果：")
    print(f"  关键发现：{analysis.key_findings}")
    print(f"  有价值的信号：{len(analysis.promising_signals)} 个")
    print(f"  是否评估：{analysis.should_evaluate_now}")

    if analysis.should_evaluate_now:
        print(f"  候选query：{analysis.candidates_to_evaluate}")
    else:
        print(f"  下一层探索：{analysis.next_combinations}")

    # 保存分析结果
    context.level_analyses.append({
        "level": level_data['level'],
        "timestamp": datetime.now().isoformat(),
        "analysis": analysis.model_dump()
    })

    # 记录步骤
    add_step(context, f"Level {level_data['level']} 分析", "level_analysis", {
        "level": level_data['level'],
        "key_findings": analysis.key_findings,
        "promising_signals_count": len(analysis.promising_signals),
        "promising_signals": [s.model_dump() for s in analysis.promising_signals],
        "should_evaluate_now": analysis.should_evaluate_now,
        "candidates_to_evaluate": analysis.candidates_to_evaluate if analysis.should_evaluate_now else [],
        "next_combinations": analysis.next_combinations if not analysis.should_evaluate_now else [],
        "reasoning": analysis.reasoning
    })

    return analysis


async def evaluate_candidates(candidates: list[str], original_question: str, context: RunContext) -> list[dict]:
    """评估候选query（含实际搜索验证）"""
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 评估 {len(candidates)} 个候选query")
    print(f"{'='*60}")

    xiaohongshu_api = XiaohongshuSearchRecommendations()
    xiaohongshu_search = XiaohongshuSearch()

    # 创建搜索结果保存目录
    search_results_dir = os.path.join(context.log_dir, "search_results")
    os.makedirs(search_results_dir, exist_ok=True)

    async def evaluate_single_candidate(candidate: str, candidate_index: int):
        print(f"\n评估候选：{candidate}")

        # 为当前候选创建子目录
        # 清理候选名称，移除不适合作为目录名的字符
        safe_candidate_name = "".join(c if c.isalnum() or c in (' ', '_', '-') else '_' for c in candidate)
        candidate_dir = os.path.join(search_results_dir, f"candidate_{candidate_index+1}_{safe_candidate_name[:50]}")
        os.makedirs(candidate_dir, exist_ok=True)

        # 1. 获取推荐词
        suggestions = xiaohongshu_api.get_recommendations(keyword=candidate)
        print(f"  获取到 {len(suggestions) if suggestions else 0} 个推荐词")

        if not suggestions:
            return {
                "candidate": candidate,
                "suggestions": [],
                "evaluations": []
            }

        # 2. 评估每个推荐词（意图匹配 + 相关性）
        async def eval_single_sug(sug: str, sug_index: int):
            # 2.1 先进行意图和相关性评估
            eval_input = f"""
<原始问题>
{original_question}
</原始问题>

<待评估的推荐query>
{sug}
</待评估的推荐query>

请评估该推荐query：
1. intent_match: 意图是否匹配（true/false）
2. relevance_score: 相关性分数（0-1）
3. reason: 详细的评估理由
"""
            result = await Runner.run(evaluator, eval_input)
            evaluation: RelevanceEvaluation = result.final_output

            eval_result = {
                "query": sug,
                "intent_match": evaluation.intent_match,
                "relevance_score": evaluation.relevance_score,
                "reason": evaluation.reason,
            }

            # 2.2 如果意图匹配且相关性足够高，进行实际搜索验证
            if evaluation.intent_match and evaluation.relevance_score >= 0.7:
                print(f"    → 合格候选，进行实际搜索验证: {sug}")
                try:
                    search_result = xiaohongshu_search.search(keyword=sug)

                    # 解析result字段（它是JSON字符串，需要先解析）
                    result_str = search_result.get("result", "{}")
                    if isinstance(result_str, str):
                        result_data = json.loads(result_str)
                    else:
                        result_data = result_str

                    # 格式化搜索结果：将result字段解析后再保存
                    formatted_search_result = {
                        "success": search_result.get("success"),
                        "result": result_data,  # 保存解析后的数据
                        "tool_name": search_result.get("tool_name"),
                        "call_type": search_result.get("call_type"),
                        "query": sug,
                        "timestamp": datetime.now().isoformat()
                    }

                    # 保存格式化后的搜索结果到文件
                    safe_sug_name = "".join(c if c.isalnum() or c in (' ', '_', '-') else '_' for c in sug)
                    search_result_file = os.path.join(candidate_dir, f"sug_{sug_index+1}_{safe_sug_name[:30]}.json")
                    with open(search_result_file, 'w', encoding='utf-8') as f:
                        json.dump(formatted_search_result, f, ensure_ascii=False, indent=2)
                    print(f"       搜索结果已保存: {os.path.basename(search_result_file)}")

                    # 提取搜索结果的标题和描述
                    # 正确的数据路径: result.data.data[]
                    notes = result_data.get("data", {}).get("data", [])
                    if notes:
                        print(f"       开始评估 {len(notes)} 个帖子...")

                        # 对每个帖子进行独立评估
                        note_evaluations = []
                        for note_idx, note in enumerate(notes, 1):  # 评估所有帖子
                            note_card = note.get("note_card", {})
                            title = note_card.get("display_title", "")
                            desc = note_card.get("desc", "")
                            note_id = note.get("id", "")

                            # 构造评估输入
                            eval_input = f"""
<原始问题>
{original_question}
</原始问题>

<帖子信息>
标题: {title}
描述: {desc}
</帖子信息>

请评估这个帖子能否满足用户需求。
"""
                            # 调用评估Agent
                            eval_result_run = await Runner.run(note_evaluator, eval_input)
                            note_eval: NoteEvaluation = eval_result_run.final_output

                            note_evaluation_record = {
                                "note_index": note_idx,
                                "note_id": note_id,
                                "title": title,
                                "desc": desc,  # 保存完整描述
                                "evaluation": {
                                    "title_relevance": note_eval.title_relevance,
                                    "content_expectation": note_eval.content_expectation,
                                    "need_satisfaction": note_eval.need_satisfaction,
                                    "confidence_score": note_eval.confidence_score,
                                    "reason": note_eval.reason
                                }
                            }
                            note_evaluations.append(note_evaluation_record)

                            # 简单打印进度
                            if note_idx % 3 == 0 or note_idx == len(notes):
                                print(f"         已评估 {note_idx}/{len(notes)} 个帖子")

                        # 统计满足需求的帖子数量
                        satisfied_count = sum(1 for ne in note_evaluations if ne["evaluation"]["need_satisfaction"])
                        avg_confidence = sum(ne["evaluation"]["confidence_score"] for ne in note_evaluations) / len(note_evaluations) if note_evaluations else 0

                        eval_result["search_verification"] = {
                            "total_notes": len(notes),
                            "evaluated_notes": len(note_evaluations),
                            "satisfied_count": satisfied_count,
                            "average_confidence": round(avg_confidence, 2),
                            "note_evaluations": note_evaluations,
                            "search_result_file": search_result_file
                        }

                        print(f"       评估完成: {satisfied_count}/{len(note_evaluations)} 个帖子满足需求, "
                              f"平均置信度={avg_confidence:.2f}")
                    else:
                        eval_result["search_verification"] = {
                            "total_notes": 0,
                            "evaluated_notes": 0,
                            "satisfied_count": 0,
                            "average_confidence": 0.0,
                            "note_evaluations": [],
                            "search_result_file": search_result_file,
                            "reason": "搜索无结果"
                        }
                        print(f"       搜索无结果")

                except Exception as e:
                    print(f"       搜索验证出错: {e}")
                    eval_result["search_verification"] = {
                        "error": str(e)
                    }

            return eval_result

        evaluations = await asyncio.gather(*[eval_single_sug(s, i) for i, s in enumerate(suggestions)])

        return {
            "candidate": candidate,
            "suggestions": suggestions,
            "evaluations": evaluations
        }

    results = await asyncio.gather(*[evaluate_single_candidate(c, i) for i, c in enumerate(candidates)])

    # 生成搜索结果汇总文件
    summary_data = {
        "original_question": original_question,
        "timestamp": datetime.now().isoformat(),
        "total_candidates": len(candidates),
        "candidates": []
    }

    for i, result in enumerate(results):
        candidate_summary = {
            "index": i + 1,
            "candidate": result["candidate"],
            "suggestions_count": len(result["suggestions"]),
            "verified_queries": []
        }

        for eval_item in result.get("evaluations", []):
            if "search_verification" in eval_item and "search_result_file" in eval_item["search_verification"]:
                sv = eval_item["search_verification"]
                candidate_summary["verified_queries"].append({
                    "query": eval_item["query"],
                    "intent_match": eval_item["intent_match"],
                    "relevance_score": eval_item["relevance_score"],
                    "verification": {
                        "total_notes": sv.get("total_notes", 0),
                        "evaluated_notes": sv.get("evaluated_notes", 0),
                        "satisfied_count": sv.get("satisfied_count", 0),
                        "average_confidence": sv.get("average_confidence", 0.0)
                    },
                    "search_result_file": sv["search_result_file"]
                })

        summary_data["candidates"].append(candidate_summary)

    # 保存汇总文件
    summary_file = os.path.join(search_results_dir, "summary.json")
    with open(summary_file, 'w', encoding='utf-8') as f:
        json.dump(summary_data, f, ensure_ascii=False, indent=2)
    print(f"\n搜索结果汇总已保存: {summary_file}")

    context.evaluation_results = results

    # 构建详细的步骤记录数据
    step_data = {
        "candidate_count": len(candidates),
        "candidates": candidates,
        "total_evaluations": sum(len(r['evaluations']) for r in results),
        "verified_queries": sum(
            1 for r in results
            for e in r.get('evaluations', [])
            if 'search_verification' in e
        ),
        "search_results_dir": search_results_dir,
        "summary_file": summary_file,
        "detailed_results": []
    }

    # 为每个候选记录详细信息
    for result in results:
        candidate_detail = {
            "candidate": result["candidate"],
            "suggestions": result["suggestions"],
            "evaluations": []
        }

        for eval_item in result.get("evaluations", []):
            eval_detail = {
                "query": eval_item["query"],
                "intent_match": eval_item["intent_match"],
                "relevance_score": eval_item["relevance_score"],
                "reason": eval_item["reason"]
            }

            # 如果有搜索验证，添加详细信息
            if "search_verification" in eval_item:
                verification = eval_item["search_verification"]
                eval_detail["search_verification"] = {
                    "performed": True,
                    "total_notes": verification.get("total_notes", 0),
                    "evaluated_notes": verification.get("evaluated_notes", 0),
                    "satisfied_count": verification.get("satisfied_count", 0),
                    "average_confidence": verification.get("average_confidence", 0.0),
                    "search_result_file": verification.get("search_result_file"),
                    "has_error": "error" in verification
                }
                if "error" in verification:
                    eval_detail["search_verification"]["error"] = verification["error"]

                # 保存每个帖子的评估详情
                if "note_evaluations" in verification:
                    eval_detail["search_verification"]["note_evaluations"] = verification["note_evaluations"]
            else:
                eval_detail["search_verification"] = {
                    "performed": False,
                    "reason": "未达到搜索验证阈值（intent_match=False 或 relevance_score<0.7）"
                }

            candidate_detail["evaluations"].append(eval_detail)

        step_data["detailed_results"].append(candidate_detail)

    # 记录步骤
    add_step(context, "评估候选query", "candidate_evaluation", step_data)

    return results


# ============================================================================
# 新的独立步骤函数（方案A）
# ============================================================================

async def step_evaluate_query_suggestions(candidates: list[str], original_question: str, context: RunContext) -> list[dict]:
    """
    步骤1: 评估候选query的推荐词

    输入:
    - candidates: 候选query列表
    - original_question: 原始问题
    - context: 运行上下文

    输出:
    - 每个候选的评估结果列表，包含:
      - candidate: 候选query
      - suggestions: 推荐词列表
      - evaluations: 每个推荐词的意图匹配和相关性评分
    """
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 评估 {len(candidates)} 个候选query的推荐词")
    print(f"{'='*60}")

    xiaohongshu_api = XiaohongshuSearchRecommendations()

    async def evaluate_single_candidate(candidate: str):
        print(f"\n评估候选：{candidate}")

        # 1. 获取推荐词
        suggestions = xiaohongshu_api.get_recommendations(keyword=candidate)
        print(f"  获取到 {len(suggestions) if suggestions else 0} 个推荐词")

        if not suggestions:
            return {
                "candidate": candidate,
                "suggestions": [],
                "evaluations": []
            }

        # 2. 评估每个推荐词（只做意图匹配和相关性评分）
        async def eval_single_sug(sug: str):
            eval_input = f"""
<原始问题>
{original_question}
</原始问题>

<待评估的推荐query>
{sug}
</待评估的推荐query>

请评估该推荐query：
1. intent_match: 意图是否匹配（true/false）
2. relevance_score: 相关性分数（0-1）
3. reason: 详细的评估理由
"""
            result = await Runner.run(evaluator, eval_input)
            evaluation: RelevanceEvaluation = result.final_output

            return {
                "query": sug,
                "intent_match": evaluation.intent_match,
                "relevance_score": evaluation.relevance_score,
                "reason": evaluation.reason
            }

        evaluations = await asyncio.gather(*[eval_single_sug(s) for s in suggestions])

        return {
            "candidate": candidate,
            "suggestions": suggestions,
            "evaluations": evaluations
        }

    results = await asyncio.gather(*[evaluate_single_candidate(c) for c in candidates])

    # 记录步骤
    add_step(context, "评估候选query的推荐词", "query_suggestion_evaluation", {
        "candidate_count": len(candidates),
        "candidates": candidates,
        "results": results,
        "total_evaluations": sum(len(r['evaluations']) for r in results),
        "qualified_count": sum(
            1 for r in results
            for e in r['evaluations']
            if e['intent_match'] and e['relevance_score'] >= 0.7
        )
    })

    return results


def step_filter_qualified_queries(evaluation_results: list[dict], context: RunContext, min_relevance_score: float = 0.7) -> list[dict]:
    """
    步骤1.5: 筛选合格的推荐词

    输入:
    - evaluation_results: 步骤1的评估结果

    输出:
    - 合格的query列表，每个包含:
      - query: 推荐词
      - from_candidate: 来源候选
      - intent_match: 意图匹配
      - relevance_score: 相关性分数
      - reason: 评估理由
    """
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 筛选合格的推荐词")
    print(f"{'='*60}")

    qualified_queries = []
    all_queries = []  # 保存所有查询，包括不合格的

    for result in evaluation_results:
        candidate = result["candidate"]
        for eval_item in result.get("evaluations", []):
            query_data = {
                "query": eval_item["query"],
                "from_candidate": candidate,
                "intent_match": eval_item["intent_match"],
                "relevance_score": eval_item["relevance_score"],
                "reason": eval_item["reason"]
            }

            # 判断是否合格
            is_qualified = (eval_item['intent_match'] is True
                          and eval_item['relevance_score'] >= min_relevance_score)
            query_data["is_qualified"] = is_qualified

            all_queries.append(query_data)
            if is_qualified:
                qualified_queries.append(query_data)

    # 按相关性分数降序排列
    qualified_queries.sort(key=lambda x: x['relevance_score'], reverse=True)
    all_queries.sort(key=lambda x: x['relevance_score'], reverse=True)

    print(f"\n找到 {len(qualified_queries)} 个合格的推荐词 (共评估 {len(all_queries)} 个)")
    if qualified_queries:
        print(f"相关性分数范围: {qualified_queries[0]['relevance_score']:.2f} ~ {qualified_queries[-1]['relevance_score']:.2f}")
        print("\n合格的推荐词：")
        for idx, q in enumerate(qualified_queries[:5], 1):
            print(f"  {idx}. {q['query']} (分数: {q['relevance_score']:.2f})")
        if len(qualified_queries) > 5:
            print(f"  ... 还有 {len(qualified_queries) - 5} 个")

    # 记录步骤 - 保存所有查询数据
    add_step(context, "筛选合格的推荐词", "filter_qualified_queries", {
        "input_evaluation_count": len(all_queries),
        "min_relevance_score": min_relevance_score,
        "qualified_count": len(qualified_queries),
        "qualified_queries": qualified_queries,
        "all_queries": all_queries  # 新增：保存所有查询数据
    })

    return qualified_queries


async def step_search_qualified_queries(qualified_queries: list[dict], context: RunContext) -> dict:
    """
    步骤2: 搜索合格的推荐词

    输入:
    - qualified_queries: 步骤1.5筛选出的合格query列表，每个包含:
      - query: 推荐词
      - from_candidate: 来源候选
      - intent_match, relevance_score, reason

    输出:
    - 搜索结果字典，包含:
      - searches: 每个query的搜索结果列表
      - search_results_dir: 搜索结果保存目录
    """
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 搜索 {len(qualified_queries)} 个合格的推荐词")
    print(f"{'='*60}")

    if not qualified_queries:
        add_step(context, "搜索合格的推荐词", "search_qualified_queries", {
            "qualified_count": 0,
            "searches": []
        })
        return {"searches": [], "search_results_dir": None}

    # 创建搜索结果保存目录
    search_results_dir = os.path.join(context.log_dir, "search_results")
    os.makedirs(search_results_dir, exist_ok=True)

    xiaohongshu_search = XiaohongshuSearch()

    # 搜索每个合格的query
    async def search_single_query(query_info: dict, query_index: int):
        query = query_info['query']
        print(f"\n搜索 [{query_index+1}/{len(qualified_queries)}]: {query}")

        try:
            # 执行搜索
            search_result = xiaohongshu_search.search(keyword=query)

            # 解析result字段
            result_str = search_result.get("result", "{}")
            if isinstance(result_str, str):
                result_data = json.loads(result_str)
            else:
                result_data = result_str

            # 格式化搜索结果
            formatted_search_result = {
                "success": search_result.get("success"),
                "result": result_data,
                "tool_name": search_result.get("tool_name"),
                "call_type": search_result.get("call_type"),
                "query": query,
                "timestamp": datetime.now().isoformat()
            }

            # 保存到文件
            safe_query_name = "".join(c if c.isalnum() or c in (' ', '_', '-') else '_' for c in query)
            query_dir = os.path.join(search_results_dir, f"query_{query_index+1}_{safe_query_name[:50]}")
            os.makedirs(query_dir, exist_ok=True)

            search_result_file = os.path.join(query_dir, "search_result.json")
            with open(search_result_file, 'w', encoding='utf-8') as f:
                json.dump(formatted_search_result, f, ensure_ascii=False, indent=2)

            # 提取帖子列表
            notes = result_data.get("data", {}).get("data", [])

            print(f"  → 搜索成功，获得 {len(notes)} 个帖子")

            # ⭐ 提取帖子摘要信息用于steps.json
            notes_summary = [process_note_data(note) for note in notes]

            return {
                "query": query,
                "from_candidate": query_info['from_candidate'],
                "intent_match": query_info['intent_match'],
                "relevance_score": query_info['relevance_score'],
                "reason": query_info['reason'],
                "search_result_file": search_result_file,
                "note_count": len(notes),
                "notes": notes,  # 保存所有帖子用于评估
                "notes_summary": notes_summary  # ⭐ 保存到steps.json
            }

        except Exception as e:
            print(f"  → 搜索失败: {e}")
            return {
                "query": query,
                "from_candidate": query_info['from_candidate'],
                "intent_match": query_info['intent_match'],
                "relevance_score": query_info['relevance_score'],
                "reason": query_info['reason'],
                "error": str(e),
                "note_count": 0,
                "notes": []
            }

    search_results = await asyncio.gather(*[search_single_query(q, i) for i, q in enumerate(qualified_queries)])

    # 记录步骤
    add_step(context, "搜索合格的推荐词", "search_qualified_queries", {
        "qualified_count": len(qualified_queries),
        "search_results": [
            {
                "query": sr['query'],
                "from_candidate": sr['from_candidate'],
                "note_count": sr['note_count'],
                "search_result_file": sr.get('search_result_file'),
                "has_error": 'error' in sr,
                "notes_summary": sr.get('notes_summary', [])  # ⭐ 包含帖子摘要
            }
            for sr in search_results
        ],
        "search_results_dir": search_results_dir
    })

    return {
        "searches": search_results,
        "search_results_dir": search_results_dir
    }


async def step_evaluate_search_notes(search_data: dict, original_question: str, context: RunContext) -> dict:
    """
    步骤3: 评估搜索到的帖子

    输入:
    - search_data: 步骤2的搜索结果，包含:
      - searches: 搜索结果列表
      - search_results_dir: 结果目录

    输出:
    - 帖子评估结果字典，包含:
      - note_evaluations: 每个query的帖子评估列表
    """
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 评估搜索到的帖子")
    print(f"{'='*60}")

    search_results = search_data['searches']

    if not search_results:
        add_step(context, "评估搜索到的帖子", "evaluate_search_notes", {
            "query_count": 0,
            "total_notes": 0,
            "evaluated_notes": 0,
            "note_evaluations": []
        })
        return {"note_evaluations": []}

    # 对每个query的帖子进行评估
    async def evaluate_query_notes(search_result: dict, query_index: int):
        query = search_result['query']
        notes = search_result.get('notes', [])

        if not notes or 'error' in search_result:
            return {
                "query": query,
                "from_candidate": search_result['from_candidate'],
                "note_count": 0,
                "evaluated_notes": [],
                "satisfied_count": 0,
                "average_confidence": 0.0
            }

        print(f"\n评估query [{query_index+1}]: {query} ({len(notes)} 个帖子)")

        # 评估每个帖子
        note_evaluations = []
        for note_idx, note in enumerate(notes, 1):
            # 使用标准化函数处理帖子数据
            note_data = process_note_data(note)
            title = note_data["title"]
            desc = note_data["desc"]

            # 调用评估Agent
            eval_input = f"""
<原始问题>
{original_question}
</原始问题>

<帖子信息>
标题: {title}
描述: {desc}
</帖子信息>

请评估这个帖子能否满足用户需求。
"""
            eval_result_run = await Runner.run(note_evaluator, eval_input)
            note_eval: NoteEvaluation = eval_result_run.final_output

            # 合并标准化的帖子数据和评估结果
            note_evaluations.append({
                **note_data,  # 包含所有标准化字段
                "note_index": note_idx,
                "evaluation": {
                    "title_relevance": note_eval.title_relevance,
                    "content_expectation": note_eval.content_expectation,
                    "need_satisfaction": note_eval.need_satisfaction,
                    "confidence_score": note_eval.confidence_score,
                    "reason": note_eval.reason
                }
            })

            if note_idx % 3 == 0 or note_idx == len(notes):
                print(f"  已评估 {note_idx}/{len(notes)} 个帖子")

        # 统计
        satisfied_count = sum(1 for ne in note_evaluations if ne["evaluation"]["need_satisfaction"])
        avg_confidence = sum(ne["evaluation"]["confidence_score"] for ne in note_evaluations) / len(note_evaluations) if note_evaluations else 0

        print(f"  → 完成：{satisfied_count}/{len(note_evaluations)} 个帖子满足需求")

        return {
            "query": query,
            "from_candidate": search_result['from_candidate'],
            "note_count": len(notes),
            "evaluated_notes": note_evaluations,
            "satisfied_count": satisfied_count,
            "average_confidence": round(avg_confidence, 2)
        }

    # 并发评估所有query的帖子
    all_evaluations = await asyncio.gather(*[evaluate_query_notes(sr, i) for i, sr in enumerate(search_results, 1)])

    # 记录步骤
    total_notes = sum(e['note_count'] for e in all_evaluations)
    total_satisfied = sum(e['satisfied_count'] for e in all_evaluations)

    add_step(context, "评估搜索到的帖子", "evaluate_search_notes", {
        "query_count": len(search_results),
        "total_notes": total_notes,
        "total_satisfied": total_satisfied,
        "note_evaluations": all_evaluations
    })

    return {"note_evaluations": all_evaluations}


def step_collect_satisfied_notes(note_evaluation_data: dict) -> list[dict]:
    """
    步骤4: 汇总所有满足需求的帖子

    输入:
    - note_evaluation_data: 步骤3的帖子评估结果

    输出:
    - 所有满足需求的帖子列表，按置信度降序排列
    """
    print(f"\n{'='*60}")
    print(f"汇总满足需求的帖子")
    print(f"{'='*60}")

    all_satisfied_notes = []

    for query_eval in note_evaluation_data['note_evaluations']:
        for note in query_eval['evaluated_notes']:
            if note['evaluation']['need_satisfaction']:
                all_satisfied_notes.append({
                    "query": query_eval['query'],
                    "from_candidate": query_eval['from_candidate'],
                    "note_id": note['note_id'],
                    "title": note['title'],
                    "desc": note['desc'],
                    # ⭐ 保留完整帖子信息
                    "image_list": note.get('image_list', []),
                    "cover_image": note.get('cover_image', {}),
                    "interact_info": note.get('interact_info', {}),
                    "user": note.get('user', {}),
                    "type": note.get('type', 'normal'),
                    "note_url": note.get('note_url', ''),
                    # 评估结果
                    "title_relevance": note['evaluation']['title_relevance'],
                    "content_expectation": note['evaluation']['content_expectation'],
                    "confidence_score": note['evaluation']['confidence_score'],
                    "reason": note['evaluation']['reason']
                })

    # 按置信度降序排列
    all_satisfied_notes.sort(key=lambda x: x['confidence_score'], reverse=True)

    print(f"\n共收集到 {len(all_satisfied_notes)} 个满足需求的帖子")
    if all_satisfied_notes:
        print(f"置信度范围: {all_satisfied_notes[0]['confidence_score']:.2f} ~ {all_satisfied_notes[-1]['confidence_score']:.2f}")

    return all_satisfied_notes


async def step_generate_answer(satisfied_notes: list[dict], original_question: str, context: RunContext) -> dict:
    """
    步骤5: 基于满足需求的帖子生成答案

    输入:
    - satisfied_notes: 步骤4收集的满足需求的帖子列表
    - original_question: 原始问题
    - context: 运行上下文

    输出:
    - 生成的答案及相关信息
      - answer: 答案内容（Markdown格式）
      - cited_note_indices: 引用的帖子索引
      - confidence: 答案置信度
      - summary: 答案摘要
      - cited_notes: 被引用的帖子详情
    """
    step_num = len(context.steps) + 1
    print(f"\n{'='*60}")
    print(f"[步骤 {step_num}] 基于 {len(satisfied_notes)} 个帖子生成答案")
    print(f"{'='*60}")

    if not satisfied_notes:
        print("\n⚠️  没有满足需求的帖子，无法生成答案")
        result = {
            "answer": "抱歉，未找到能够回答该问题的相关内容。",
            "cited_note_indices": [],
            "confidence": 0.0,
            "summary": "无可用信息",
            "cited_notes": []
        }

        add_step(context, "生成答案", "answer_generation", {
            "original_question": original_question,
            "input_notes_count": 0,
            "result": result
        })

        return result

    # 构建Agent输入
    notes_info = []
    for idx, note in enumerate(satisfied_notes, 1):
        notes_info.append(f"""
【帖子 {idx}】
标题: {note['title']}
描述: {note['desc']}
置信度: {note['confidence_score']:.2f}
""".strip())

    agent_input = f"""
<原始问题>
{original_question}
</原始问题>

<相关帖子>
{chr(10).join(notes_info)}
</相关帖子>

请基于以上帖子，为原始问题生成一个全面、准确的答案。
记得在答案中使用 [1], [2] 等标注引用的帖子序号。
""".strip()

    print(f"\n📝 调用答案生成Agent...")
    print(f"  - 可用帖子: {len(satisfied_notes)} 个")
    print(f"  - 平均置信度: {sum(n['confidence_score'] for n in satisfied_notes) / len(satisfied_notes):.2f}")

    # 调用Agent生成答案
    result_run = await Runner.run(answer_generator, agent_input)
    answer_result: AnswerGeneration = result_run.final_output

    # 提取被引用的帖子详情
    cited_notes = []
    for idx in answer_result.cited_note_indices:
        if 1 <= idx <= len(satisfied_notes):
            note = satisfied_notes[idx - 1]
            cited_notes.append({
                "index": idx,
                "note_id": note['note_id'],
                "title": note['title'],
                "desc": note['desc'],
                "confidence_score": note['confidence_score'],
                # ⭐ 完整帖子信息用于可视化
                "image_list": note.get('image_list', []),
                "cover_image": note.get('cover_image', {}),
                "interact_info": note.get('interact_info', {}),
                "user": note.get('user', {}),
                "note_url": note.get('note_url', ''),
                "type": note.get('type', 'normal'),
                # ⭐ 评估详情
                "title_relevance": note.get('title_relevance', 0),
                "content_expectation": note.get('content_expectation', 0),
                "reason": note.get('reason', '')
            })

    result = {
        "answer": answer_result.answer,
        "cited_note_indices": answer_result.cited_note_indices,
        "confidence": answer_result.confidence,
        "summary": answer_result.summary,
        "cited_notes": cited_notes
    }

    # 打印结果
    print(f"\n✅ 答案生成完成")
    print(f"  - 引用帖子数: {len(answer_result.cited_note_indices)} 个")
    print(f"  - 答案置信度: {answer_result.confidence:.2f}")
    print(f"  - 答案摘要: {answer_result.summary}")

    # 记录步骤
    add_step(context, "生成答案", "answer_generation", {
        "original_question": original_question,
        "input_notes_count": len(satisfied_notes),
        "result": result,
        "agent_input_preview": agent_input[:500] + "..." if len(agent_input) > 500 else agent_input
    })

    return result


def find_qualified_queries(evaluation_results: list[dict], min_relevance_score: float = 0.7) -> list[dict]:
    """
    查找所有合格的query（旧函数，保留兼容性）

    筛选标准：
    1. intent_match = True（必须满足）
    2. relevance_score >= min_relevance_score

    返回：按 relevance_score 降序排列
    """
    all_qualified = []

    for result in evaluation_results:
        for eval_item in result.get("evaluations", []):
            if (eval_item['intent_match'] is True
                and eval_item['relevance_score'] >= min_relevance_score):
                all_qualified.append({
                    "from_candidate": result["candidate"],
                    **eval_item
                })

    # 按relevance_score降序排列
    return sorted(all_qualified, key=lambda x: x['relevance_score'], reverse=True)


# ============================================================================
# 主流程
# ============================================================================

async def progressive_exploration(context: RunContext, max_levels: int = 4) -> dict:
    """
    渐进式探索流程 - 使用独立步骤

    流程:
    1. 提取关键词 + 渐进式探索（复用旧流程）
    2. 步骤1: 评估候选query的推荐词
    3. 步骤2: 搜索合格的推荐词
    4. 步骤3: 评估搜索到的帖子
    5. 步骤4: 汇总满足需求的帖子
    6. 步骤5: 生成答案

    Args:
        context: 运行上下文
        max_levels: 最大探索层数，默认4

    返回格式：
    {
        "success": True/False,
        "final_answer": {...},  # 生成的答案
        "satisfied_notes": [...],  # 满足需求的帖子
        "message": "..."
    }
    """

    # ========== 阶段1：渐进式探索（复用旧流程找到候选query）==========

    # 1.1 提取关键词
    keyword_result = await extract_keywords(context.q, context)
    context.keywords = keyword_result.keywords

    # 1.2 渐进式探索各层级
    current_level = 1
    candidates_to_evaluate = []

    # Level 1：单个关键词
    level_1_queries = context.keywords  # 使用所有关键词
    level_1_data = await explore_level(level_1_queries, current_level, context)
    analysis_1 = await analyze_level(level_1_data, context.exploration_levels, context.q, context)

    if analysis_1.should_evaluate_now:
        candidates_to_evaluate.extend(analysis_1.candidates_to_evaluate)

    # Level 2及以后：迭代探索
    for level_num in range(2, max_levels + 1):
        prev_analysis: LevelAnalysis = context.level_analyses[-1]["analysis"]
        prev_analysis = LevelAnalysis(**prev_analysis)

        if not prev_analysis.next_combinations:
            print(f"\nLevel {level_num-1} 分析后无需继续探索")
            break

        level_data = await explore_level(prev_analysis.next_combinations, level_num, context)
        analysis = await analyze_level(level_data, context.exploration_levels, context.q, context)

        if analysis.should_evaluate_now:
            candidates_to_evaluate.extend(analysis.candidates_to_evaluate)

    if not candidates_to_evaluate:
        return {
            "success": False,
            "final_answer": None,
            "satisfied_notes": [],
            "message": "渐进式探索未找到候选query"
        }

    print(f"\n{'='*60}")
    print(f"渐进式探索完成，找到 {len(candidates_to_evaluate)} 个候选query")
    print(f"{'='*60}")

    # ========== 阶段2：新的独立步骤流程 ==========

    # 步骤1: 评估候选query的推荐词
    evaluation_results = await step_evaluate_query_suggestions(
        candidates_to_evaluate,
        context.q,
        context
    )

    # 步骤1.5: 筛选合格的推荐词
    qualified_queries = step_filter_qualified_queries(
        evaluation_results,
        context,
        min_relevance_score=0.7
    )

    if not qualified_queries:
        return {
            "success": False,
            "final_answer": None,
            "satisfied_notes": [],
            "message": "没有合格的推荐词"
        }

    # 步骤2: 搜索合格的推荐词
    search_results = await step_search_qualified_queries(
        qualified_queries,
        context
    )

    if not search_results.get('searches'):
        return {
            "success": False,
            "final_answer": None,
            "satisfied_notes": [],
            "message": "搜索失败"
        }

    # 步骤3: 评估搜索到的帖子
    note_evaluation_data = await step_evaluate_search_notes(
        search_results,
        context.q,
        context
    )

    # 步骤4: 汇总满足需求的帖子
    satisfied_notes = step_collect_satisfied_notes(note_evaluation_data)

    if not satisfied_notes:
        return {
            "success": False,
            "final_answer": None,
            "satisfied_notes": [],
            "message": "未找到满足需求的帖子"
        }

    # 步骤5: 生成答案
    final_answer = await step_generate_answer(
        satisfied_notes,
        context.q,
        context
    )

    # ========== 返回最终结果 ==========

    return {
        "success": True,
        "final_answer": final_answer,
        "satisfied_notes": satisfied_notes,
        "message": f"成功找到 {len(satisfied_notes)} 个满足需求的帖子，并生成答案"
    }


# ============================================================================
# 输出格式化
# ============================================================================

def format_output(optimization_result: dict, context: RunContext) -> str:
    """
    格式化输出结果 - 用于独立步骤流程

    包含:
    - 生成的答案
    - 引用的帖子详情
    - 满足需求的帖子统计
    """
    final_answer = optimization_result.get("final_answer")
    satisfied_notes = optimization_result.get("satisfied_notes", [])

    output = f"原始问题：{context.q}\n"
    output += f"提取的关键词：{', '.join(context.keywords or [])}\n"
    output += f"探索层数：{len(context.exploration_levels)}\n"
    output += f"找到满足需求的帖子：{len(satisfied_notes)} 个\n"
    output += "\n" + "="*60 + "\n"

    if final_answer:
        output += "【生成的答案】\n\n"
        output += final_answer.get("answer", "")
        output += "\n\n" + "="*60 + "\n"

        output += f"答案置信度：{final_answer.get('confidence', 0):.2f}\n"
        output += f"答案摘要：{final_answer.get('summary', '')}\n"
        output += f"引用帖子数：{len(final_answer.get('cited_note_indices', []))} 个\n"
        output += "\n" + "="*60 + "\n"

        output += "【引用的帖子详情】\n\n"
        for cited_note in final_answer.get("cited_notes", []):
            output += f"[{cited_note['index']}] {cited_note['title']}\n"
            output += f"    置信度: {cited_note['confidence_score']:.2f}\n"
            output += f"    描述: {cited_note['desc']}\n"
            output += f"    note_id: {cited_note['note_id']}\n\n"
    else:
        output += "未能生成答案\n"

    return output


# ============================================================================
# 主函数
# ============================================================================



async def main(input_dir: str, max_levels: int = 4, visualize: bool = False):
    """
    主函数 - 使用独立步骤流程（方案A）
    """
    current_time, log_url = set_trace()

    # 从目录中读取固定文件名
    input_context_file = os.path.join(input_dir, 'context.md')
    input_q_file = os.path.join(input_dir, 'q.md')

    q_context = read_file_as_string(input_context_file)
    q = read_file_as_string(input_q_file)
    q_with_context = f"""
<需求上下文>
{q_context}
</需求上下文>
<当前问题>
{q}
</当前问题>
""".strip()

    # 获取当前文件名作为版本
    version = os.path.basename(__file__)
    version_name = os.path.splitext(version)[0]

    # 日志保存目录
    log_dir = os.path.join(input_dir, "output", version_name, current_time)

    run_context = RunContext(
        version=version,
        input_files={
            "input_dir": input_dir,
            "context_file": input_context_file,
            "q_file": input_q_file,
        },
        q_with_context=q_with_context,
        q_context=q_context,
        q=q,
        log_dir=log_dir,
        log_url=log_url,
    )

    # 执行渐进式探索
    optimization_result = await progressive_exploration(run_context, max_levels=max_levels)

    # 格式化输出
    final_output = format_output(optimization_result, run_context)
    print(f"\n{'='*60}")
    print("最终结果")
    print(f"{'='*60}")
    print(final_output)

    # 保存结果
    run_context.optimization_result = optimization_result
    run_context.final_output = final_output

    # 记录最终输出步骤（新格式）
    final_answer = optimization_result.get("final_answer")
    satisfied_notes = optimization_result.get("satisfied_notes", [])

    add_step(run_context, "生成最终结果", "final_result", {
        "success": optimization_result["success"],
        "message": optimization_result["message"],
        "satisfied_notes_count": len(satisfied_notes),
        "final_answer": final_answer,
        "satisfied_notes_summary": [
            {
                "note_id": note["note_id"],
                "title": note["title"],
                "confidence_score": note["confidence_score"]
            }
            for note in satisfied_notes  # 保存所有满足条件的帖子摘要
        ] if satisfied_notes else [],
        "final_output": final_output
    })

    # 保存 RunContext 到 log_dir（不包含 steps，steps 单独保存）
    os.makedirs(run_context.log_dir, exist_ok=True)
    context_file_path = os.path.join(run_context.log_dir, "run_context.json")
    context_dict = run_context.model_dump()
    context_dict.pop('steps', None)  # 移除 steps，避免数据冗余
    with open(context_file_path, "w", encoding="utf-8") as f:
        json.dump(context_dict, f, ensure_ascii=False, indent=2)
    print(f"\nRunContext saved to: {context_file_path}")

    # 保存步骤化日志
    steps_file_path = os.path.join(run_context.log_dir, "steps.json")
    with open(steps_file_path, "w", encoding="utf-8") as f:
        json.dump(run_context.steps, f, ensure_ascii=False, indent=2)
    print(f"Steps log saved to: {steps_file_path}")

    # 如果需要生成可视化
    if visualize:
        import subprocess
        output_html = os.path.join(run_context.log_dir, "visualization.html")
        print(f"\n🎨 生成可视化HTML...")
        result = subprocess.run([
            "python", "sug_v6_1_2_3.visualize.py",
            steps_file_path,
            "-o", output_html
        ])
        if result.returncode == 0:
            print(f"✅ 可视化已生成: {output_html}")
        else:
            print(f"❌ 可视化生成失败")



if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="搜索query优化工具 - v6.1.2.3 独立步骤+答案生成版")
    parser.add_argument(
        "--input-dir",
        type=str,
        default="input/简单扣图",
        help="输入目录路径，默认: input/简单扣图"
    )
    parser.add_argument(
        "--max-levels",
        type=int,
        default=10,
        help="最大探索层数，默认: 10"
    )
    parser.add_argument(
        "--visualize",
        action="store_true",
        default=True,
        help="运行完成后自动生成可视化HTML（默认开启）"
    )
    parser.add_argument(
        "--no-visualize",
        action="store_false",
        dest="visualize",
        help="关闭自动生成可视化"
    )
    parser.add_argument(
        "--visualize-only",
        action="store_true",
        help="只生成可视化，不运行搜索流程。自动查找input-dir下最新的输出目录"
    )
    args = parser.parse_args()

    # 如果只是生成可视化
    if args.visualize_only:
        import subprocess
        import glob

        # 获取版本名称
        version_name = os.path.splitext(os.path.basename(__file__))[0]
        output_base = os.path.join(args.input_dir, "output", version_name)

        # 查找最新的输出目录
        if not os.path.exists(output_base):
            print(f"❌ 找不到输出目录: {output_base}")
            sys.exit(1)

        # 获取所有日期目录
        date_dirs = glob.glob(os.path.join(output_base, "*", "*"))
        if not date_dirs:
            print(f"❌ 在 {output_base} 中没有找到输出目录")
            sys.exit(1)

        # 按修改时间排序，获取最新的
        latest_dir = max(date_dirs, key=os.path.getmtime)
        steps_json = os.path.join(latest_dir, "steps.json")

        if not os.path.exists(steps_json):
            print(f"❌ 找不到 steps.json: {steps_json}")
            sys.exit(1)

        output_html = os.path.join(latest_dir, "visualization.html")
        print(f"🎨 找到最新输出目录: {latest_dir}")
        print(f"🎨 生成可视化: {steps_json} -> {output_html}")

        result = subprocess.run([
            "python", "sug_v6_1_2_3.visualize.py",
            steps_json,
            "-o", output_html
        ])
        sys.exit(result.returncode)

    asyncio.run(main(args.input_dir, max_levels=args.max_levels, visualize=args.visualize))