ChouJuGEO/geo_tool.py

import streamlit as st
import pandas as pd
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import JsonOutputParser, StrOutputParser
import zipfile
import io
import plotly.express as px
import re
import json
from data_storage import DataStorage
from keyword_tool import KeywordTool
from content_scorer import ContentScorer

APP_TITLE = "GEO 智能内容优化平台"

# ------------------- 页面配置 & 极简美学 CSS（产品级精修，仍然克制） -------------------
st.set_page_config(page_title="GEO 智能内容优化平台", layout="wide", initial_sidebar_state="expanded")

st.markdown(
    """
<style>
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=Noto+Sans+SC:wght@400;500;600&display=swap');

:root{
  --bg:#FFFFFF;
  --panel:#F7FAFC;
  --text:#1A202C;
  --muted:#4A5568;
  --border:#E2E8F0;
  --primary:#2563EB;
  --shadow: 0 1px 2px rgba(16,24,40,.04), 0 6px 16px rgba(16,24,40,.06);
  --radius:12px;
}

.stApp { background: var(--bg); }
html, body, [class*="css"]  { font-family: "Inter","Noto Sans SC",-apple-system,BlinkMacSystemFont,"Segoe UI",Arial,sans-serif; color: var(--text); }

.block-container { max-width: 980px; padding-top: 1.6rem; padding-bottom: 3.5rem; }

/* Sidebar 更轻 */
section[data-testid="stSidebar"] { background: var(--panel); border-right: 1px solid var(--border); }

/* 标题层级 */
h1 { font-size: 2.15rem; font-weight: 600; letter-spacing: -0.4px; margin-bottom: 1.0rem; }
h2 { font-size: 1.25rem; font-weight: 600; color: var(--text); margin: 1.8rem 0 0.75rem; }
p, li { color: var(--muted); }

/* 按钮 */
.stButton > button { border-radius: 10px; }

/* 输入 */
.stTextInput input, .stTextArea textarea, .stSelectbox div[data-baseweb="select"] {
  border-radius: 10px !important;
}
.stTextInput input, .stTextArea textarea {
  border: 1px solid var(--border) !important;
  padding: 0.75rem !important;
}
.stTextInput input:focus, .stTextArea textarea:focus {
  border-color: var(--primary) !important;
  box-shadow: 0 0 0 3px rgba(37,99,235,.12) !important;
}

/* Tabs 产品化 */
.stTabs [data-baseweb="tab-list"] { gap: 8px; }
.stTabs [data-baseweb="tab"]{
  padding: 10px 14px;
  border-radius: 10px;
  background: transparent;
  border: 1px solid transparent;
}
.stTabs [aria-selected="true"]{
  background: rgba(37,99,235,.08);
  border: 1px solid rgba(37,99,235,.20);
}

/* “卡片感”：尽量使用 st.container(border=True) */
div[data-testid="stVerticalBlockBorderWrapper"]{
  border-radius: var(--radius);
  box-shadow: var(--shadow);
}
/* ========== Button radius override (works across Streamlit versions) ========== */

/* st.button */
div[data-testid="stButton"] button {
  border-radius: 10px !important;
}

/* st.form_submit_button */
div[data-testid="stFormSubmitButton"] button {
  border-radius: 10px !important;
}

/* BaseWeb buttons (Streamlit internal) */
button[data-testid^="baseButton-"] {
  border-radius: 10px !important;
}

/* 防止出现“圆形外圈/描边” */
div[data-testid="stButton"] button:focus,
div[data-testid="stButton"] button:focus-visible,
div[data-testid="stFormSubmitButton"] button:focus,
div[data-testid="stFormSubmitButton"] button:focus-visible,
button[data-testid^="baseButton-"]:focus,
button[data-testid^="baseButton-"]:focus-visible {
  outline: none !important;
  box-shadow: 0 0 0 3px rgba(37,99,235,.12) !important;
}

/* 次级按钮更轻，和 Tabs 更协调（不会像“圆圈”） */
button[data-testid="baseButton-secondary"],
div[data-testid="stButton"] button[kind="secondary"],
div[data-testid="stFormSubmitButton"] button[kind="secondary"] {
  background: #FFFFFF !important;
  border: 1px solid #E2E8F0 !important;
  color: #1A202C !important;
}

button[data-testid="baseButton-secondary"]:hover {
  background: rgba(37,99,235,.04) !important;
  border-color: rgba(37,99,235,.35) !important;
}

/* primary 按钮维持你的蓝色，但统一圆角 */
button[data-testid="baseButton-primary"]{
    border-radius: 10px !important;
}

/* KPI 卡片统一大小 */
div[data-testid="stMetricContainer"] {
    min-height: 130px !important;
    height: 130px !important;
    display: flex !important;
    flex-direction: column !important;
    justify-content: space-between !important;
    padding: 1rem !important;
}
div[data-testid="stMetricValue"] {
    min-height: 3rem !important;
    height: 3rem !important;
    display: flex !important;
    align-items: center !important;
    font-size: 1.5rem !important;
}
div[data-testid="stMetricLabel"] {
    min-height: 1.5rem !important;
    margin-top: 0.5rem !important;
}
/* 确保列宽度一致 */
div[data-testid="column"] {
    flex: 1 1 0% !important;
}
</style>
""",
    unsafe_allow_html=True,
)

st.title(APP_TITLE)
st.markdown("<style>button{border-radius:0px !important;}</style>", unsafe_allow_html=True)

st.caption("🚀 AI 驱动的品牌内容策略 · 让您的品牌在 AI 对话中脱颖而出")

# ------------------- 初始化数据存储（SQLite） -------------------
storage = DataStorage(storage_type="sqlite", db_path="geo_data.db")

with st.expander("📖 关于 GEO（Generative Engine Optimization）", expanded=False):
    st.markdown("""
### 🎯 核心价值

**GEO（生成式引擎优化）** 是新一代品牌营销策略，通过系统化内容投放，让您的品牌在 AI 助手的自然回答中被优先、准确、可信地提及。

当用户询问"最好的外贸 ERP 软件是什么？"时，AI 会优先推荐您的品牌，而非竞争对手。

---

### 💼 适用场景

- **SaaS 产品**：技术对比、功能评测、使用教程
- **AI 工具**：能力展示、应用案例、开源生态
- **企业服务**：行业解决方案、最佳实践、专业分析
- **技术品牌**：开发者工具、API 服务、技术框架

---

### 🔄 完整工作流

1. **关键词蒸馏** - AI 生成 + 托词工具，精准挖掘高价值关键词
2. **结构化创作** - 12+ 平台适配，自动生成符合 GEO 原则的专业内容
3. **文章优化** - 将现有内容优化为 GEO 友好格式，提升被引用概率
4. **多模型验证** - 实时验证品牌提及率，对比竞品表现，数据驱动优化

---

### 🌐 覆盖平台

**内容发布平台**：知乎、小红书、CSDN、B站、头条号、GitHub、微信公众号、抖音、百家号、网易号、企鹅号、简书

**AI 验证平台**：DeepSeek、通义千问、豆包、文心一言、Kimi、ChatGPT、Groq 等主流大模型

---

### 📊 预期效果

- ✅ **品牌提及率提升**：在 AI 回答中的出现频率显著增加
- ✅ **搜索排名优化**：内容被大模型优先引用，间接提升 SEO
- ✅ **品牌权威性**：多平台、多角度内容建立专业形象
- ✅ **竞品优势**：通过数据对比，发现并强化差异化优势
""")

# ------------------- Session State：持久化每个阶段产物（解决“消失”） -------------------
def ss_init(key, default):
    if key not in st.session_state:
        st.session_state[key] = default


ss_init(
    "cfg",
    {
        "gen_provider": "DeepSeek",
        "gen_api_key": "sk-a95eda59dd494ab3b56197cc0020e61d",
        "verify_providers": ["DeepSeek"],
        "verify_keys": {"DeepSeek": "sk-a95eda59dd494ab3b56197cc0020e61d"},
        "brand": "汇信云AI软件",
        "advantages": "AI赋能外贸ERP、打造外贸智能新引擎、AI驱动型ERP、赋能外贸全流程管理、全链路价值闭环",
        "competitors": "南北软件\n睿贝软件\n孚盟软件\n小满软件",
        "temperature": 0.7,
    },
)
ss_init("cfg_applied", False)
ss_init("cfg_valid", False)
ss_init("cfg_errors", [])

# 模块1：关键词
ss_init("keywords", [])
ss_init("kw_last_num", 40)
ss_init("kw_generation_mode", "AI生成")  # 生成模式：AI生成 / 托词工具 / 混合模式
ss_init("wordbanks", None)  # 词库字典
ss_init("keyword_tool", KeywordTool())  # 托词工具实例

# 模块2：内容
ss_init("generated_contents", [])  # list[dict]
ss_init("zip_bytes", None)
ss_init("zip_filename", "")

# 模块3：文章优化
ss_init("optimized_article", "")
ss_init("opt_changes", "")
ss_init("opt_platform", "通用优化")

# 模块4：验证
ss_init("verify_combined", None)  # DataFrame or None
ss_init("verify_last_queries", "")

# ------------------- 工具函数 -------------------
INVALID_FS_CHARS = r'<>:"/\\|?*\n\r\t'


def sanitize_filename(name: str, max_len: int = 80) -> str:
    if not name:
        return "untitled"
    name = name.strip()
    name = re.sub(rf"[{re.escape(INVALID_FS_CHARS)}]", "_", name)
    name = re.sub(r"_+", "_", name).strip("_")
    return name[:max_len] if len(name) > max_len else name


