from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 步骤 1：从用户反馈中提取关键信息
extract_prompt = ChatPromptTemplate.from_template("""
从以下用户反馈中提取关键信息，以 JSON 格式输出：
{{
  "product": "提到的产品名",
  "issue_type": "问题类型（quality/delivery/service/other）",
  "sentiment": "情绪（positive/neutral/negative）",
  "key_complaint": "核心诉求一句话总结"
}}

用户反馈：{feedback}
""")

# 步骤 2：根据提取的信息生成回复策略
strategy_prompt = ChatPromptTemplate.from_template("""
根据以下用户反馈分析，制定客服回复策略：

分析结果：{extracted_info}

请输出：
1. 回复的语气（apologetic/neutral/positive）
2. 是否需要补偿（yes/no）
3. 解决方案要点（2-3 条）
""")

# 步骤 3：生成最终回复
reply_prompt = ChatPromptTemplate.from_template("""
根据以下策略，生成专业的客服回复：

策略：{strategy}
原始反馈：{original_feedback}

要求：语气真诚，不超过 150 字，给出明确的解决方案。
""")

# 构建线性链
step1 = extract_prompt | llm | StrOutputParser()
step2 = strategy_prompt | llm | StrOutputParser()
step3 = reply_prompt | llm | StrOutputParser()

# 用 RunnablePassthrough 传递原始数据（RunnablePassthrough 是 LangChain 的工具类，用来在链中传递原始输入数据，不做任何修改）
from langchain_core.runnables import RunnablePassthrough

linear_chain = (
    RunnablePassthrough.assign(extracted_info=step1)
    | RunnablePassthrough.assign(strategy=step2)
    | step3
)

# 调用
result = linear_chain.invoke({"feedback": "收到的手机屏幕有划痕，物流也很慢，很失望"})
print(result)

from langchain_core.runnables import RunnableBranch, RunnableLambda

# 意图识别 Prompt
intent_prompt = ChatPromptTemplate.from_template("""
识别用户问题的意图类型，只输出一个词：
- order_query: 订单相关
- product_question: 产品咨询
- complaint: 投诉
- other: 其他

用户问题：{question}
""")

intent_chain = intent_prompt | llm | StrOutputParser()

# 三条专用处理链
order_chain = (
    ChatPromptTemplate.from_template("你是订单专家，帮助用户解决：{question}")
    | llm | StrOutputParser()
)

product_chain = (
    ChatPromptTemplate.from_template("你是产品顾问，详细介绍：{question}")
    | llm | StrOutputParser()
)

complaint_chain = (
    ChatPromptTemplate.from_template("你是客诉专员，处理此投诉（语气诚恳）：{question}")
    | llm | StrOutputParser()
)

default_chain = (
    ChatPromptTemplate.from_template("你是通用客服，回答：{question}")
    | llm | StrOutputParser()
)

# 条件路由链
branch_chain = RunnableBranch(
    (lambda x: "order" in x["intent"], order_chain),
    (lambda x: "product" in x["intent"], product_chain),
    (lambda x: "complaint" in x["intent"], complaint_chain),
    default_chain  # 默认分支
)

# 组合：先识别意图，再路由
conditional_chain = (
    RunnablePassthrough.assign(
        intent=lambda x: intent_chain.invoke({"question": x["question"]})
    )
    | branch_chain
)

result = conditional_chain.invoke({"question": "我的订单三天了还没发货"})

from langchain_core.runnables import RunnableParallel

# 三个并行分析维度
security_chain = (
    ChatPromptTemplate.from_template("从安全角度分析这段代码的风险：\n{code}")
    | llm | StrOutputParser()
)

performance_chain = (
    ChatPromptTemplate.from_template("从性能角度分析这段代码的问题：\n{code}")
    | llm | StrOutputParser()
)

maintainability_chain = (
    ChatPromptTemplate.from_template("从可维护性角度评估这段代码：\n{code}")
    | llm | StrOutputParser()
)

# 聚合 Prompt
aggregate_prompt = ChatPromptTemplate.from_template("""
综合以下三个维度的代码分析，给出优先级排序的改进建议：

安全性分析：{security}
性能分析：{performance}
可维护性分析：{maintainability}

请输出按优先级排序的前 5 条改进建议。
""")

