import os
from dotenv import load_dotenv

load_dotenv()

# 读取环境变量
openai_api_key = os.getenv("OPENAI_API_KEY")
hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")

# 错误做法：在节点内部每次实例化
def bad_summary_node(state: dict) -> dict:
    llm = ChatOpenAI(model="gpt-4o-mini")  # 每次节点触发都重新创建连接、读取配置
    res = llm.invoke(...)
    return {"summary": res.content}

# 正确做法：单例外部初始化，节点内部纯粹调用
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.2,
    timeout=30.0,
    max_retries=2,
)

def good_summary_node(state: dict) -> dict:
    res = llm.invoke(...)
    return {"summary": res.content}

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

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

prompt_template = ChatPromptTemplate.from_messages([
    ("system", "你是一名资深的技术架构师，擅长用简练的语言做技术提炼。"),
    ("human", "请根据以下背景信息提炼 3 个关键设计考量：\n\n{context}"),
])

# 利用 LCEL 管道组合
summary_chain = prompt_template | llm

def analyze_architecture_node(state: dict) -> dict:
    context = state.get("raw_text", "")
    response = summary_chain.invoke({"context": context})
    return {"key_considerations": response.content}

from typing import List
from pydantic import BaseModel, Field


class CodeReviewResult(BaseModel):
    score: int = Field(description="代码质量评分，范围 1 到 10")
    passed: bool = Field(description="是否达到合并标准")
    identified_issues: List[str] = Field(description="发现的潜在缺陷或规范问题列表")
    optimization_suggestions: List[str] = Field(description="重构优化建议")


structured_llm = llm.with_structured_output(CodeReviewResult)

def code_review_node(state: dict) -> dict:
    code_snippet = state.get("source_code", "")
    prompt = f"请严格审查以下 Python 代码并输出审查结果：\n\n```python\n{code_snippet}\n```"
    
    # 直接返回强类型的 Pydantic 对象
    review: CodeReviewResult = structured_llm.invoke(prompt)
    
    return {
        "review_score": review.score,
        "is_review_passed": review.passed,
        "review_issues": review.identified_issues,
        "review_suggestions": review.optimization_suggestions,
    }

from langchain_huggingface import HuggingFaceEndpoint

hf_llm = HuggingFaceEndpoint(
    repo_id="mistralai/Mistral-7B-Instruct-v0.2",
    task="text-generation",
    max_new_tokens=512,
    temperature=0.1,
    do_sample=False,
)

def hf_generate_node(state: dict) -> dict:
    query = state["query"]
    # Mistral 特定的提示词指令格式
    prompt = f"[INST] 请根据用户问题给出技术解答：{query} [/INST]"
    
    response = hf_llm.invoke(prompt)
    return {"answer": response}

from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
from langchain_core.messages import HumanMessage, SystemMessage

endpoint = HuggingFaceEndpoint(
    repo_id="mistralai/Mistral-7B-Instruct-v0.2",
    task="text-generation",
    max_new_tokens=512,
)

# 自动处理模板格式映射
chat_hf_model = ChatHuggingFace(llm=endpoint)

def uniform_chat_node(state: dict) -> dict:
    messages = [
        SystemMessage(content="你是一个专业的运维排错专家。"),
        HumanMessage(content=state["error_log"]),
    ]
    response = chat_hf_model.invoke(messages)
    return {"diagnostic_report": response.content}

# 接入本地部署的 Ollama / vLLM
local_llm = ChatOpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # 本地无需鉴权但不可为空
    model="qwen2.5:7b",
    temperature=0.1,
)

import os
from typing import TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langgraph.graph import StateGraph, END


# 1. 状态定义
class ContentPipeline(TypedDict):
    topic: str
    keywords: str
    outline: str
    article: str


# 2. 全局初始化模型
model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.3,
    api_key=os.getenv("OPENAI_API_KEY"),
)


# 3. 节点实现
def extract_keywords_node(state: ContentPipeline) -> dict:
    topic = state["topic"]
    resp = model.invoke([
        SystemMessage(content="你是一个 SEO 与关键词提取助手。请仅输出关键词，用逗号分隔。"),
        HumanMessage(content=f"提取主题【{topic}】的 5 个技术核心关键词。"),
    ])
    return {"keywords": resp.content.strip()}


def create_outline_node(state: ContentPipeline) -> dict:
    topic = state["topic"]
    keywords = state["keywords"]
    resp = model.invoke([
        SystemMessage(content="你是一名资深技术主编，擅长设计逻辑递进的技术文章大纲。"),
        HumanMessage(
            content=f"基于主题【{topic}】和关键词【{keywords}】，规划 3 个核心章节大纲，包含二级小节标题。"
        ),
    ])
    return {"outline": resp.content.strip()}


def write_article_node(state: ContentPipeline) -> dict:
    topic = state["topic"]
    outline = state["outline"]
    resp = model.invoke([
        SystemMessage(content="你是一名工程博主，行文偏重实际应用和工程落地，语言精炼。"),
        HumanMessage(
            content=f"主题：{topic}\n\n大纲如下：\n{outline}\n\n请根据大纲撰写一篇 800 字左右的技术短文。"
        ),
    ])
    return {"article": resp.content.strip()}


# 4. 组装与编译工作流图
workflow = StateGraph(ContentPipeline)
workflow.add_node("extract_keywords", extract_keywords_node)
workflow.add_node("create_outline", create_outline_node)
workflow.add_node("write_article", write_article_node)

workflow.set_entry_point("extract_keywords")
workflow.add_edge("extract_keywords", "create_outline")
workflow.add_edge("create_outline", "write_article")
workflow.add_edge("write_article", END)

app = workflow.compile()

# 5. 执行调用
if __name__ == "__main__":
    inputs = {
        "topic": "LangGraph 状态机的错误恢复机制",
        "keywords": "",
        "outline": "",
        "article": "",
    }
    
    final_output = app.invoke(inputs)
    print("========== 提取的关键词 ==========")
    print(final_output["keywords"])
    print("\n========== 生成的结构大纲 ==========")
    print(final_output["outline"])
    print("\n========== 正文产出 ==========")
    print(final_output["article"])

import time
from typing import Optional


def resilient_llm_call_node(state: dict) -> dict:
    """具备重试容错与优雅降级的节点"""
    prompt = state.get("query_prompt", "")
    max_retries = 3
    base_delay = 1.0  # 秒
    
    last_error: Optional[Exception] = None
    for attempt in range(max_retries):
        try:
            response = model.invoke([HumanMessage(content=prompt)])
            return {
                "generated_result": response.content,
                "is_error": False,
                "error_message": "",
            }
        except Exception as e:
            last_error = e
            # 指数退避：1s, 2s, 4s...
            wait_time = base_delay * (2 ** attempt)
            print(f"[警告] 模型调用异常 (尝试 {attempt + 1}/{max_retries}): {e}，{wait_time} 秒后重试...")
            time.sleep(wait_time)
            
    # 重试全部耗尽后的优雅降级，不抛出致命异常中断整张图
    return {
        "generated_result": "生成失败：服务暂不可用",
        "is_error": True,
        "error_message": str(last_error),
    }