def safe_decode_uploaded(uploaded) -> str:
    if not uploaded:
        return ""
    b = uploaded.getvalue()
    for enc in ("utf-8-sig", "utf-8", "gb18030"):
        try:
            return b.decode(enc)
        except Exception:
            pass
    return b.decode("utf-8", errors="replace")


def extract_json_array(text: str):
    """从模型输出中抽取 JSON 数组（JsonOutputParser 失败时兜底）。"""
    if not text:
        return None
    m = re.search(r"\[[\s\S]*\]", text)
    if not m:
        return None
    try:
        return json.loads(m.group(0))
    except Exception:
        return None


def validate_cfg(cfg: dict):
    """保留你原本的“必须填写所有 API Key”约束，但不 st.stop：改为禁用按钮 + 提示。"""
    errors = []
    if not cfg.get("gen_api_key", "").strip():
        errors.append("生成&优化 LLM 的 API Key 未填写")

    verify_providers = cfg.get("verify_providers", [])
    verify_keys = cfg.get("verify_keys", {})
    if not verify_providers:
        errors.append("至少选择一个验证模型")

    for vp in verify_providers:
        if not verify_keys.get(vp, "").strip():
            errors.append(f"验证模型 {vp} 的 API Key 未填写")

    return (len(errors) == 0), errors


def model_defaults(provider: str) -> str:
    if provider == "DeepSeek":
        return "deepseek-chat"
    if provider == "OpenAI (GPT)":
        return "gpt-4o-mini"
    if provider == "Tongyi (通义千问)":
        return "qwen-max"
    if provider == "Groq":
        return "llama3-70b-8192"
    if provider == "Moonshot (Kimi)":
        return "moonshot-v1-128k"
    if provider == "豆包（字节跳动）":
        return ""  # 豆包使用 ENDPOINT_ID，不需要模型名
    if provider == "文心一言（百度）":
        return "ernie-bot-turbo"
    return ""


# ------------------- 缓存 LLM 客户端（显著降低“频繁 Loading”） -------------------
@st.cache_resource(show_spinner=False)
def build_llm(provider: str, api_key: str, model: str, temperature: float):
    """
    - 使用 cache_resource 缓存客户端，避免每次 rerun 重建
    - Tongyi / Moonshot：保留你原功能路径，同时提供更稳的 import 兜底
    """
    if provider == "DeepSeek":
        from langchain_deepseek import ChatDeepSeek

        return ChatDeepSeek(api_key=api_key, model=model, temperature=temperature)

    if provider == "OpenAI (GPT)":
        from langchain_openai import ChatOpenAI

        return ChatOpenAI(api_key=api_key, model=model, temperature=temperature)

    if provider == "Tongyi (通义千问)":
        try:
            from langchain_community.chat_models import ChatTongyi

            return ChatTongyi(api_key=api_key, model=model, model_kwargs={"temperature": temperature})
        except Exception:
            from langchain_aliyun import ChatTongyi  # type: ignore

            return ChatTongyi(api_key=api_key, model=model, temperature=temperature)

    if provider == "Groq":
        from langchain_groq import ChatGroq

        return ChatGroq(api_key=api_key, model=model, temperature=temperature)

    if provider == "Moonshot (Kimi)":
        try:
            from langchain_moonshot import ChatMoonshot  # type: ignore

            return ChatMoonshot(api_key=api_key, model=model, temperature=temperature)
        except Exception:
            from langchain_community.chat_models import MoonshotChat  # type: ignore

            return MoonshotChat(api_key=api_key, model=model, temperature=temperature)

    if provider == "豆包（字节跳动）":
        try:
            # 尝试使用 volcengine-python-sdk[ark]
            from volcengine.ark import Ark
            from langchain_core.language_models.chat_models import BaseChatModel
            from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
            from langchain_core.outputs import ChatGeneration, ChatResult
            from typing import List, Optional, Any
            
            class ChatDoubao(BaseChatModel):
                """豆包聊天模型封装（LangChain 兼容）"""
                volc_ak: str
                volc_sk: str
                endpoint_id: str
                temperature: float = 0.7
                
                def __init__(self, volc_ak: str, volc_sk: str, endpoint_id: str, temperature: float = 0.7):
                    super().__init__(temperature=temperature)
                    self.volc_ak = volc_ak
                    self.volc_sk = volc_sk
                    self.endpoint_id = endpoint_id
                    self.temperature = temperature
                    self.client = Ark(ak=volc_ak, sk=volc_sk)
                
                def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[Any] = None, **kwargs: Any) -> ChatResult:
                    # 转换消息格式
                    volc_messages = []
                    for msg in messages:
                        if isinstance(msg, SystemMessage):
                            volc_messages.append({"role": "system", "content": msg.content})
                        elif isinstance(msg, HumanMessage):
                            volc_messages.append({"role": "user", "content": msg.content})
                        elif isinstance(msg, AIMessage):
                            volc_messages.append({"role": "assistant", "content": msg.content})
                        else:
                            volc_messages.append({"role": "user", "content": str(msg.content)})
                    
                    response = self.client.chat.completions.create(
                        model=self.endpoint_id,
                        messages=volc_messages,
                        temperature=self.temperature,
                    )
                    
                    ai_message = AIMessage(content=response.choices[0].message.content)
                    return ChatResult(generations=[ChatGeneration(message=ai_message)])
                
                @property
                def _llm_type(self) -> str:
                    return "doubao"
            
            # 豆包的 api_key 格式：access_key:secret_key:endpoint_id
            parts = api_key.split(":")
            if len(parts) >= 3:
                return ChatDoubao(volc_ak=parts[0], volc_sk=parts[1], endpoint_id=parts[2], temperature=temperature)
            else:
                raise ValueError("豆包 API Key 格式错误，应为：access_key:secret_key:endpoint_id（用冒号分隔）")
        except ImportError:
            # 尝试其他导入方式
            try:
                from volcenginesdkarkruntime import Ark
                # 使用相同的 ChatDoubao 类
                from langchain_core.language_models.chat_models import BaseChatModel
                from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
                from langchain_core.outputs import ChatGeneration, ChatResult
                from typing import List, Optional, Any
                
                class ChatDoubao(BaseChatModel):
                    """豆包聊天模型封装（LangChain 兼容）"""
                    volc_ak: str
                    volc_sk: str
                    endpoint_id: str
                    temperature: float = 0.7
                    
                    def __init__(self, volc_ak: str, volc_sk: str, endpoint_id: str, temperature: float = 0.7):
                        super().__init__(temperature=temperature)
                        self.volc_ak = volc_ak
                        self.volc_sk = volc_sk
                        self.endpoint_id = endpoint_id
                        self.temperature = temperature
                        self.client = Ark(ak=volc_ak, sk=volc_sk)
                    
                    def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[Any] = None, **kwargs: Any) -> ChatResult:
                        volc_messages = []
                        for msg in messages:
                            if isinstance(msg, SystemMessage):
                                volc_messages.append({"role": "system", "content": msg.content})
                            elif isinstance(msg, HumanMessage):
                                volc_messages.append({"role": "user", "content": msg.content})
                            elif isinstance(msg, AIMessage):
                                volc_messages.append({"role": "assistant", "content": msg.content})
                            else:
                                volc_messages.append({"role": "user", "content": str(msg.content)})
                        
                        response = self.client.chat.completions.create(
                            model=self.endpoint_id,
                            messages=volc_messages,
                            temperature=self.temperature,
                        )
                        
                        ai_message = AIMessage(content=response.choices[0].message.content)
                        return ChatResult(generations=[ChatGeneration(message=ai_message)])
                    
                    @property
                    def _llm_type(self) -> str:
                        return "doubao"
                
                parts = api_key.split(":")
                if len(parts) >= 3:
                    return ChatDoubao(volc_ak=parts[0], volc_sk=parts[1], endpoint_id=parts[2], temperature=temperature)
                else:
                    raise ValueError("豆包 API Key 格式错误，应为：access_key:secret_key:endpoint_id（用冒号分隔）")
            except ImportError as e:
                raise ValueError(f"豆包初始化失败：缺少依赖库。请运行：pip install 'volcengine-python-sdk[ark]'。错误：{e}")
        except Exception as e:
            raise ValueError(f"豆包初始化失败：{e}。请确保 API Key 格式为：access_key:secret_key:endpoint_id")

    if provider == "文心一言（百度）":
        # 文心一言的 api_key 格式：app_key:app_secret
        parts = api_key.split(":")
        if len(parts) != 2:
            raise ValueError("文心一言 API Key 格式错误，应为：app_key:app_secret（用冒号分隔）")
        
        app_key, app_secret = parts
        
        # 优先使用 langchain-community 的千帆接口（已包含在依赖中）
        try:
            from langchain_community.chat_models import QianfanChatEndpoint
            import os
            
            os.environ["QIANFAN_AK"] = app_key
            os.environ["QIANFAN_SK"] = app_secret
            return QianfanChatEndpoint(
                model=model if model else "ernie-bot-turbo",
                temperature=temperature,
            )
        except ImportError:
            # 备选方案：尝试 langchain-wenxin
            try:
                from langchain_wenxin import ChatWenxin
                return ChatWenxin(
                    baidu_api_key=app_key,
                    baidu_secret_key=app_secret,
                    model=model if model else "ernie-bot-turbo",
                    temperature=temperature,
                )
            except ImportError as e:
                raise ValueError(f"文心一言初始化失败：缺少依赖库。请运行：pip install qianfan（或使用已安装的 langchain-community）。错误：{e}")
        except Exception as e:
            raise ValueError(f"文心一言初始化失败：{e}")

    raise ValueError(f"Unknown provider: {provider}")