# 并行执行 + 聚合
parallel_chain = (
    RunnableParallel(
        security=security_chain,
        performance=performance_chain,
        maintainability=maintainability_chain
    )
    | aggregate_prompt
    | llm
    | StrOutputParser()
)

code_sample = """
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    return db.execute(query)
"""
result = parallel_chain.invoke({"code": code_sample})

from langchain.globals import set_verbose, set_debug

# 开启 verbose：打印每步的输入输出摘要
set_verbose(True)

# 开启 debug：打印完整的输入输出内容（更详细）
set_debug(True)

result = linear_chain.invoke({"feedback": "快递很慢"})

> Entering new chain...

[Step 1 - Extract]
Input: {"feedback": "快递很慢"}
Output: {"product": "unknown", "issue_type": "delivery", "sentiment": "negative", "key_complaint": "物流速度慢"}

[Step 2 - Strategy]
Input: {"extracted_info": "..."}
Output: "语气：apologetic；需要补偿：yes；方案：1. 道歉 2. 查询物流 3. 优惠券补偿"

[Step 3 - Reply]
...

# 单步调试
intermediate_output = step1.invoke({"feedback": "快递很慢"})
print("Step 1 输出:", intermediate_output)

# 验证 step2 是否能正确处理 step1 的输出
step2_output = step2.invoke({"extracted_info": intermediate_output})
print("Step 2 输出:", step2_output)

from langchain_openai import ChatOpenAI

# 廉价模型：用于简单的分类、提取、格式转换
cheap_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 贵模型：只用于需要深度推理的核心步骤
powerful_llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 成本优化的链：前后步骤用便宜模型，核心步骤用强模型
cost_optimized_chain = (
    extract_prompt | cheap_llm | StrOutputParser()          # 提取：便宜
    | RunnablePassthrough.assign(strategy=
        strategy_prompt | powerful_llm | StrOutputParser()  # 推理：强模型
    )
    | reply_prompt | cheap_llm | StrOutputParser()          # 格式化：便宜
)

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

cheap_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
strong_llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

# 步骤 1：需求文档→结构化需求分析
requirements_prompt = ChatPromptTemplate.from_template("""
分析以下需求文档，输出结构化分析：

需求文档：
{requirement_doc}

请提取：
1. 核心功能列表（3-5 条）
2. 非功能需求（性能、安全、可扩展性）
3. 技术约束（语言、框架、已有系统）
4. 主要风险点
""")

# 步骤 2：结构化需求→技术方案
tech_design_prompt = ChatPromptTemplate.from_template("""
根据以下需求分析，设计技术方案：

需求分析：
{requirements_analysis}

请输出：
## 系统架构
（描述整体架构设计）

## 核心模块
（列出主要模块及职责）

## 技术选型
（框架、数据库、中间件选择及理由）

## 接口设计
（主要 API 端点，RESTful 格式）
""")

# 步骤 3：技术方案→代码骨架
code_skeleton_prompt = ChatPromptTemplate.from_template("""
根据以下技术方案，生成 Python 代码骨架（只需类/函数定义和注释，不需要完整实现）：

技术方案：
{tech_design}

要求：
- 使用 FastAPI 框架
- 包含完整的类型注解
- 每个函数有 docstring
- 包含 Pydantic 数据模型定义
""")

# 组装三段链
pipeline = (
    RunnablePassthrough.assign(
        requirements_analysis=(requirements_prompt | strong_llm | StrOutputParser())
    )
    | RunnablePassthrough.assign(
        tech_design=(tech_design_prompt | strong_llm | StrOutputParser())
    )
    | (code_skeleton_prompt | cheap_llm | StrOutputParser())
)

# 执行
requirement_doc = """
需要开发一个用户积分管理系统：
- 用户消费后自动累积积分
- 积分可以兑换商品或抵扣现金
- 积分有有效期（1年）
- 管理员可以手动调整积分
- 需要支持高并发（日活 10 万）
技术约束：现有系统使用 Python + PostgreSQL
"""

result = pipeline.invoke({"requirement_doc": requirement_doc})
print(result)

需求文档 (非结构化)
    ↓ [步骤 1：需求分析 - GPT-4o]
结构化需求分析 (Markdown)
    ↓ [步骤 2：技术方案 - GPT-4o]
详细技术方案 (Markdown)
    ↓ [步骤 3：代码骨架 - GPT-4o-mini]
Python 代码骨架 (可运行)