# ------------------- 侧边栏：全局配置（用 form 降低 rerun） -------------------
with st.sidebar:
    st.header("全局配置")

    with st.form("global_config_form", clear_on_submit=False):
        gen_provider = st.selectbox(
            "生成&优化 LLM",
            ["DeepSeek", "OpenAI (GPT)", "Tongyi (通义千问)", "Groq", "Moonshot (Kimi)", "豆包（字节跳动）", "文心一言（百度）"],
            index=["DeepSeek", "OpenAI (GPT)", "Tongyi (通义千问)", "Groq", "Moonshot (Kimi)", "豆包（字节跳动）", "文心一言（百度）"].index(
                st.session_state.cfg["gen_provider"]
            ) if st.session_state.cfg["gen_provider"] in ["DeepSeek", "OpenAI (GPT)", "Tongyi (通义千问)", "Groq", "Moonshot (Kimi)", "豆包（字节跳动）", "文心一言（百度）"] else 0,
            key="sb_gen_provider",
        )
        # API Key 输入提示
        if gen_provider == "豆包（字节跳动）":
            api_key_help = "格式：access_key:secret_key:endpoint_id（用冒号分隔）"
        elif gen_provider == "文心一言（百度）":
            api_key_help = "格式：app_key:app_secret（用冒号分隔）"
        else:
            api_key_help = ""
        
        gen_api_key = st.text_input(
            f"{gen_provider} API Key（生成&优化用）",
            type="password",
            value=st.session_state.cfg.get("gen_api_key", ""),
            key="sb_gen_api_key",
            help=api_key_help if api_key_help else None,
        )

        st.markdown("### 验证用LLM（多选）")
        verify_providers = st.multiselect(
            "选择验证模型",
            ["DeepSeek", "OpenAI (GPT)", "Tongyi (通义千问)", "Groq", "Moonshot (Kimi)", "豆包（字节跳动）", "文心一言（百度）"],
            default=st.session_state.cfg.get("verify_providers", []),
            key="sb_verify_providers",
        )

        verify_keys = {}
        old_keys = st.session_state.cfg.get("verify_keys", {})
        for vp in verify_providers:
            # API Key 输入提示
            if vp == "豆包（字节跳动）":
                api_key_help = "格式：access_key:secret_key:endpoint_id（用冒号分隔）"
            elif vp == "文心一言（百度）":
                api_key_help = "格式：app_key:app_secret（用冒号分隔）"
            else:
                api_key_help = None
            
            verify_keys[vp] = st.text_input(
                f"{vp} API Key（验证用）",
                type="password",
                value=old_keys.get(vp, ""),
                key=f"sb_verify_key_{vp}",
                help=api_key_help if api_key_help else None,
            )

        st.markdown("---")
        brand = st.text_input("主品牌名称", value=st.session_state.cfg.get("brand", "汇信云AI软件"), key="sb_brand")
        advantages = st.text_area(
            "核心优势/卖点（AI专属）",
            value=st.session_state.cfg.get(
                "advantages", "AI赋能外贸ERP、打造外贸智能新引擎、AI驱动型ERP、赋能外贸全流程管理、全链路价值闭环"
            ),
            height=140,
            key="sb_advantages",
        )
        competitors = st.text_area(
            "竞品品牌（每行一个，用于对比验证）",
            value=st.session_state.cfg.get("competitors", "南北软件\n睿贝软件\n孚盟软件\n小满软件"),
            height=120,
            key="sb_competitors",
        )

        st.markdown("---")
        temperature = st.slider(
            "生成温度（更稳→更低）",
            0.0,
            1.0,
            float(st.session_state.cfg.get("temperature", 0.7)),
            0.05,
            key="sb_temperature",
        )

        apply_cfg = st.form_submit_button("应用配置（推荐）", use_container_width=True)

    if apply_cfg or not st.session_state.cfg_applied:
        st.session_state.cfg = {
            "gen_provider": gen_provider,
            "gen_api_key": gen_api_key,
            "verify_providers": verify_providers,
            "verify_keys": verify_keys,
            "brand": brand,
            "advantages": advantages,
            "competitors": competitors,
            "temperature": temperature,
        }
        st.session_state.cfg_applied = True

        ok, errs = validate_cfg(st.session_state.cfg)
        st.session_state.cfg_valid = ok
        st.session_state.cfg_errors = errs

    if not st.session_state.cfg_valid:
        st.warning("配置未满足运行条件：\n- " + "\n- ".join(st.session_state.cfg_errors))
    else:
        st.success("配置已就绪，可运行全部模块。")

    st.markdown("---")
    if st.button("重置全部结果（不删除配置）", use_container_width=True, key="sb_reset_all"):
        st.session_state.keywords = []
        st.session_state.generated_contents = []
        st.session_state.zip_bytes = None
        st.session_state.zip_filename = ""
        st.session_state.optimized_article = ""
        st.session_state.opt_changes = ""
        st.session_state.verify_combined = None
        st.toast("已重置全部结果。")

    st.caption("闭环：关键词 → 创作 → 优化 → 验证")

cfg = st.session_state.cfg
brand = cfg["brand"]
advantages = cfg["advantages"]
temperature = float(cfg.get("temperature", 0.7))

competitor_list = [c.strip() for c in cfg["competitors"].split("\n") if c.strip()]
_seen = set()
clean_competitors = []
for c in competitor_list:
    cl = c.lower()
    if cl == brand.lower():
        continue
    if cl in _seen:
        continue
    _seen.add(cl)
    clean_competitors.append(c)
competitor_list = clean_competitors

# ------------------- 初始化 LLM（仅在 cfg_valid 时；且 build_llm 已缓存） -------------------
gen_llm = None
verify_llms = {}

if st.session_state.cfg_valid:
    try:
        gen_llm = build_llm(cfg["gen_provider"], cfg["gen_api_key"], model_defaults(cfg["gen_provider"]), temperature)
    except Exception as e:
        st.error(f"生成LLM加载失败：{e}")

    for vp in cfg["verify_providers"]:
        key = cfg["verify_keys"].get(vp, "").strip()
        if not key:
            continue
        try:
            verify_llms[vp] = build_llm(vp, key, model_defaults(vp), temperature)
        except Exception as e:
            st.error(f"{vp}验证LLM加载失败：{e}")

# ------------------- KPI 总览（极简但更像产品） -------------------
k1, k2, k3, k4 = st.columns(4)
try:
    k1.metric("关键词", len(st.session_state.keywords), border=True)
    k2.metric("内容包", len(st.session_state.generated_contents), border=True)
    k3.metric("文章优化", "已生成" if bool(st.session_state.optimized_article) else "未生成", border=True)
    k4.metric("验证结果", "已生成" if st.session_state.verify_combined is not None else "未生成", border=True)
except TypeError:
    k1.metric("关键词", len(st.session_state.keywords))
    k2.metric("内容包", len(st.session_state.generated_contents))
    k3.metric("文章优化", "已生成" if bool(st.session_state.optimized_article) else "未生成")
    k4.metric("验证结果", "已生成" if st.session_state.verify_combined is not None else "未生成")

st.markdown("---")

# ------------------- 主导航：Tabs（流程更清晰） -------------------
tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(["1 关键词蒸馏", "2 自动创作", "3 文章优化", "4 多模型验证", "5 历史记录", "6 AI 数据报表"])

# =======================
# Tab1：关键词蒸馏
# =======================
with tab1:
    # 生成模式选择
    generation_mode = st.radio(
        "生成模式",
        ["AI生成", "托词工具", "混合模式"],
        index=["AI生成", "托词工具", "混合模式"].index(st.session_state.kw_generation_mode),
        horizontal=True,
        key="kw_mode_radio"
    )
    st.session_state.kw_generation_mode = generation_mode
    
    # 词库管理和组合模式选择（托词工具和混合模式需要）
    if generation_mode in ["托词工具", "混合模式"]:
        # 初始化词库
        if st.session_state.wordbanks is None:
            st.session_state.wordbanks = st.session_state.keyword_tool.load_wordbanks()
        
        # 初始化组合模式选择
        ss_init("selected_patterns", list(st.session_state.keyword_tool.combination_patterns))
        
        wordbanks = st.session_state.wordbanks
        
        # 组合模式选择
        with st.container(border=True):
            st.markdown("**组合模式选择**")
            pattern_descriptions = st.session_state.keyword_tool.get_pattern_descriptions()
            all_patterns = st.session_state.keyword_tool.combination_patterns
            
            # 显示所有可用模式
            pattern_options = []
            for pattern in all_patterns:
                pattern_str = "+".join(pattern)
                desc = pattern_descriptions.get(pattern_str, pattern_str)
                pattern_options.append((pattern_str, pattern, desc))
            
            # 多选组合模式
            selected_pattern_strs = st.multiselect(
                "选择要使用的组合模式（可多选）",
                options=[opt[0] for opt in pattern_options],
                default=[opt[0] for opt in pattern_options if opt[1] in st.session_state.selected_patterns],
                key="kw_pattern_select",
                help="选择要使用的组合模式，至少选择一个"
            )
            
            # 更新选中的模式
            selected_patterns = []
            for pattern_str, pattern, desc in pattern_options:
                if pattern_str in selected_pattern_strs:
                    selected_patterns.append(pattern)
            st.session_state.selected_patterns = selected_patterns if selected_patterns else all_patterns
            
            # 显示模式说明
            with st.expander("组合模式说明", expanded=False):
                for pattern_str, pattern, desc in pattern_options:
                    st.markdown(f"**{pattern_str}**: {' + '.join(desc)}")
        
        # 词库管理
        with st.expander("词库管理", expanded=False):
            # 词库编辑
            col1, col2 = st.columns([1, 1])
            with col1:
                st.markdown("**词库编辑**")
                bank_types = list(wordbanks.keys())
                selected_bank = st.selectbox("选择词库类型", bank_types, key="kw_bank_select")
                
                # 显示当前词库内容
                current_words = wordbanks[selected_bank]
                edited_words = st.text_area(
                    f"{selected_bank} 词汇（每行一个）",
                    "\n".join(current_words),
                    height=150,
                    key=f"kw_bank_edit_{selected_bank}"
                )
                
                if st.button("更新词库", key=f"kw_update_{selected_bank}"):
                    new_words = [w.strip() for w in edited_words.split("\n") if w.strip()]
                    wordbanks[selected_bank] = new_words
                    st.session_state.wordbanks = wordbanks
                    st.success(f"{selected_bank} 已更新（{len(new_words)} 个词汇）")
            
            with col2:
                st.markdown("**词库导入/导出**")
                # 导出
                wordbanks_json = json.dumps(wordbanks, ensure_ascii=False, indent=2)
                st.download_button(
                    "导出词库（JSON）",
                    wordbanks_json,
                    "wordbanks.json",
                    "application/json",
                    use_container_width=True,
                    key="kw_export_json"
                )
                
                # 导入
                uploaded_wordbanks = st.file_uploader(
                    "导入词库（JSON）",
                    type=["json"],
                    key="kw_import_json"
                )
                if uploaded_wordbanks:
                    try:
                        imported = json.loads(uploaded_wordbanks.read().decode('utf-8'))
                        if isinstance(imported, dict):
                            st.session_state.wordbanks = imported
                            st.success("词库导入成功！")
                            st.rerun()
                    except Exception as e:
                        st.error(f"导入失败：{e}")
                
                # 重置为默认词库
                if st.button("重置为默认词库", use_container_width=True, key="kw_reset_banks"):
                    st.session_state.wordbanks = st.session_state.keyword_tool.load_wordbanks()
                    st.success("已重置为默认词库")
                    st.rerun()
    
    # 生成控制
    with st.container(border=True):
        c1, c2, c3 = st.columns([2, 1, 1])
        with c1:
            st.session_state.kw_last_num = st.slider(
                "生成数量", 10, 100, st.session_state.kw_last_num, key="kw_num"
            )
        with c2:
            # 根据模式调整禁用条件
            if generation_mode == "托词工具":
                run_kw_disabled = False  # 托词工具不需要 LLM
            else:
                run_kw_disabled = (not st.session_state.cfg_valid) or (gen_llm is None)
            
            run_kw = st.button(
                "生成关键词",
                type="primary",
                use_container_width=True,
                disabled=run_kw_disabled,
                key="kw_run",
            )
        with c3:
            if st.button("清空本模块结果", use_container_width=True, key="kw_clear"):
                st.session_state.keywords = []
                st.toast("关键词已清空。")

        if run_kw:
            keywords = []
            
            if generation_mode == "AI生成":
                # 原有 AI 生成逻辑
                keyword_prompt = PromptTemplate.from_template(
                    """
你是AI领域GEO专家，目标是提升品牌在大模型自然回答中的提及率。

【输入】
- 品牌：{brand}
- 核心优势：{advantages}
- 数量：{num_keywords}

【要求（GEO本质）】
1) 覆盖AI用户真实搜索意图：模型对比、推理性能、多模态、实时知识、开源生态、部署成本、行业应用、评测基准
2) 品牌词占比约30%（护城河），70%泛词（新增流量）
3) 口语化、自然、12–28字
4) 去重、均衡意图
5) 输出严格JSON数组：["问题1","问题2",...]

【开始输出JSON数组】
"""
                )

                chain_json = keyword_prompt | gen_llm | JsonOutputParser()
                chain_text = keyword_prompt | gen_llm | StrOutputParser()

                with st.spinner("AI生成中..."):
                    try:
                        result = chain_json.invoke(
                            {"brand": brand, "advantages": advantages, "num_keywords": st.session_state.kw_last_num}
                        )
                        keywords = result if isinstance(result, list) else []
                    except Exception:
                        raw = chain_text.invoke(
                            {"brand": brand, "advantages": advantages, "num_keywords": st.session_state.kw_last_num}
                        )
                        keywords = extract_json_array(raw) or []
            
            elif generation_mode == "托词工具":
                # 托词工具生成
                with st.spinner("组合生成中..."):
                    wordbanks = st.session_state.wordbanks or st.session_state.keyword_tool.load_wordbanks()
                    selected_patterns = st.session_state.get("selected_patterns", st.session_state.keyword_tool.combination_patterns)
                    
                    # 检查词库是否为空
                    empty_banks = [k for k, v in wordbanks.items() if not v]
                    if empty_banks:
                        st.warning(f"以下词库为空，请先添加词汇：{', '.join(empty_banks)}")
                    
                    keywords = st.session_state.keyword_tool.generate_combinations(
                        wordbanks=wordbanks,
                        patterns=selected_patterns,
                        max_results=st.session_state.kw_last_num,
                        similarity_threshold=0.8
                    )
            
            elif generation_mode == "混合模式":
                # 混合模式：先托词生成，再 LLM 润色
                with st.spinner("托词生成中..."):
                    wordbanks = st.session_state.wordbanks or st.session_state.keyword_tool.load_wordbanks()
                    selected_patterns = st.session_state.get("selected_patterns", st.session_state.keyword_tool.combination_patterns)
                    
                    # 检查词库是否为空
                    empty_banks = [k for k, v in wordbanks.items() if not v]
                    if empty_banks:
                        st.warning(f"以下词库为空，请先添加词汇：{', '.join(empty_banks)}")
                    
                    raw_keywords = st.session_state.keyword_tool.generate_combinations(
                        wordbanks=wordbanks,
                        patterns=selected_patterns,
                        max_results=st.session_state.kw_last_num * 2,  # 生成更多，因为会去重
                        similarity_threshold=0.8
                    )
                
                if raw_keywords and gen_llm:
                    with st.spinner("LLM 润色中..."):
                        # 使用 LLM 润色
                        from langchain_core.prompts import PromptTemplate as PT
                        polish_template = PT.from_template("{input}")
                        polish_chain = polish_template | gen_llm | StrOutputParser()
                        keywords = st.session_state.keyword_tool.polish_with_llm(
                            keywords=raw_keywords,
                            llm_chain=polish_chain,
                            brand=brand,
                            max_polish=min(len(raw_keywords), st.session_state.kw_last_num)
                        )
                else:
                    keywords = raw_keywords

            # 清理和去重
            cleaned, seen = [], set()
            for k in keywords:
                if not isinstance(k, str):
                    continue
                kk = k.strip()
                if not kk:
                    continue
                kl = kk.lower()
                if kl in seen:
                    continue
                seen.add(kl)
                cleaned.append(kk)
            
            # 限制数量
            cleaned = cleaned[:st.session_state.kw_last_num]

            if cleaned:
                st.session_state.keywords = cleaned
                # 保存到数据库
                try:
                    storage.save_keywords(cleaned, brand)
                except Exception as e:
                    st.warning(f"关键词已生成，但保存到数据库时出错：{e}")
                st.success(f"生成完成（{len(cleaned)} 条）")
            else:
                error_msg = "生成失败，可能的原因：\n"
                if generation_mode in ["托词工具", "混合模式"]:
                    wordbanks = st.session_state.wordbanks or st.session_state.keyword_tool.load_wordbanks()
                    empty_banks = [k for k, v in wordbanks.items() if not v]
                    if empty_banks:
                        error_msg += f"- 以下词库为空：{', '.join(empty_banks)}\n"
                    if not st.session_state.get("selected_patterns"):
                        error_msg += "- 未选择任何组合模式\n"
                    error_msg += "- 请检查词库配置或选择更多组合模式"
                else:
                    error_msg += "- 请检查 API Key 配置或重试"
                st.error(error_msg)

    if st.session_state.keywords:
        df = pd.DataFrame(st.session_state.keywords, columns=["长尾关键词/问题"])
        st.dataframe(df, use_container_width=True, hide_index=True)
        st.download_button(
            "下载关键词CSV",
            df.to_csv(index=False, encoding="utf-8-sig"),
            f"{sanitize_filename(brand,40)}_keywords.csv",
            mime="text/csv",
            use_container_width=True,
            key="kw_dl_csv",
        )
    else:
        st.info("在左侧完成配置后，点击“生成关键词”。")

# =======================
# Tab2：自动创作内容（含批量 ZIP / GitHub 模板）
# =======================
with tab2:
    top_l, top_r = st.columns([3, 1])
    with top_r:
        if st.button("清空本模块结果", use_container_width=True, key="content_clear"):
            st.session_state.generated_contents = []
            st.session_state.zip_bytes = None
            st.session_state.zip_filename = ""
            st.toast("创作内容已清空。")

    if not st.session_state.keywords:
        st.info("请先在【1 关键词蒸馏】生成关键词。")
    else:
        with st.container(border=True):
            with st.form("content_form", clear_on_submit=False):
                mode = st.radio("生成模式", ["单篇生成", "批量生成"], horizontal=True, key="content_mode")

                platforms = [
                    "知乎（专业问答）",
                    "小红书（生活种草）",
                    "CSDN（技术博客）",
                    "B站（视频脚本）",
                    "头条号（资讯软文）",
                    "GitHub（README/文档）",
                    "微信公众号（长文）",
                    "抖音图文（短内容）",
                    "百家号（资讯）",
                    "网易号（资讯）",
                    "企鹅号（资讯）",
                    "简书（文艺）",
                ]

                if mode == "单篇生成":
                    col1, col2 = st.columns([2, 1])
                    with col1:
                        selected_keyword = st.selectbox("选择关键词", st.session_state.keywords, key="content_kw_single")
                    with col2:
                        platform = st.selectbox("平台", platforms, key="content_platform_single")
                    keywords_to_generate = [(selected_keyword, platform)]
                else:
                    selected_keywords = st.multiselect(
                        "选择关键词（批量）", st.session_state.keywords, key="content_kw_multi"
                    )
                    platform = st.selectbox("统一平台", platforms, key="content_platform_multi")
                    keywords_to_generate = [(kw, platform) for kw in selected_keywords]

                run_content_disabled = (not st.session_state.cfg_valid) or (gen_llm is None) or (not keywords_to_generate)
                run_content = st.form_submit_button(
                    "生成内容", use_container_width=True, disabled=run_content_disabled
                )

            if run_content:
                st.session_state.generated_contents = []
                st.session_state.zip_bytes = None
                st.session_state.zip_filename = ""
                st.session_state.content_scores = {}  # 存储内容评分

                contents = []
                zip_buffer = io.BytesIO()
                scorer = ContentScorer()  # 初始化评分器

                with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
                    for keyword, plat in keywords_to_generate:
                        with st.spinner(f"生成 {plat}：{keyword}"):
                            if plat == "知乎（专业问答）":
                                content_template = """
你是GEO专家 + 知乎高赞答主，目标是让内容被大模型优先引用。
【问题】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 结论摘要（80-120字）
2) 结构化：小标题、清单、FAQ
3) 自然提及品牌2-4次，先通用标准再品牌适用
4) 避免编造，来源用占位建议
5) 包含选择清单、适用/不适用、6个FAQ、3步行动
【格式】清晰标题顺序输出
【开始】
"""
                            elif plat == "小红书（生活种草）":
                                content_template = """
你是GEO专家 + 小红书作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个标题备选
2) 强场景开头
3) 痛点3点、对比例表5个、使用体验（3亮点+2不足）
4) 适合/不适合各3条、避坑5条
5) 结尾8条搜索词
6) 自然品牌提及
【格式】标题-正文-标签-搜索词
【开始】
"""
                            elif plat == "CSDN（技术博客）":
                                content_template = """
你是GEO专家 + CSDN博主。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个技术标题
2) 摘要 + 背景 + 框架 + {brand}案例（匿名）
3) 代码占位 + 注意事项 + 来源建议
4) 专业、自然提及品牌
【开始】
"""
                            elif plat == "B站（视频脚本）":
                                content_template = """
你是GEO专家 + B站UP主。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 5个点击标题
2) 开场钩子 + 时间戳分段 + 画面建议
3) {brand}演示部分
4) 描述：时间戳 + 10搜索词 + 15标签
【开始】
"""
                            elif plat == "头条号（资讯软文）":
                                content_template = """
你是GEO专家 + 头条作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 4个热点标题
2) 列表结构（Top/步骤）
3) 自然推荐品牌
4) 数据占位
【开始】
"""
                            elif plat == "微信公众号（长文）":
                                content_template = """
你是GEO专家 + 微信公众号作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个吸引人的标题（适合公众号）
2) 开头：场景化引入、痛点共鸣
3) 正文：结构化分段、小标题清晰、配图建议（用【配图：xxx】标注）
4) 自然提及品牌3-5次，先讲通用标准再推荐品牌
5) 结尾：总结+行动号召+关注引导
6) 适合公众号的排版：段落分明、重点加粗提示、适当使用emoji
7) 字数：1500-3000字
【格式】清晰分段，标注配图位置
【开始】
"""
                            elif plat == "抖音图文（短内容）":
                                content_template = """
你是GEO专家 + 抖音创作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 5个爆款标题（吸引点击）
2) 正文：短小精悍，200-500字，适合图文形式
3) 图片建议：每段配图说明（用【配图：xxx】标注），至少3-5张图
4) 结构：痛点→解决方案→品牌推荐→行动
5) 语言：口语化、有节奏感、适合短视频风格
6) 结尾：互动引导（点赞、评论、关注）
7) 标签：10-15个相关话题标签
【格式】标题-正文（分段配图建议）-标签
【开始】
"""
                            elif plat == "百家号（资讯）":
                                content_template = """
你是GEO专家 + 百家号作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个SEO友好标题
2) 开头：热点引入或数据开头
3) 正文：信息密度高、结构化清晰、小标题明确
4) 自然提及品牌2-4次
5) 适合百度搜索：关键词自然分布、长尾词覆盖
6) 字数：800-2000字
7) 结尾：总结+相关推荐
【格式】标题-正文-总结
【开始】
"""
                            elif plat == "网易号（资讯）":
                                content_template = """
你是GEO专家 + 网易号作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个吸引人的标题
2) 开头：新闻式或故事式引入
3) 正文：客观专业、数据支撑、案例说明
4) 自然提及品牌2-3次，保持客观中立
5) 适合网易用户：理性分析、深度内容
6) 字数：1000-2500字
7) 结尾：观点总结+延伸思考
【格式】标题-正文-总结
【开始】
"""
                            elif plat == "企鹅号（资讯）":
                                content_template = """
你是GEO专家 + 企鹅号作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 3个热点标题
2) 开头：话题引入或疑问开头
3) 正文：通俗易懂、案例丰富、对比清晰
4) 自然提及品牌2-4次
5) 适合腾讯用户：内容轻松、可读性强
6) 字数：800-2000字
7) 结尾：总结+互动引导
【格式】标题-正文-总结
【开始】
"""
                            elif plat == "简书（文艺）":
                                content_template = """
你是GEO专家 + 简书作者。
【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}
【要求】
1) 2个文艺范标题
2) 开头：故事化或情感化引入
3) 正文：文笔优美、有温度、有思考深度
4) 自然提及品牌2-3次，融入故事或体验
5) 适合简书用户：文艺风格、深度思考
6) 字数：1500-3000字
7) 结尾：感悟总结+延伸思考
【格式】标题-正文-感悟
【开始】
"""
                            else:
                                content_template = """
你是GEO专家 + 开源项目维护者。
生成GitHub README或项目文档，目标是被大模型（尤其是代码模型）优先引用。

【关键词】{keyword}
【品牌】{brand}
【优势】{advantages}

【要求】
1) 标准README结构：标题、描述、特性清单、安装步骤、用法示例（代码块）
2) {brand}自然集成作为核心工具/模型
3) 加入徽章占位、贡献指南、引用建议
4) 代码块真实占位，避免编造
5) 自然提及品牌2-4次

【格式】Markdown完整输出

【开始】
"""

                            prompt = PromptTemplate.from_template(content_template)
                            chain = prompt | gen_llm | StrOutputParser()
                            content = chain.invoke({"keyword": keyword, "brand": brand, "advantages": advantages})

                            # 微信公众号需要特殊处理（可选：Markdown转HTML）
                            if plat == "微信公众号（长文）":
                                # 可以在这里添加 Markdown 转 HTML 的逻辑
                                # 目前先保持原样，用户可以在公众号编辑器中使用
                                pass

                            safe_kw = sanitize_filename(keyword, 60)
                            # 确定文件扩展名
                            if plat == "GitHub（README/文档）":
                                ext = "md"
                            elif plat in ["微信公众号（长文）", "百家号（资讯）", "网易号（资讯）", "企鹅号（资讯）", "简书（文艺）"]:
                                ext = "md"  # 这些平台也适合用 Markdown
                            else:
                                ext = "txt"
                            
                            filename = f"{sanitize_filename(plat,30)}_{sanitize_filename(brand,30)}_{safe_kw}.{ext}"
                            zip_file.writestr(filename, content)
                            
                            # 内容质量评分
                            score_data = None
                            if gen_llm:
                                try:
                                    with st.spinner(f"正在评估内容质量..."):
                                        score_chain = PromptTemplate.from_template("{input}") | gen_llm | StrOutputParser()
                                        score_data = scorer.score_content(
                                            content, brand, advantages, plat, score_chain
                                        )
                                        # 保存评分结果
                                        content_key = f"{keyword}_{plat}"
                                        st.session_state.content_scores[content_key] = score_data
                                except Exception as e:
                                    st.warning(f"内容质量评分失败：{e}")
                            
                            contents.append(
                                {
                                    "keyword": keyword,
                                    "platform": plat,
                                    "content": content,
                                    "ext": ext,
                                    "filename": filename,
                                    "score": score_data,  # 添加评分数据
                                }
                            )
                            # 保存到数据库
                            try:
                                storage.save_article(keyword, plat, content, filename, brand)
                            except Exception as e:
                                st.warning(f"内容已生成，但保存到数据库时出错：{e}")

                zip_buffer.seek(0)
                st.session_state.generated_contents = contents
                st.session_state.zip_bytes = zip_buffer.getvalue()
                st.session_state.zip_filename = f"{sanitize_filename(brand,40)}_GEO内容包.zip"
                st.success(f"生成完成（{len(contents)} 篇）")

    if st.session_state.generated_contents:
        if len(st.session_state.generated_contents) == 1:
            item = st.session_state.generated_contents[0]
            
            # 显示内容质量评分
            if item.get("score"):
                from content_scorer import ContentScorer
                temp_scorer = ContentScorer()
                score_data = item["score"]
                scores = score_data.get("scores", {})
                total_score = scores.get("total", 0)
                level, color = temp_scorer.get_score_level(total_score)
                
                st.markdown("#### 📊 内容质量评分")
                col1, col2, col3, col4, col5 = st.columns(5)
                with col1:
                    st.metric("总分", f"{total_score}/100", delta=level, delta_color="off")
                with col2:
                    st.metric("结构化", f"{scores.get('structure', 0)}/25")
                with col3:
                    st.metric("品牌提及", f"{scores.get('brand_mention', 0)}/25")
                with col4:
                    st.metric("权威性", f"{scores.get('authority', 0)}/25")
                with col5:
                    st.metric("可引用性", f"{scores.get('citations', 0)}/25")
                
                # 详细评分和改进建议
                with st.expander("📝 详细评分与改进建议", expanded=True):
                    details = score_data.get("details", {})
                    improvements = score_data.get("improvements", [])
                    strengths = score_data.get("strengths", [])
                    
                    if strengths:
                        st.markdown("**✅ 优点：**")
                        for strength in strengths:
                            st.markdown(f"- {strength}")
                    
                    if improvements:
                        st.markdown("**💡 改进建议：**")
                        for improvement in improvements:
                            st.markdown(f"- {improvement}")
                    
                    st.markdown("**📋 详细评估：**")
                    st.markdown(f"- **结构化**：{details.get('structure', '无')}")
                    st.markdown(f"- **品牌提及**：{details.get('brand_mention', '无')}")
                    st.markdown(f"- **权威性**：{details.get('authority', '无')}")
                    st.markdown(f"- **可引用性**：{details.get('citations', '无')}")
            
            st.markdown("#### 生成内容预览")
            if item["ext"] == "md":
                st.code(item["content"], language="markdown")
            else:
                st.text_area(
                    "内容（可复制发布）",
                    item["content"],
                    height=520,
                    label_visibility="collapsed",
                    key="content_single_preview",
                )

            st.download_button(
                "下载单篇文件",
                item["content"],
                f"{sanitize_filename(brand,40)}_{sanitize_filename(item['keyword'],40)}.{item['ext']}",
                mime=("text/markdown" if item["ext"] == "md" else "text/plain"),
                use_container_width=True,
                key="content_dl_single",
            )

        if st.session_state.zip_bytes:
            st.download_button(
                "下载所有ZIP",
                st.session_state.zip_bytes,
                st.session_state.zip_filename,
                "application/zip",
                use_container_width=True,
                key="content_dl_zip",
            )

        with st.expander("预览最后一篇（批量生成时）", expanded=False):
            last = st.session_state.generated_contents[-1]
            
            # 显示评分（如果有）
            if last.get("score"):
                score_data = last["score"]
                total_score = score_data.get("scores", {}).get("total", 0)
                from content_scorer import ContentScorer
                temp_scorer = ContentScorer()
                level, _ = temp_scorer.get_score_level(total_score)
                st.markdown(f"**内容质量评分：{total_score}/100 ({level})**")
            
            if last["ext"] == "md":
                st.code(last["content"], language="markdown")
            else:
                st.text_area("内容", last["content"], height=420, key="content_last_preview")

# =======================
# Tab3：文章优化
# =======================
with tab3:
    top_l, top_r = st.columns([3, 1])
    with top_r:
        if st.button("清空本模块结果", use_container_width=True, key="opt_clear"):
            st.session_state.optimized_article = ""
            st.session_state.opt_changes = ""
            st.toast("优化结果已清空。")

    with st.container(border=True):
        st.markdown("**粘贴或上传已写文章，一键提升GEO效果（结构化、可引用、自然植入品牌）**")

        with st.form("opt_form", clear_on_submit=False):
            input_mode = st.radio("输入方式", ["粘贴文本", "上传文件（TXT/MD）"], horizontal=True, key="opt_input_mode")

            if input_mode == "粘贴文本":
                original_article = st.text_area("粘贴文章内容", height=360, key="opt_text")
            else:
                uploaded = st.file_uploader("上传TXT或MD文件", type=["txt", "md"], key="opt_uploader")
                original_article = safe_decode_uploaded(uploaded) if uploaded else ""
                if uploaded:
                    st.text_area("上传内容预览", original_article, height=200, disabled=True, key="opt_upload_preview")

            target_platform = st.selectbox(
                "优化目标平台（可选通用）",
                ["通用优化", "知乎（专业问答）", "CSDN（技术博客）", "GitHub（README/文档）", "B站（视频脚本）", "头条号（资讯软文）", 
                 "微信公众号（长文）", "抖音图文（短内容）", "百家号（资讯）", "网易号（资讯）", "企鹅号（资讯）", "简书（文艺）"],
                index=["通用优化", "知乎（专业问答）", "CSDN（技术博客）", "GitHub（README/文档）", "B站（视频脚本）", "头条号（资讯软文）",
                       "微信公众号（长文）", "抖音图文（短内容）", "百家号（资讯）", "网易号（资讯）", "企鹅号（资讯）", "简书（文艺）"].index(
                    st.session_state.opt_platform if st.session_state.opt_platform in ["通用优化", "知乎（专业问答）", "CSDN（技术博客）", "GitHub（README/文档）", "B站（视频脚本）", "头条号（资讯软文）",
                                                                                      "微信公众号（长文）", "抖音图文（短内容）", "百家号（资讯）", "网易号（资讯）", "企鹅号（资讯）", "简书（文艺）"] else 0
                ),
                key="opt_platform_sel",
            )

            run_opt_disabled = (not st.session_state.cfg_valid) or (gen_llm is None) or (not original_article.strip())
            run_opt = st.form_submit_button("开始优化", use_container_width=True, disabled=run_opt_disabled)

        if run_opt:
            st.session_state.opt_platform = target_platform

            optimize_prompt = PromptTemplate.from_template(
                """
你是GEO优化专家，目标是提升文章在大模型中的引用率和品牌自然提及。

【原文章】
{original_article}

【品牌】{brand}
【优势】{advantages}
【目标平台】{platform}

【优化要求（严格GEO原则）】
1) 保留原意和核心信息，不改变事实
2) 增强结构化：标题、清单、FAQ、代码块（适用时）
3) 自然植入品牌2-4次（先通用标准，再品牌适用）
4) 提升权威感：评估维度、匿名案例、来源占位建议（不得编造）
5) 结论先行、信息密度高
6) 长度控制在原长度的1.0-1.3倍
7) 输出两部分：【优化后文章】 + 【变更说明】（列出主要改动点）

【开始优化】
"""
            )

            with st.spinner("优化中..."):
                chain = optimize_prompt | gen_llm | StrOutputParser()
                result = chain.invoke(
                    {"original_article": original_article, "brand": brand, "advantages": advantages, "platform": target_platform}
                )

            if "【优化后文章】" in result and "【变更说明】" in result:
                optimized_article = result.split("【优化后文章】", 1)[1].split("【变更说明】", 1)[0].strip()
                changes = result.split("【变更说明】", 1)[1].strip()
            else:
                optimized_article = result.strip()
                changes = "无详细变更说明（模型未按模板输出）。"

            st.session_state.optimized_article = optimized_article
            st.session_state.opt_changes = changes
            # 保存到数据库
            try:
                storage.save_optimization(original_article, optimized_article, changes, target_platform, brand)
            except Exception as e:
                st.warning(f"优化完成，但保存到数据库时出错：{e}")

    if st.session_state.optimized_article:
        st.markdown("#### 优化后文章")
        # Markdown 平台使用代码显示，其他使用 markdown 渲染
        markdown_platforms = ["GitHub", "微信公众号", "百家号", "网易号", "企鹅号", "简书"]
        if any(p in st.session_state.opt_platform for p in markdown_platforms):
            st.code(st.session_state.optimized_article, language="markdown")
        else:
            st.markdown(st.session_state.optimized_article)

        st.markdown("#### 变更说明")
        st.markdown(st.session_state.opt_changes)

        # 确定文件扩展名
        markdown_platforms = ["GitHub", "微信公众号", "百家号", "网易号", "企鹅号", "简书"]
        ext = "md" if any(p in st.session_state.opt_platform for p in markdown_platforms) else "txt"
        st.download_button(
            "下载优化版",
            st.session_state.optimized_article,
            f"{sanitize_filename(brand,40)}_优化文章.{ext}",
            use_container_width=True,
            key="opt_dl",
        )

# =======================
# Tab4：多模型验证 & 竞品对比
# =======================
with tab4:
    top_l, top_r = st.columns([3, 1])
    with top_r:
        if st.button("清空本模块结果", use_container_width=True, key="verify_clear"):
            st.session_state.verify_combined = None
            st.toast("验证结果已清空。")

    with st.container(border=True):
        with st.form("verify_form", clear_on_submit=False):
            test_queries = st.text_area(
                "测试问题（每行一个，可粘贴关键词）",
                height=140,
                value=st.session_state.verify_last_queries,
                key="verify_queries",
            )
            st.session_state.verify_last_queries = test_queries

            run_verify_disabled = (not st.session_state.cfg_valid) or (not verify_llms) or (not test_queries.strip())
            run_verify = st.form_submit_button("开始验证", use_container_width=True, disabled=run_verify_disabled)

        if run_verify:
            queries = [q.strip() for q in test_queries.split("\n") if q.strip()]
            all_results = []
            brands_to_check = [brand] + competitor_list

            verify_prompt = PromptTemplate.from_template(
                """
你是一名国内AI搜索助手，像百度/微信搜一搜AI总结：结论先行、信息密度高、可复述。
不要编造数据，不确定处说明边界。

【用户问题】{query}
【候选品牌】{brand}
【优势（仅参考）】{advantages}

【要求】
1) 60–90字结论摘要
2) 选择标准5条
3) 推荐方案最多3个（仅当符合标准时提及品牌）
4) 4个FAQ
5) 250–450字，克制语言

【开始回答】
"""
            )

            total = max(1, len(brands_to_check) * len(verify_llms) * len(queries))
            done = 0
            prog = st.progress(0)

            for target_brand in brands_to_check:
                current_advantages = advantages if target_brand == brand else ""
                for model_name, v_llm in verify_llms.items():
                    chain = verify_prompt | v_llm | StrOutputParser()

                    for q in queries:
                        with st.spinner(f"模型：{model_name} | 品牌：{target_brand} | 问题：{q}"):
                            response = chain.invoke({"query": q, "brand": target_brand, "advantages": current_advantages})

                        resp_l = response.lower()
                        tb_l = target_brand.lower()
                        count = resp_l.count(tb_l)
                        first_pos = resp_l.find(tb_l)
                        rank = "前1/3（优先）" if first_pos != -1 and first_pos < len(response) // 3 else ("中后段" if first_pos != -1 else "未提及")

                        all_results.append({"问题": q, "提及次数": count, "位置": rank, "品牌": target_brand, "验证模型": model_name})

                        done += 1
                        prog.progress(min(done / total, 1.0))

            combined = pd.DataFrame(all_results)
            st.session_state.verify_combined = combined
            # 保存到数据库
            try:
                storage.save_verify_results(all_results)
            except Exception as e:
                st.warning(f"验证完成，但保存到数据库时出错：{e}")
            st.success("验证完成")

    if st.session_state.verify_combined is not None:
        combined = st.session_state.verify_combined

        st.markdown("#### 跨模型提及次数对比")
        pivot = combined.pivot_table(index=["问题", "验证模型"], columns="品牌", values="提及次数", fill_value=0)
        st.dataframe(pivot, use_container_width=True)

        st.markdown("#### 多模型竞品提及对比（可视化）")
        fig = px.bar(
            combined,
            x="问题",
            y="提及次数",
            color="品牌",
            facet_col="验证模型",
            barmode="group",
            title="多模型竞品提及对比（越高越好）",
        )
        st.plotly_chart(fig, use_container_width=True)

        st.markdown("#### 平均提及次数（跨模型）")
        summary = combined.groupby(["品牌", "验证模型"])["提及次数"].mean().round(2).unstack()
        st.dataframe(summary, use_container_width=True)

        st.download_button(
            "下载验证报表CSV",
            combined.to_csv(index=False, encoding="utf-8-sig"),
            f"{sanitize_filename(brand,40)}_验证结果.csv",
            mime="text/csv",
            use_container_width=True,
            key="verify_dl_csv",
        )

# =======================
# Tab5：历史记录
# =======================
with tab5:
    st.header("历史记录")
    
    # 统计数据
    try:
        stats = storage.get_stats(brand)
        col1, col2, col3, col4 = st.columns(4)
        col1.metric("关键词总数", stats["keywords_count"])
        col2.metric("文章总数", stats["articles_count"])
        col3.metric("优化记录", stats["optimizations_count"])
        col4.metric("验证结果", stats["verify_results_count"])
    except Exception as e:
        st.error(f"获取统计数据失败：{e}")
        stats = {"keywords_count": 0, "articles_count": 0, "optimizations_count": 0, "verify_results_count": 0}
    
    st.markdown("---")
    
    # 历史文章列表
    st.markdown("#### 历史文章")
    try:
        articles = storage.get_articles(brand=brand)
        if articles:
            articles_df = pd.DataFrame(articles)
            # 只显示关键列
            display_cols = ["keyword", "platform", "created_at"]
            available_cols = [col for col in display_cols if col in articles_df.columns]
            if available_cols:
                st.dataframe(articles_df[available_cols], use_container_width=True, hide_index=True)
            else:
                st.dataframe(articles_df, use_container_width=True, hide_index=True)
            
            # 文章详情查看
            if len(articles) > 0:
                selected_idx = st.selectbox("选择文章查看详情", range(len(articles)), format_func=lambda x: f"{articles[x].get('keyword', 'N/A')} - {articles[x].get('platform', 'N/A')}")
                if selected_idx is not None:
                    selected_article = articles[selected_idx]
                    with st.expander("文章内容", expanded=True):
                        if selected_article.get("content"):
                            if selected_article.get("platform", "").startswith("GitHub"):
                                st.code(selected_article["content"], language="markdown")
                            else:
                                st.text_area("内容", selected_article["content"], height=400, disabled=True, key=f"article_content_{selected_idx}")
        else:
            st.info("暂无历史文章记录。")
    except Exception as e:
        st.error(f"获取历史文章失败：{e}")
    
    st.markdown("---")
    
    # 历史优化记录
    st.markdown("#### 历史优化记录")
    try:
        optimizations = storage.get_optimizations(brand=brand)
        if optimizations:
            opt_df = pd.DataFrame(optimizations)
            display_cols = ["platform", "created_at"]
            available_cols = [col for col in display_cols if col in opt_df.columns]
            if available_cols:
                st.dataframe(opt_df[available_cols], use_container_width=True, hide_index=True)
            else:
                st.dataframe(opt_df.head(10), use_container_width=True, hide_index=True)
            
            if len(optimizations) > 0:
                selected_opt_idx = st.selectbox("选择优化记录查看详情", range(len(optimizations)), format_func=lambda x: f"{optimizations[x].get('platform', 'N/A')} - {optimizations[x].get('created_at', 'N/A')[:10] if optimizations[x].get('created_at') else 'N/A'}")
                if selected_opt_idx is not None:
                    selected_opt = optimizations[selected_opt_idx]
                    with st.expander("优化详情", expanded=True):
                        if selected_opt.get("changes"):
                            st.markdown("**变更说明**")
                            st.markdown(selected_opt["changes"])
                        if selected_opt.get("optimized_content"):
                            st.markdown("**优化后内容**")
                            if "GitHub" in selected_opt.get("platform", ""):
                                st.code(selected_opt["optimized_content"], language="markdown")
                            else:
                                st.text_area("内容", selected_opt["optimized_content"], height=300, disabled=True, key=f"opt_content_{selected_opt_idx}")
        else:
            st.info("暂无优化记录。")
    except Exception as e:
        st.error(f"获取优化记录失败：{e}")
    
    st.markdown("---")
    
    # 历史验证结果
    st.markdown("#### 历史验证结果")
    try:
        verify_df = storage.get_verify_results(brand=brand)
        if not verify_df.empty:
            st.dataframe(verify_df, use_container_width=True, hide_index=True)
            
            # 可视化历史验证结果
            if len(verify_df) > 0:
                st.markdown("#### 历史验证结果可视化")
                fig = px.bar(
                    verify_df,
                    x="问题",
                    y="提及次数",
                    color="品牌",
                    facet_col="验证模型",
                    barmode="group",
                    title="历史验证结果对比",
                )
                st.plotly_chart(fig, use_container_width=True)
        else:
            st.info("暂无验证结果记录。")
    except Exception as e:
        st.error(f"获取验证结果失败：{e}")

# =======================
# Tab6：AI 数据报表
# =======================
with tab6:
    st.markdown("### 📊 AI 数据报表")
    st.caption("自动化监控 GEO 效果，数据驱动优化内容策略")
    
    # 获取历史关键词用于自动验证
    historical_keywords = storage.get_keywords(brand=brand)
    
    col1, col2, col3 = st.columns([2, 1, 1])
    with col1:
        st.markdown("#### 🚀 自动验证任务")
        st.caption("使用历史关键词自动进行多模型验证，生成数据报表")
    
    with col2:
        auto_verify_btn = st.button("开始自动验证", use_container_width=True, 
                                     disabled=(not st.session_state.cfg_valid) or (not verify_llms) or (len(historical_keywords) == 0))
    
    with col3:
        if st.button("刷新报表", use_container_width=True):
            st.rerun()
    
    if len(historical_keywords) == 0:
        st.info("💡 提示：请先在【1 关键词蒸馏】生成关键词，然后才能进行自动验证。")
    elif not verify_llms:
        st.warning("⚠️ 请先在侧边栏配置至少一个验证用 LLM。")
    
    # 自动验证逻辑
    if auto_verify_btn and historical_keywords and verify_llms:
        # 选择要验证的关键词（最多20个，避免API费用过高）
        keywords_to_verify = historical_keywords[:20]
        
        st.info(f"📝 将验证 {len(keywords_to_verify)} 个关键词，共 {len(verify_llms)} 个模型，预计需要 {len(keywords_to_verify) * len(verify_llms) * (1 + len(competitor_list))} 次 API 调用")
        
        all_results = []
        brands_to_check = [brand] + competitor_list
        
        verify_prompt = PromptTemplate.from_template(
            """
你是一名国内AI搜索助手，像百度/微信搜一搜AI总结：结论先行、信息密度高、可复述。
不要编造数据，不确定处说明边界。

【用户问题】{query}
【候选品牌】{brand}
【优势（仅参考）】{advantages}

【要求】
1) 60–90字结论摘要
2) 选择标准5条
3) 推荐方案最多3个（仅当符合标准时提及品牌）
4) 4个FAQ
5) 250–450字，克制语言

【开始回答】
"""
        )
        
        total = max(1, len(brands_to_check) * len(verify_llms) * len(keywords_to_verify))
        done = 0
        prog = st.progress(0)
        status_text = st.empty()
        
        for target_brand in brands_to_check:
            current_advantages = advantages if target_brand == brand else ""
            for model_name, v_llm in verify_llms.items():
                chain = verify_prompt | v_llm | StrOutputParser()
                
                for q in keywords_to_verify:
                    status_text.text(f"验证中：{target_brand} | {model_name} | {q}")
                    try:
                        response = chain.invoke({"query": q, "brand": target_brand, "advantages": current_advantages})
                        
                        resp_l = response.lower()
                        tb_l = target_brand.lower()
                        count = resp_l.count(tb_l)
                        first_pos = resp_l.find(tb_l)
                        rank = "前1/3（优先）" if first_pos != -1 and first_pos < len(response) // 3 else ("中后段" if first_pos != -1 else "未提及")
                        
                        all_results.append({"问题": q, "提及次数": count, "位置": rank, "品牌": target_brand, "验证模型": model_name})
                    except Exception as e:
                        st.warning(f"验证失败：{target_brand} | {model_name} | {q} - {str(e)}")
                    
                    done += 1
                    prog.progress(min(done / total, 1.0))
        
        # 保存验证结果
        if all_results:
            try:
                storage.save_verify_results(all_results)
                st.success(f"✅ 自动验证完成！共验证 {len(all_results)} 条记录")
            except Exception as e:
                st.warning(f"验证完成，但保存到数据库时出错：{e}")
        
        status_text.empty()
        prog.empty()
    
    # 获取所有验证数据（带时间戳）
    verify_df = storage.get_verify_results(brand=brand, include_timestamp=True)
    
    if verify_df.empty:
        st.info("📊 暂无验证数据。请先运行自动验证任务或手动验证。")
    else:
        # 数据概览
        st.markdown("---")
        st.markdown("#### 📈 数据概览")
        
        col1, col2, col3, col4 = st.columns(4)
        with col1:
            total_verifications = len(verify_df)
            st.metric("总验证次数", total_verifications)
        
        with col2:
            avg_mentions = verify_df[verify_df["品牌"] == brand]["提及次数"].mean() if len(verify_df[verify_df["品牌"] == brand]) > 0 else 0
            st.metric("平均提及次数", f"{avg_mentions:.2f}")
        
        with col3:
            if "验证时间" in verify_df.columns:
                latest_date = verify_df["验证时间"].max()
                st.metric("最新验证时间", latest_date.strftime("%Y-%m-%d") if pd.notna(latest_date) else "N/A")
            else:
                st.metric("最新验证时间", "N/A")
        
        with col4:
            unique_queries = verify_df["问题"].nunique()
            st.metric("已验证关键词", unique_queries)
        
        # 1. 提及率趋势图
        if "验证时间" in verify_df.columns and len(verify_df) > 0:
            st.markdown("---")
            st.markdown("#### 📊 提及率趋势图")
            
            # 按日期聚合数据
            brand_df = verify_df[verify_df["品牌"] == brand].copy()
            if len(brand_df) > 0:
                brand_df["日期"] = brand_df["验证时间"].dt.date
                daily_mentions = brand_df.groupby(["日期", "验证模型"])["提及次数"].mean().reset_index()
                daily_mentions["日期"] = pd.to_datetime(daily_mentions["日期"])
                
                fig_trend = px.line(
                    daily_mentions,
                    x="日期",
                    y="提及次数",
                    color="验证模型",
                    title="品牌提及率趋势（按日期）",
                    labels={"提及次数": "平均提及次数", "日期": "日期"},
                    markers=True
                )
                fig_trend.update_layout(hovermode='x unified')
                st.plotly_chart(fig_trend, use_container_width=True)
        
        # 2. 平台贡献度分析（基于文章平台）
        st.markdown("---")
        st.markdown("#### 🌐 平台贡献度分析")
        
        articles = storage.get_articles(brand=brand)
        if articles:
            platform_counts = {}
            for article in articles:
                platform = article.get("platform", "未知")
                platform_counts[platform] = platform_counts.get(platform, 0) + 1
            
            platform_df = pd.DataFrame(list(platform_counts.items()), columns=["平台", "文章数量"])
            platform_df = platform_df.sort_values("文章数量", ascending=False)
            
            fig_platform = px.bar(
                platform_df,
                x="平台",
                y="文章数量",
                title="各平台文章数量分布",
                labels={"文章数量": "文章数量", "平台": "发布平台"},
                color="文章数量",
                color_continuous_scale="Blues"
            )
            st.plotly_chart(fig_platform, use_container_width=True)
        else:
            st.info("暂无文章数据。")
        
        # 3. 关键词效果排名
        st.markdown("---")
        st.markdown("#### 🎯 关键词效果排名")
        
        brand_verify = verify_df[verify_df["品牌"] == brand].copy()
        if len(brand_verify) > 0:
            keyword_performance = brand_verify.groupby("问题")["提及次数"].agg(["mean", "count"]).reset_index()
            keyword_performance.columns = ["关键词", "平均提及次数", "验证次数"]
            keyword_performance = keyword_performance.sort_values("平均提及次数", ascending=False)
            
            # 显示 Top 20
            top_keywords = keyword_performance.head(20)
            
            fig_keywords = px.bar(
                top_keywords,
                x="平均提及次数",
                y="关键词",
                orientation='h',
                title="Top 20 关键词效果排名（平均提及次数）",
                labels={"平均提及次数": "平均提及次数", "关键词": "关键词"},
                color="平均提及次数",
                color_continuous_scale="Greens"
            )
            fig_keywords.update_layout(yaxis={'categoryorder': 'total ascending'})
            st.plotly_chart(fig_keywords, use_container_width=True)
            
            with st.expander("查看完整关键词排名", expanded=False):
                st.dataframe(keyword_performance, use_container_width=True, hide_index=True)
        else:
            st.info("暂无品牌验证数据。")
        
        # 4. 竞品对比分析
        st.markdown("---")
        st.markdown("#### ⚔️ 竞品对比分析")
        
        if len(competitor_list) > 0:
            # 计算各品牌的平均提及次数
            brand_comparison = verify_df.groupby("品牌")["提及次数"].agg(["mean", "count"]).reset_index()
            brand_comparison.columns = ["品牌", "平均提及次数", "验证次数"]
            brand_comparison = brand_comparison.sort_values("平均提及次数", ascending=False)
            
            fig_comparison = px.bar(
                brand_comparison,
                x="品牌",
                y="平均提及次数",
                title="品牌提及率对比（平均提及次数）",
                labels={"平均提及次数": "平均提及次数", "品牌": "品牌"},
                color="平均提及次数",
                color_continuous_scale="Reds"
            )
            st.plotly_chart(fig_comparison, use_container_width=True)
            
            # 详细对比表
            with st.expander("查看详细对比数据", expanded=False):
                st.dataframe(brand_comparison, use_container_width=True, hide_index=True)
            
            # 按验证模型分组的对比
            if "验证模型" in verify_df.columns:
                model_comparison = verify_df.groupby(["品牌", "验证模型"])["提及次数"].mean().reset_index()
                model_comparison = model_comparison.pivot(index="品牌", columns="验证模型", values="提及次数").fillna(0)
                
                fig_model_comparison = px.bar(
                    model_comparison.reset_index(),
                    x="品牌",
                    y=[col for col in model_comparison.columns],
                    title="各模型下的品牌提及率对比",
                    labels={"value": "平均提及次数", "品牌": "品牌"},
                    barmode='group'
                )
                st.plotly_chart(fig_model_comparison, use_container_width=True)
        else:
            st.info("💡 提示：在侧边栏配置竞品品牌后，可查看竞品对比分析。")
        
        # 5. 数据导出
        st.markdown("---")
        st.markdown("#### 💾 数据导出")
        
        col1, col2 = st.columns(2)
        with col1:
            # 导出验证数据
            csv_data = verify_df.to_csv(index=False, encoding="utf-8-sig")
            st.download_button(
                "下载验证数据 CSV",
                csv_data,
                f"{sanitize_filename(brand,40)}_AI数据报表_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.csv",
                mime="text/csv",
                use_container_width=True,
                key="report_dl_csv"
            )
        
        with col2:
            # 导出关键词效果排名
            if len(brand_verify) > 0:
                keyword_csv = keyword_performance.to_csv(index=False, encoding="utf-8-sig")
                st.download_button(
                    "下载关键词排名 CSV",
                    keyword_csv,
                    f"{sanitize_filename(brand,40)}_关键词排名_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.csv",
                    mime="text/csv",
                    use_container_width=True,
                    key="keyword_rank_dl_csv"
                )

st.caption("最完整版：GitHub模板 + 真实多模型验证 + 现有文章优化 • GEO全闭环，专注AI品牌影响力")