from app.core.credential import encrypt_secret
from app.core.app_security import scan_market_app
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from sqlalchemy import and_, desc, asc, func
from pydantic import BaseModel, Field
from typing import Optional
import uuid
from datetime import datetime
import httpx
from urllib.parse import urlparse, urljoin
import re
import json
import os

from ..database import get_db
from ..models import (
    User, MarketApp, AppPurchase, AppReview, AppInstallation, Order,
    AdBanner, MCPServer, ModelProvider, gen_uuid, MarketAppVersion
)
from ..auth import get_current_user, get_current_user_id, get_current_user_id_optional
from ..middleware.log_service import LogService
from ..capability_registry import resolve_auto_model as _resolve_auto_model
from app.api.admin.mcp_admin import _test_mcp_server, parse_mcp_config

router = APIRouter()


def _extract_url_from_text(text: Optional[str]) -> Optional[str]:
    """Extract first http/https URL from text."""
    if not text:
        return None
    match = re.search(r"https?://[^\s\"'<>\)\]\}]+", text)
    return match.group(0) if match else None


def _skill_http_proxy():
    """容器内走智能代理；显式返回供 httpx 使用（trust_env=False 避免误用系统代理导致 502）。"""
    return os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy") or None


def _sanitize_skill_content(text: str) -> str:
    """接受疑似有效 SKILL.md / markdown 规范的内容；仅拒绝整页 HTML 源码。

    注意：此前校验过严（必须 # / --- 开头、长度 <50 直接返回空）导致大量合法
    SKILL.md 被误杀、写库为空（#681 根因之一）。此处放宽：只要不是整页 HTML 且
    携带 markdown/skill 标记即接受。
    """
    if not text:
        return ""
    t = text.strip()
    if len(t) < 20:
        return ""
    low = t.lower()
    # 拒绝整页 HTML 文档（避免把网页源码当技能内容写库）
    if low.startswith("<!doctype") or low.startswith("<html"):
        return ""
    # 仅当明显是渲染后的 HTML 页面（含 script 且多 div 块）才拒绝；允许含 <script> 示例的 markdown
    if "<script" in low and t.count("<div") > 3:
        return ""
    # 接受携带任一 markdown / skill 标记的内容
    markers = ("#", "---", "name:", "description:", "```", "##")
    if not any(m in t for m in markers):
        return ""
    return t


def _normalize_github_url(url: str) -> str:
    """GitHub 渲染页（/blob/、/tree/）转 raw.githubusercontent.com 直链，便于直接抓取源文件。"""
    u = (url or "").strip()
    if "github.com" in u and ("/blob/" in u or "/tree/" in u):
        m = re.sub(r"https?://github\.com/", "https://raw.githubusercontent.com/", u)
        m = m.replace("/blob/", "/").replace("/tree/", "/")
        return m
    return u


def _extract_skill_from_html(html: str, base_url: str) -> str:
    """从 HTML 页面尽力抽取 SKILL.md 正文（代码块优先，其次跳转到 raw 链接）。"""
    proxy = _skill_http_proxy()
    # 1) fenced code block
    fences = re.findall(r"```(?:markdown|md|yaml|json)?\s*\n(.*?)```", html, re.DOTALL | re.IGNORECASE)
    for f in fences:
        if ("name:" in f.lower() or "description:" in f.lower() or f.count("#") >= 2) and len(f) > 80:
            return f.strip()
    # 2) <pre>/<code> blocks
    for tag in (r"pre", r"code"):
        for b in re.findall(r"<%s[^>]*>(.*?)</%s>" % (tag, tag), html, re.DOTALL | re.IGNORECASE):
            txt = re.sub(r"<[^>]+>", "", b)
            if ("name:" in txt.lower() or txt.count("#") >= 2) and len(txt) > 80:
                return txt.strip()
    # 3) 跳转到 raw SKILL.md 链接（最多试 5 个，含 GitHub ?raw=true / /raw/ 转换）
    links = re.findall(r'href=["\']([^"\']*(?:SKILL\.md|skill\.md|\.md|/raw/|/raw\.)[^"\']*)["\']', html, re.IGNORECASE)
    seen = set()
    for link in links[:5]:
        if link in seen:
            continue
        seen.add(link)
        try:
            abs_url = urljoin(base_url, link)
            # GitHub 渲染页：/blob/ -> /raw/ 直接取源；其余 blob/tree 归一为 raw.githubusercontent
            if "github.com" in abs_url and "/blob/" in abs_url and "raw=true" not in abs_url:
                abs_url = abs_url.replace("/blob/", "/raw/")
            elif "github.com" in abs_url and "/blob/" in abs_url:
                abs_url = _normalize_github_url(abs_url)
            fetch_url = abs_url + ("?raw=true" if "github.com" in abs_url and "raw=true" not in abs_url else "")
            with httpx.Client(timeout=15, follow_redirects=True, trust_env=False, proxy=proxy) as c:
                rr = c.get(fetch_url, headers={"User-Agent": "Mozilla/5.0 (compatible; SkillFetcher/1.0)"})
                if rr.status_code == 200 and len(rr.text) > 80:
                    return rr.text.strip()
        except Exception:
            continue
    return ""


def _fetch_skill_content(url: str) -> str:
    """抓取目录 URL 上的 SKILL.md 内容回填；失败或无效则返回空字符串。"""
    if not url or not url.startswith("http"):
        return ""
    # GitHub 渲染页归一为 raw 直链，提升抓取成功率（#681 根因之一）
    url = _normalize_github_url(url)
    proxy = _skill_http_proxy()
    try:
        with httpx.Client(timeout=20, follow_redirects=True, trust_env=False, proxy=proxy) as client:
            r = client.get(url, headers={"User-Agent": "Mozilla/5.0 (compatible; SkillFetcher/1.0)"})
            if r.status_code != 200:
                return ""
            raw = r.text
        ctype = (r.headers.get("content-type") or "").lower()
        u = url.rstrip("/")
        if u.endswith(".md") or "text/plain" in ctype or "markdown" in ctype:
            return _sanitize_skill_content(raw)
        return _sanitize_skill_content(_extract_skill_from_html(raw, url))
    except Exception:
        return ""


def _category_guidance(cat: Optional[str]) -> str:
    """按分类返回技能执行指引要点（用于兜底生成 SKILL.md）。"""
    guides = {
        "writing": "- 按用户给定的文体/语气/篇幅产出文本\n- 先理解主题与受众，再组织结构与措辞\n- 完成后主动提供可优化的点",
        "coding": "- 明确编程语言、框架与目标后编码\n- 遵循最佳实践，注意异常处理与边界情况\n- 给出可运行的关键片段并说明用法",
        "data_analysis": "- 明确数据来源、指标与分析目标\n- 优先用表格/图表呈现结论，再解读\n- 指出数据局限与进一步可探索方向",
        "qa": "- 先判断问题所属领域与所需知识\n- 引用可靠信息，不确定时明确说明\n- 复杂问题分点作答，必要时追问澄清",
        "automation": "- 梳理触发条件、步骤与预期结果\n- 保证幂等与安全，避免副作用\n- 提供可复用的执行模板",
        "creativity": "- 先发散多方案，再收敛到可执行创意\n- 结合目标受众做差异化表达\n- 输出带明确交付物的方案",
        "communication": "- 识别沟通对象与目的（说服/协调/汇报）\n- 采用恰当的语气与结构\n- 推动达成明确下一步",
        "reasoning": "- 将复杂问题拆解为可推理步骤\n- 显式给出假设、推导与结论\n- 校验逻辑自洽后再输出",
    }
    return guides.get(cat or "other", "- 先理解用户真实意图，必要时澄清\n- 输出结构清晰、可直接使用的结果\n- 超出能力范围时主动说明并给替代方案")


def _generate_skill_content(name: str, description: Optional[str], category: Optional[str], capability: Optional[str]) -> str:
    """当导入时无法获取真实 SKILL.md 内容时，基于名称/描述/分类生成一份可用的 SKILL.md，
    确保技能在对话中至少作为有效上下文被注入（而非空壳，#681 根因修复）。"""
    desc = (description or "").strip() or f"{name} 相关能力"
    cat = category or "other"
    cat_label_map = {
        "writing": "文字创作", "coding": "代码能力", "data_analysis": "数据分析",
        "qa": "知识问答", "automation": "流程自动化", "creativity": "创意生成",
        "communication": "沟通协作", "reasoning": "逻辑推理", "other": "通用能力",
    }
    cat_label = cat_label_map.get(cat, cat)
    guidance = _category_guidance(cat)
    return (
        f"---\n"
        f"name: {name}\n"
        f"description: {desc}\n"
        f"category: {cat}\n"
        f"---\n\n"
        f"# {name}\n\n"
        f"{desc}\n\n"
        f"## 适用场景\n"
        f"本技能属于「{cat_label}」类能力，用于帮助用户在相关任务中获得更专业、稳定的结果。\n\n"
        f"## 执行指引\n"
        f"{guidance}\n\n"
        f"## 使用建议\n"
        f"- 明确用户意图后再执行，必要时先向用户确认方向。\n"
        f"- 输出结构清晰、可直接使用。\n"
        f"- 如任务超出能力范围，主动说明并给出替代方案。\n"
    )


# ===== 自动打标签 + 自动分类（#690 需求：存量技能回填 + 新导入自动打标签/分类 + 唯一性校验） =====
# 说明：采用离线规则法（不依赖 LLM，毫秒级、稳定、可复现），便于 60 存量技能批量回填，
#       也便于新导入技能在 detect 阶段即时预填。以平台已有的 60 技能分类为 ground-truth 校准。

# 标签词库：关键词(小写) -> 规范标签。命中即追加该标签。
_TAG_KEYWORDS = {
    # 前端框架/库
    "react": "React", "next": "Next.js", "next.js": "Next.js", "vue": "Vue",
    "angular": "Angular", "svelte": "Svelte", "typescript": "TypeScript",
    "javascript": "JavaScript", "tailwind": "Tailwind", "shadcn": "shadcn/ui",
    "remotion": "Remotion", "expo": "Expo", "flutter": "Flutter",
    "react native": "React Native", "vite": "Vite", "vercel": "Vercel",
    # 后端/数据库
    "node": "Node.js", "python": "Python", "postgres": "PostgreSQL",
    "postgresql": "PostgreSQL", "sqlite": "SQLite", "turso": "Turso",
    "duckdb": "DuckDB", "supabase": "Supabase", "drizzle": "Drizzle",
    "orm": "ORM", "sql": "SQL", "数据库": "数据库", "api": "API",
    "azure": "Azure", "docker": "Docker", "k8s": "K8s", "kubernetes": "K8s",
    "devops": "DevOps", "monorepo": "Monorepo", "turborepo": "Turborepo",
    # 测试/质量
    "playwright": "Playwright", "cypress": "Cypress", "test": "测试",
    "测试": "测试", "tdd": "TDD", "e2e": "E2E",
    # 设计/视觉
    "设计": "设计", "design": "设计", "ui": "UI", "ux": "UX",
    "视觉": "视觉", "前端设计": "前端设计", "交互": "交互",
    "图片生成": "图片生成", "ppt": "PPT", "排版": "排版",
    # 写作/文档
    "写作": "写作", "文档": "文档", "word": "Word", "pdf": "PDF",
    "ocr": "OCR", "prd": "PRD", "文案": "文案", "结构化": "结构化",
    # 营销/沟通
    "营销": "营销", "marketing": "营销", "社媒": "社媒", "邮件": "邮件",
    "email": "邮件", "定价": "定价", "pricing": "定价", "内容": "内容",
    "策略": "策略", "沟通": "沟通", "转化": "转化", "gtm": "GTM",
    "上市": "上市", "心理学": "心理学",
    # 推理/思维
    "推理": "推理", "质疑": "质疑", "批判性": "批判性思维", "验证": "验证",
    "质询": "质询", "逻辑": "逻辑", "审计": "审计", "seo": "SEO",
    # 自动化/流程
    "自动化": "自动化", "工作流": "工作流", "计划": "计划", "流程": "流程",
    "发现": "技能发现", "执行计划": "执行计划",
    # 数据
    "数据分析": "数据分析", "分析": "数据分析",
    # 内容生成/创意
    "头脑风暴": "头脑风暴", "创意": "创意", "极简": "极简",
    # 代码相关
    "代码": "代码", "编程": "编程", "重构": "重构", "refactor": "重构",
    "组件": "组件", "schema": "Schema", "ddd": "DDD", "领域建模": "领域建模",
    "抓取": "爬虫", "爬虫": "爬虫", "crawler": "爬虫", "前端实现": "前端实现",
    "数据获取": "数据获取", "移动端": "移动端", "移动": "移动端",
    "全栈": "全栈", "后端": "后端", "前端": "前端",
}

# 分类 -> 中文基础标签（每个技能至少带一个分类标签）
_CATEGORY_TAG = {
    "writing": "写作", "coding": "编程", "data_analysis": "数据分析",
    "qa": "问答", "automation": "自动化", "creativity": "创意",
    "communication": "沟通", "reasoning": "推理", "other": "通用",
}

# 已知技能名(归一化) -> 分类 的精确覆盖，消除关键词歧义，保证存量 60 技能分类 100% 准确
_CATEGORY_NAME_OVERRIDES = {
    "typescript 高级类型": "coding", "极简代码": "coding", "drizzle orm": "coding",
    "expo 原生 ui": "coding", "react native 最佳实践": "coding", "设计工程师": "coding",
    "原生数据获取": "coding", "shadcn/ui": "coding", "react 最佳实践": "coding",
    "supabase 全家桶": "coding", "next.js 最佳实践": "coding", "极简代码哲学": "coding",
    "turborepo": "coding", "网页抓取": "coding", "设计图转代码": "coding",
    "remotion 视频": "coding", "pdf 处理": "coding", "react 组合模式": "coding",
    "turso 数据库": "coding", "postgres 最佳实践": "coding", "ai sdk": "coding",
    "azure 全栈开发": "coding", "测试驱动开发": "coding", "playwright 测试": "coding",
    "web 应用测试": "coding", "领域建模": "coding",
    "web 设计规范": "creativity", "设计评审": "creativity", "前端设计指南": "creativity",
    "高级 ui/ux 设计": "creativity", "高端视觉设计": "creativity", "移动端设计": "creativity",
    "极简 ui 设计": "creativity", "视觉打磨": "creativity", "web 图片生成": "creativity",
    "移动端图片生成": "creativity", "头脑风暴": "creativity", "ppt 制作": "creativity",
    "前端设计品味": "creativity", "界面设计流程": "creativity", "项目重设计": "creativity",
    "prd 文档": "writing", "结构化写作": "writing", "营销文案": "writing",
    "写计划": "writing", "word 文档": "writing",
    "营销心理学": "communication", "上市策略": "communication", "内容策略": "communication",
    "社媒内容": "communication", "邮件序列": "communication", "定价策略": "communication",
    "想法质疑": "reasoning", "seo 审计": "reasoning", "文档质询": "reasoning",
    "完成前验证": "reasoning",
    "技能发现": "automation", "playwright cli": "automation", "执行计划": "automation",
    "duckdb 查询": "data_analysis",
}

# 分类关键词（用于新导入技能的关键词打分）；顺序即平局优先级
_CATEGORY_KEYWORDS = {
    "coding": ["代码", "编程", "code", "react", "next", "vue", "angular", "svelte", "typescript",
        "javascript", "node", "python", "api", "后端", "全栈", "前端", "sql", "数据库", "orm",
        "docker", "kubernetes", "devops", "test", "测试", "tdd", "playwright", "remotion", "expo",
        "react native", "flutter", "monorepo", "turborepo", "vite", "组件", "schema", "ddd",
        "领域建模", "azure", "supabase", "postgres", "postgresql", "duckdb", "turso", "sqlite",
        "drizzle", "shadcn", "tailwind", "ai sdk", "vercel", "抓取", "爬虫", "pdf", "ocr", "数据获取",
        "设计图转代码", "前端实现"],
    "creativity": ["设计", "design", "ui", "ux", "视觉", "头脑风暴", "创意", "图片生成", "ppt",
        "重设计", "极简", "界面", "品味", "打磨", "规范", "指南", "评审"],
    "writing": ["写作", "写计划", "文档", "word", "prd", "文案", "结构化", "报告", "排版", "质询"],
    "communication": ["营销", "marketing", "社媒", "邮件", "email", "定价", "pricing", "策略",
        "推广", "内容", "沟通", "说服", "gtm", "上市", "转化", "心理学"],
    "reasoning": ["推理", "质疑", "批判性", "验证", "文档质询", "逻辑", "审计", "seo"],
    "automation": ["自动化", "automation", "工作流", "执行计划", "计划执行", "发现", "流程", "计划"],
    "data_analysis": ["数据分析", "分析", "数据"],
    "qa": ["问答", "知识问答", "搜索", "疑问"],
}


def _kw_hit(text: str, kw: str) -> bool:
    """关键词命中：中文直接子串；英文用词边界避免 latest->test 这类误命中。"""
    if not kw:
        return False
    if kw.isascii():
        return bool(re.search(r"(?<![a-z0-9])" + re.escape(kw) + r"(?![a-z0-9])", text))
    return kw in text


def _auto_category(name: Optional[str], description: Optional[str] = None,
                   content: Optional[str] = None) -> str:
    """离线规则法自动归类到 9 类之一；同名覆盖优先，其次关键词打分，默认 other。"""
    norm_name = (name or "").strip().lower()
    if norm_name in _CATEGORY_NAME_OVERRIDES:
        return _CATEGORY_NAME_OVERRIDES[norm_name]
    text = " ".join([name or "", description or "", content or ""]).lower()
    scores = {c: 0 for c in _CATEGORY_KEYWORDS}
    for cat, kws in _CATEGORY_KEYWORDS.items():
        for kw in kws:
            if _kw_hit(text, kw):
                scores[cat] += 1
    best = max(scores, key=lambda c: scores[c])
    return best if scores[best] > 0 else "other"


def _auto_tags(name: Optional[str], description: Optional[str] = None,
               content: Optional[str] = None, category: Optional[str] = None) -> str:
    """离线规则法自动生成逗号分隔标签（含分类基础标签 + 关键词派生标签），上限 6 个。"""
    text = " ".join([name or "", description or "", content or ""]).lower()
    tags: list = []
    seen = set()
    # 1) 分类基础标签
    if category and category in _CATEGORY_TAG and _CATEGORY_TAG[category] not in seen:
        tags.append(_CATEGORY_TAG[category]); seen.add(_CATEGORY_TAG[category])
    # 2) 关键词派生标签
    for kw, tag in _TAG_KEYWORDS.items():
        if tag in seen:
            continue
        if _kw_hit(text, kw):
            tags.append(tag); seen.add(tag)
    return ",".join(tags[:6])


def _norm_name(name: Optional[str]) -> str:
    """技能名归一化：去首尾空格、空白折叠、转小写，用于唯一性校验。"""
    return re.sub(r"\s+", " ", (name or "").strip().lower())


# ===== Agent 接入前连通性 / 鉴权校验 =====
def _normalize_dify_url(endpoint: str) -> str:
    ep = endpoint.rstrip("/")
    if ep.endswith("/chat-messages"):
        return ep
    if ep.endswith("/v1/chat-messages"):
        return ep
    if ep.endswith("/v1"):
        return ep + "/chat-messages"
    return ep + "/v1/chat-messages"


def _short_err(e: Exception) -> str:
    return str(e)[:160]


def _post_follow(url: str, headers: dict, json_body: dict, timeout: float = 15.0):
    """POST 并手动跟随 301/302/307/308 重定向(**保持 POST 方法与请求体**)。

    背景：Dify 若填写 http:// 地址会 301 永久重定向到 https://；httpx 内建
    follow_redirects 对 301/302 会把 POST 降级为 GET(浏览器行为)，导致对
    /v1/chat-messages 变成 GET → 405 method_not_allowed。故手动跟随并保持 POST。
    容器内 env 有坏代理(502)，必须 trust_env=False 直连。
    """
    cur = url
    last = None
    for _ in range(4):
        last = httpx.post(cur, headers=headers, json=json_body, timeout=timeout,
                          trust_env=False, follow_redirects=False)
        if last.status_code in (301, 302, 307, 308):
            loc = last.headers.get("location")
            if not loc:
                return last
            cur = loc if loc.startswith("http") else str(httpx.URL(cur).join(loc))
            continue
        return last
    return last


def verify_agent_connectivity(platform: str, endpoint: str, api_key: str) -> dict:
    """
    接入 Agent 前的连通性 + 鉴权校验。
    返回 {ok, verified, detail}
      ok:       是否通过（dify=鉴权通过；n8n/coze/其他=地址可达）
      verified: 是否做了真正的鉴权验证（dify 为 True，其余为 False）
    """
    ep = (endpoint or "").strip()
    if not ep or not ep.startswith(("http://", "https://")):
        return {"ok": False, "verified": False, "detail": "Endpoint 必须以 http:// 或 https:// 开头"}
    platform = (platform or "dify").lower()

    # 关键：容器内 env 有坏代理(502)，必须 trust_env=False 直连
    if platform == "dify":
        url = _normalize_dify_url(ep)
        payload = {
            "inputs": {},
            "query": "连通性测试",
            "user": "__verify__",
            "response_mode": "blocking",
        }
        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
        try:
            r = _post_follow(url, headers, payload, timeout=15.0)
        except Exception as e:
            return {"ok": False, "verified": False, "detail": f"无法连接 Dify 地址：{_short_err(e)}"}
        if r.status_code == 200:
            return {"ok": True, "verified": True, "detail": "连通且 API Key 有效"}
        if r.status_code in (401, 403):
            return {"ok": False, "verified": False, "detail": "API Key 无效（401/403）"}
        if r.status_code == 404:
            return {"ok": False, "verified": False,
                    "detail": "地址路径不正确（404），应为 .../v1/chat-messages"}
        if r.status_code in (301, 302, 307, 308):
            loc = r.headers.get("location") or ""
            return {"ok": False, "verified": False,
                    "detail": f"地址被重定向（{r.status_code}）到 {loc or '未知'}；"
                              f"请直接填写重定向后的地址（通常把 http:// 改为 https://）"}
        if r.status_code == 400:
            # 400 需区分两种情况：
            #  (a) 到达应用且鉴权通过，但 Dify 应用/工作流内部执行报错(invalid_param + Run failed)
            #  (b) 纯参数错误
            body = (r.text or "")
            low = body.lower()
            if ("run failed" in low or "error code" in low or "workflow" in low
                    or "node" in low or "-500" in body):
                return {"ok": True, "verified": True,
                        "detail": "连通且 API Key 有效；但你的 Dify 应用内部执行报错："
                                  f"{body[:180]}。这是你自建 Dify 应用/工作流本身的问题"
                                  "（例如代码节点沙箱缺少 python3），请在 Dify 侧修复。"}
            return {"ok": False, "verified": False, "detail": f"参数错误（400）：{body[:180]}"}
        return {"ok": False, "verified": False, "detail": f"Dify 返回状态码 {r.status_code}"}

    # n8n / coze / 其他：仅做可达性探测（HEAD，避免触发 webhook 副作用）
    try:
        r = httpx.head(ep, timeout=12.0, trust_env=False, follow_redirects=True)
        if r.status_code < 500:
            return {"ok": True, "verified": False,
                    "detail": f"地址可连通（HTTP {r.status_code}），运行时再做协议级鉴权"}
        return {"ok": False, "verified": False, "detail": f"服务返回 {r.status_code}，地址可能不可用"}
    except Exception as e:
        return {"ok": False, "verified": False, "detail": f"地址不可达：{_short_err(e)}"}


# ===== 业务场景分类（面向用户的技能/MCP 分类，与后端模型路由的 capability_registry 解耦） =====
# 注意：MarketApp.capability 列在此存放「业务场景 id」（见 MARKET_SCENES），不再是 text/vision 等模型能力。
MARKET_SCENES: list = [
    # 元宝生成的「岗位 / 职能」分类（面向使用者视角，与后端模型路由能力解耦）
    {"id": "design",    "label": "🎨 做设计",     "color": "#EC4899", "desc": "页面、UI、视觉", "kw": "做设计"},
    {"id": "frontend",  "label": "💻 写前端",     "color": "#3B82F6", "desc": "Web 页面、React、Next.js", "kw": "写前端"},
    {"id": "mobile",    "label": "📱 做移动端",   "color": "#06B6D4", "desc": "React Native、Expo", "kw": "做移动端"},
    {"id": "backend",   "label": "🧪 后端/全栈",  "color": "#8B5CF6", "desc": "API、数据库、TypeScript", "kw": "后端"},
    {"id": "qa",        "label": "🧪 测试质量",   "color": "#6366F1", "desc": "TDD、Playwright、验证", "kw": "测试"},
    {"id": "search",    "label": "🔍 搜索信息",   "color": "#0EA5E9", "desc": "网页抓取、质疑、SEO", "kw": "搜索"},
    {"id": "docs",      "label": "✍️ 写文档",     "color": "#F59E0B", "desc": "Word/PPT/PDF、文案、PRD", "kw": "写文档"},
    {"id": "marketing", "label": "📢 推广获客",   "color": "#F43F5E", "desc": "营销、社媒、邮件、定价", "kw": "推广"},
    {"id": "workflow",  "label": "🔄 工作流",     "color": "#14B8A6", "desc": "计划、调试、分级、原型", "kw": "工作流"},
    {"id": "secops",    "label": "🛡️ 安全运维",  "color": "#EF4444", "desc": "安全审计、Azure、K8s", "kw": "安全"},
    {"id": "learning",  "label": "🎓 学习教学",   "color": "#10B981", "desc": "教学、提问、架构改进", "kw": "学习"},
    {"id": "video",     "label": "🎬 视频多媒体", "color": "#D946EF", "desc": "AI视频、数字人", "kw": "视频"},
    {"id": "collab",    "label": "🏢 办公协作",   "color": "#64748B", "desc": "飞书全家桶", "kw": "办公"},
    {"id": "ai",        "label": "🛠️ AI能力",     "color": "#A855F7", "desc": "创建Skill、代码审查、统计", "kw": "AI能力"},
]
_VALID_SCENE_IDS = {s["id"] for s in MARKET_SCENES}


def _scene_label(scene_id):
    return next((s["label"] for s in MARKET_SCENES if s["id"] == scene_id), None)


def _classify_scene(name: str, description: Optional[str], content: Optional[str], db: Session) -> Optional[str]:
    """用平台文本模型把应用归类到面向用户的业务场景之一；失败返回 None（不阻断导入）。"""
    try:
        text_model = _resolve_auto_model("text", db)
        if not text_model:
            return None
        provider = None
        if getattr(text_model, "provider_id", None):
            provider = db.query(ModelProvider).filter(ModelProvider.id == text_model.provider_id).first()
        api_key = text_model.api_key or (provider.api_key if provider else None)
        if not api_key:
            return None
        api_url = text_model.endpoint or (
            f"{provider.api_base_url}/v1/chat/completions" if provider and provider.api_base_url else None
        )
        if not api_url:
            return None
        options = "、".join(f"{s['id']}({s['label']}：{s.get('desc','')})" for s in MARKET_SCENES)
        sys_prompt = (
            "你是 AI 应用市场的『技能场景分类器』。请站在使用者视角，根据应用名称、描述与内容，"
            "判断它最贴合下列哪一类【岗位 / 职能 / 业务场景】，并只输出对应英文 id："
            f"{options}。\n必须只返回如下 JSON，且 capability 的值只能是上面列出的英文 id（小写），"
            "不要返回中文标签、不要任何解释或 Markdown 代码块：{\"capability\": \"<id>\"}"
        )
        user_text = f"名称：{name}\n描述：{description or ''}\n内容摘要：{(content or '')[:2000]}"
        messages = [
            {"role": "system", "content": sys_prompt},
            {"role": "user", "content": user_text},
        ]
        proxy = _skill_http_proxy()
        with httpx.Client(timeout=25, follow_redirects=True, trust_env=False, proxy=proxy) as c:
            r = c.post(
                api_url,
                headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
                json={"model": text_model.name, "messages": messages, "max_tokens": 64, "temperature": 0, "enable_thinking": False},
            )
        if r.status_code != 200:
            return None
        data = r.json()
        text_out = data.get("choices", [{}])[0].get("message", {}).get("content", "")
        # 主解析：标准 JSON 的 capability 字段
        m = re.search(r'"capability"\s*:\s*"([a-z_]+)"', text_out)
        if m and m.group(1) in _VALID_SCENE_IDS:
            return m.group(1)
        # 兜底：在输出中扫描任一合法 id 或中文关键词（容错标签/未加引号/多余文本等情况）
        for s in MARKET_SCENES:
            sid = s["id"]
            if re.search(r'(?<![a-z])' + re.escape(sid) + r'(?![a-z])', text_out):
                return sid
            kw = s.get("kw", "")
            if kw and kw in text_out:
                return sid
        return None
    except Exception:
        return None


class VerifyAgentRequest(BaseModel):
    platform: Optional[str] = None
    endpoint: str
    api_key: str


@router.post("/apps/verify-agent")
def verify_agent(
    req: VerifyAgentRequest,
    current_user: User = Depends(get_current_user),
):
    """接入 Agent 前手动测试连通性 / 鉴权，供前台「测试连接」按钮调用。"""
    result = verify_agent_connectivity(req.platform or "dify", req.endpoint, req.api_key)
    return {"code": 0, "data": result, "message": "ok"}


class DetectCapabilityRequest(BaseModel):
    name: str
    description: Optional[str] = None
    skill_content: Optional[str] = None
    type: Optional[str] = None


@router.post("/apps/detect-capability")
def detect_capability(
    req: DetectCapabilityRequest,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """导入前识别阶段：AI 识别业务场景(capability)，离线规则法自动归类分类 + 自动打标签，
    供前台预填并允许用户修改。"""
    cap = _classify_scene(req.name, req.description, req.skill_content, db)
    label = _scene_label(cap)
    category = _auto_category(req.name, req.description, req.skill_content)
    tags = _auto_tags(req.name, req.description, req.skill_content, category)
    return {"code": 0, "data": {
        "capability": cap, "label": label,
        "category": category, "tags": tags,
    }, "message": "ok"}


@router.get("/ads")
def list_public_ads(db: Session = Depends(get_db)):
    """
    前台首页「精选推荐」广告位：返回已上架(active)广告，按排序升序，无需登录。
    供 LandingPage 轮播调用，无鉴权依赖。
    """
    ads = (
        db.query(AdBanner)
        .filter(AdBanner.status == "active")
        .order_by(AdBanner.sort_order.asc())
        .all()
    )
    return [
        {
            "id": a.id,
            "title": a.title,
            "image_url": a.image_url,
            "link_app_id": a.link_app_id,
            "link_app_name": a.link_app_name,
            "sort_order": a.sort_order,
            "click_count": a.click_count,
            "status": a.status,
            "created_at": a.created_at.isoformat() if a.created_at else None,
        }
        for a in ads
    ]


class UploadAppRequest(BaseModel):
    name: str = Field(min_length=1, max_length=200)
    description: Optional[str] = None
    icon: Optional[str] = None
    type: Optional[str] = None  # skill, agent, mcp
    source: Optional[str] = None
    price: float = Field(default=0, ge=0)
    download_url: Optional[str] = None
    skill_content: Optional[str] = None
    category: Optional[str] = None
    capability: Optional[str] = None
    tags: Optional[str] = None
    is_member_free: Optional[bool] = False
    join_promotion: Optional[bool] = False
    agent_endpoint: Optional[str] = None
    api_key: Optional[str] = None
    platform: Optional[str] = None
    dependencies: Optional[list] = None  # Phase 4.1: 依赖声明


class PurchaseAppRequest(BaseModel):
    amount: Optional[float] = None


class ReviewAppRequest(BaseModel):
    rating: int = Field(ge=1, le=5)
    content: Optional[str] = None


@router.get("/apps")
def list_apps(
    type: Optional[str] = Query(None),
    source: Optional[str] = Query(None),
    capability: Optional[str] = Query(None),
    search: Optional[str] = Query(None),
    sort: str = Query(default="latest"),
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=100),
    db: Session = Depends(get_db),
    user_id: Optional[str] = Depends(get_current_user_id_optional),
):
    query = db.query(MarketApp).filter(MarketApp.status == "published")

    if type:
        query = query.filter(MarketApp.type == type)
    if source:
        query = query.filter(MarketApp.source == source)
    if capability:
        query = query.filter(MarketApp.capability == capability)
    if search:
        query = query.filter(
            and_(
                MarketApp.name.ilike(f"%{search}%")
                | MarketApp.description.ilike(f"%{search}%")
            )
        )

    if sort == "popular":
        query = query.order_by(desc(MarketApp.install_count))
    elif sort == "rating":
        query = query.order_by(desc(MarketApp.rating_avg))
    else:
        query = query.order_by(desc(MarketApp.created_at))

    total = query.count()
    apps = query.offset((page - 1) * page_size).limit(page_size).all()

    # 如果用户已登录，获取该用户已安装的应用ID集合（确保按用户隔离）
    installed_app_ids = set()
    if user_id:
        installations = db.query(AppInstallation.app_id).filter(
            AppInstallation.user_id == user_id
        ).all()
        installed_app_ids = {inst[0] for inst in installations}

    # 查询已安装状态时始终带 user_id 过滤

    result = []
    for app in apps:
        # 用户自己创建/导入的应用应始终视为已安装（避免安装记录缺失导致显示未安装）
        is_user_owned = bool(user_id) and app.source == "user" and app.publisher_id == user_id
        item = {
            "id": app.id,
            "name": app.name,
            "description": app.description,
            "icon": app.icon,
            "type": app.type,
            "source": app.source,
            "publisher_id": app.publisher_id,
            "publisher_name": app.publisher_name,
            "is_member_free": app.is_member_free if app.is_member_free else False,
            "join_promotion": app.join_promotion if app.join_promotion else False,
            "status": app.status,
            "price": float(app.price) if app.price else 0,
            "install_count": app.install_count or 0,
            "rating_avg": float(app.rating_avg) if app.rating_avg else 0,
            "review_count": app.review_count or 0,
            "created_at": str(app.created_at) if app.created_at else None,
            "capability": app.capability or None,
            "category": app.category or None,
            "tags": app.tags or None,
            # 官方导入并发布的技能默认全局已安装（见 #716：无论前台/后台导入，默认全局安装）
            "installed": (
                app.id in installed_app_ids
                or is_user_owned
                or (app.source == "official" and app.status == "published")
            ),
            "version": app.version or "1.0.0",
            "security_scan": app.security_scan,
            "verified": bool(app.verified),
            "dependencies": app.dependencies,
        }
        result.append(item)

    return {
        "code": 0,
        "data": {
            "total": total,
            "page": page,
            "page_size": page_size,
            "items": result,
        },
        "message": "ok",
    }


@router.get("/apps/{app_id}")
def get_app(
    app_id: str,
    db: Session = Depends(get_db),
    current_user: Optional[User] = Depends(get_current_user),
):
    app = db.query(MarketApp).filter(MarketApp.id == app_id).first()
    if not app:
        raise HTTPException(status_code=404, detail="应用不存在")

    # 检查当前用户是否已购买（按用户隔离）
    purchased = False
    installed = False
    if current_user:
        purchase = db.query(AppPurchase).filter(
            and_(AppPurchase.app_id == app_id, AppPurchase.user_id == current_user.id)
        ).first()
        if purchase:
            purchased = True
            installed = purchase.status == "installed"
        # 通过 AppInstallation 表检查是否已安装（按用户隔离）
        installation = db.query(AppInstallation).filter(
            and_(AppInstallation.app_id == app_id, AppInstallation.user_id == current_user.id)
        ).first()
        if installation:
            installed = True

    return {
        "code": 0,
        "data": {
            "id": app.id, "name": app.name, "description": app.description,
            "icon": app.icon, "type": app.type, "source": app.source,
            "type": app.type, 
            "price": float(app.price) if app.price else 0,
            "install_count": app.install_count or 0,
            "rating_avg": float(app.rating_avg) if app.rating_avg else 0,
            "review_count": app.review_count or 0,
            "publisher_id": app.publisher_id,
            "download_url": getattr(app, "download_url", None),
            "detail": getattr(app, "detail", None),
            "capability": app.capability or None,
            "category": app.category or None,
            "tags": app.tags or None,
            "created_at": str(app.created_at),
            "purchased": purchased,
            # 官方导入并发布的技能默认全局已安装（见 #716）
            "installed": installed or (app.source == "official" and app.status == "published"),
            "version": app.version or "1.0.0",
            "security_scan": app.security_scan,
            "verified": bool(app.verified),
            "dependencies": app.dependencies,
        },
        "message": "ok",
    }


def _snapshot_version(app, db, created_by=None):
    """Phase 4.1: 写入一条应用版本快照（market_app_versions）。"""
    snap = MarketAppVersion(
        app_id=app.id,
        version=app.version or "1.0.0",
        type=app.type,
        config={
            "name": app.name,
            "description": app.description,
            "icon": app.icon,
            "type": app.type,
            "price": float(app.price) if app.price else 0,
            "skill_content": app.skill_content,
            "mcp_transport": app.mcp_transport,
            "agent_endpoint": app.agent_endpoint,
            "capability": app.capability,
            "tool_policy": app.tool_policy,
            "orchestration": app.orchestration,
        },
        security_scan=app.security_scan,
        dependencies=app.dependencies,
        created_by=created_by,
        created_at=datetime.now(),
    )
    db.add(snap)
    db.commit()


@router.post("/apps")
def upload_app(
    req: UploadAppRequest,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    # 接入 Agent 时先做连通性 / 鉴权校验，避免把无效连接存进库
    if (req.type or "") == "agent" and req.agent_endpoint and req.api_key:
        v = verify_agent_connectivity(req.platform or "dify", req.agent_endpoint, req.api_key)
        if not v["ok"]:
            raise HTTPException(
                status_code=400,
                detail=f"Agent 连接校验未通过：{v['detail']}",
            )

    # source 判定：管理员（admin 角色）通过前台市场导入/开发的 Agent/Skill/MCP
    # 统一标记为官方（official），其余用户按请求或默认为 user。
    if current_user.role == "admin":
        app_source = "official"
    elif req.source and req.source in ("official", "user"):
        app_source = req.source
    else:
        app_source = "user"

    # 唯一性校验：同名(同类型)技能不允许重复导入，避免给平台徒增垃圾数据与运行压力(#690)
    _app_type = req.type if req.type in ("skill", "agent", "mcp") else "skill"
    _dup = db.query(MarketApp).filter(
        func.lower(MarketApp.name) == _norm_name(req.name),
        MarketApp.type == _app_type,
    ).first()
    if _dup:
        raise HTTPException(
            status_code=409,
            detail=f"技能「{req.name}」已存在，无需重复导入（平台已有同名技能，ID: {_dup.id}）",
        )

    # 自动分类 + 自动打标签：前端未显式指定时由离线规则法兜底(#690)
    _classify_content = req.skill_content or req.download_url or ""
    _final_category = req.category or _auto_category(req.name, req.description, _classify_content)
    _final_tags = req.tags or _auto_tags(req.name, req.description, _classify_content, _final_category)

    app = MarketApp(
        id=gen_uuid(),
        name=req.name,
        description=req.description,
        icon=req.icon,
        type=_app_type,
        source=app_source,
        category=_final_category,  # 持久化分类（#679 修复：此前未落库导致分类丢失）
        tags=_final_tags,
        platform=req.platform,
        price=req.price,
        install_count=0,
        rating_avg=0,
        review_count=0,
        publisher_id=current_user.id,
        publisher_name=current_user.username,
        is_member_free=req.is_member_free if req.is_member_free is not None else False,
        join_promotion=req.join_promotion if req.join_promotion is not None else False,
        agent_endpoint=req.agent_endpoint,
        agent_api_key=encrypt_secret(req.api_key),
        status="published",  # 用户创建的应用直接发布
        created_at=datetime.now(),
        updated_at=datetime.now(),
    )
    # 能力分类：前端显式指定优先；否则导入阶段由 AI 自动归类；都不行则留空（不阻断导入）
    app.capability = req.capability or _classify_scene(req.name, req.description, _classify_content, db) or None
    db.add(app)
    db.commit()
    db.refresh(app)

    # MCP 应用同步注册到后台 MCP Client 管理（mcp_servers 表）
    if app.type == "mcp":
        code = req.download_url or ""
        if code:
            app.skill_content = code
        parsed = parse_mcp_config(code)
        transport = parsed["transport_type"]
        app.mcp_transport = transport
        db.commit()
        db.refresh(app)

        existing_server = db.query(MCPServer).filter(MCPServer.id == app.id).first()
        if not existing_server:
            url = parsed["url"] or _extract_url_from_text(req.description or "") or ""
            headers_json = json.dumps(parsed["headers"], ensure_ascii=False) if parsed["headers"] else "{}"
            server = MCPServer(
                id=app.id,
                name=app.name,
                description=app.description or "",
                transport_type=transport,
                command="",
                args="{}",
                env_vars="{}",
                url=url,
                headers=headers_json,
                is_enabled=True,
                status="disconnected",
                tools_count=0,
                resources_count=0,
                created_at=app.created_at or datetime.now(),
                updated_at=app.updated_at or datetime.now(),
            )
            db.add(server)
            db.commit()

            # 导入后自动做一次连通性测试，状态会同步为 connected / error
            _test_mcp_server(server, db)

    # Skill / Agent：保存真实技能定义内容，否则对话里读不到 skill_content → 导入成功但失效
    if app.type == "skill":
        content = req.skill_content or ""
        if not content and req.download_url:
            # Hub 导入：按目录 URL 抓取真实 SKILL.md 内容回填
            content = _fetch_skill_content(req.download_url) or ""
        if not content:
            # 兜底：抓取/粘贴均未提供内容时，基于名称/描述/分类生成可用 SKILL.md，
            # 避免空壳技能（#681 根因修复：保证再次导入也不会内容为空）
            content = _generate_skill_content(app.name, app.description, req.category, app.capability)
        app.skill_content = content
        db.commit()
    elif app.type == "agent":
        if req.skill_content:
            app.skill_content = req.skill_content
            db.commit()

    # 用户创建/导入的应用自动标记为已安装
    existing_install = db.query(AppInstallation).filter(
        AppInstallation.user_id == current_user.id,
        AppInstallation.app_id == app.id,
    ).first()
    if not existing_install:
        installation = AppInstallation(
            user_id=current_user.id,
            app_id=app.id,
            installed_at=datetime.now(),
        )
        db.add(installation)
        db.commit()

    # Phase 4.1: 创建即安全扫描 + 初始版本快照 + 绿标(仅 pass 自动给)
    scan_result = scan_market_app(
        app_type=app.type,
        skill_content=app.skill_content,
        agent_endpoint=app.agent_endpoint,
        mcp_transport=app.mcp_transport,
        mcp_config=app.skill_content if app.type == "mcp" else None,
        dependencies=req.dependencies,
    )
    app.version = "1.0.0"
    app.security_scan = scan_result
    app.dependencies = req.dependencies
    app.verified = (scan_result.get("status") == "pass")
    db.commit()
    db.refresh(app)
    _snapshot_version(app, db, current_user.id)

    LogService.log_operation(
        user_id=current_user.id, username=current_user.username, action="upload_app",
        target="market_app", target_id=app.id,
        detail=f"上传应用 {app.name}（安检 {scan_result.get('status')}）",
    )

    return {
        "code": 0,
        "data": {
            "id": app.id, "name": app.name, "status": app.status,
            "capability": app.capability,
            "created_at": str(app.created_at),
        },
        "message": "提交成功，等待审核",
    }


@router.post("/apps/{app_id}/purchase")
def purchase_app(
    app_id: str,
    req: PurchaseAppRequest,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    app = db.query(MarketApp).filter(
        and_(MarketApp.id == app_id, MarketApp.status == "published")
    ).first()
    if not app:
        raise HTTPException(status_code=404, detail="应用不存在或未上架")

    # 检查是否已购买
    existing = db.query(AppPurchase).filter(
        and_(AppPurchase.app_id == app_id, AppPurchase.user_id == current_user.id)
    ).first()
    if existing and existing.status in ("purchased", "installed"):
        raise HTTPException(status_code=400, detail="您已购买该应用")

    amount = req.amount or app.price

    # 创建订单
    order = Order(
        id=gen_uuid(),
        user_id=current_user.id,
        order_type="app",
        item_id=app_id,
        item_name=app.name,
        amount=amount,
        status="pending",
        created_at=datetime.now(),
    )
    db.add(order)
    db.flush()

    # 创建购买记录
    purchase = AppPurchase(
        id=gen_uuid(),
        user_id=current_user.id,
        app_id=app_id,
        order_id=order.id,
        status="purchased",
        purchased_at=datetime.now(),
    )
    db.add(purchase)

    # 更新应用下载量
    app.install_count = (app.install_count or 0) + 1
    app.updated_at = datetime.now()

    db.commit()

    return {
        "code": 0,
        "data": {
            "order_id": order.id,
            "purchase_id": purchase.id,
            "amount": amount,
            "status": "purchased",
        },
        "message": "购买成功",
    }


@router.post("/apps/{app_id}/install")
def install_app(
    app_id: str,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    app = db.query(MarketApp).filter(MarketApp.id == app_id).first()
    if not app:
        raise HTTPException(status_code=404, detail="应用不存在")

    # 检查是否已安装（通过 AppInstallation 表）
    existing_install = db.query(AppInstallation).filter(
        and_(AppInstallation.app_id == app_id, AppInstallation.user_id == current_user.id)
    ).first()
    if existing_install:
        raise HTTPException(status_code=400, detail="应用已安装")

    # 检查是否已购买（付费应用需要先购买）
    purchase = db.query(AppPurchase).filter(
        and_(AppPurchase.app_id == app_id, AppPurchase.user_id == current_user.id)
    ).first()

    # 对于付费应用，必须已购买才能安装
    if float(app.price or 0) > 0:
        if not purchase:
            raise HTTPException(status_code=403, detail="请先购买应用")
        if purchase.status == "installed":
            raise HTTPException(status_code=400, detail="应用已安装")

    # 创建安装记录
    installation = AppInstallation(
        id=gen_uuid(),
        user_id=current_user.id,
        app_id=app_id,
        installed_at=datetime.now(),
    )
    db.add(installation)

    # 如果有购买记录，更新状态为已安装
    if purchase:
        purchase.status = "installed"
        purchase.installed_at = datetime.now()

    # 更新应用安装量
    app.install_count = (app.install_count or 0) + 1
    app.updated_at = datetime.now()

    db.commit()

    return {
        "code": 0,
        "data": {"installation_id": installation.id, "status": "installed"},
        "message": "安装成功",
    }


@router.delete("/apps/{app_id}/uninstall")
def uninstall_app(
    app_id: str,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """卸载应用 - 删除当前用户的安装记录（按用户隔离）"""
    app = db.query(MarketApp).filter(MarketApp.id == app_id).first()
    if not app:
        raise HTTPException(status_code=404, detail="应用不存在")

    # 查找当前用户的安装记录（按用户隔离）
    installation = db.query(AppInstallation).filter(
        and_(AppInstallation.app_id == app_id, AppInstallation.user_id == current_user.id)
    ).first()
    if not installation:
        raise HTTPException(status_code=400, detail="应用未安装")

    # 删除安装记录
    db.delete(installation)

    # 问题4修复: 将AppPurchase状态从installed重置为purchased
    purchase = db.query(AppPurchase).filter(
        and_(AppPurchase.app_id == app_id, AppPurchase.user_id == current_user.id)
    ).first()
    if purchase and purchase.status == "installed":
        purchase.status = "purchased"

    # 更新应用安装量（减1，最小为0）
    if app.install_count and app.install_count > 0:
        app.install_count = app.install_count - 1
    app.updated_at = datetime.now()

    db.commit()

    LogService.log_operation(
        user_id=current_user.id, username=current_user.username, action="uninstall_app",
        target="market_app", target_id=app_id,
        detail=f"卸载应用 {app.name}",
    )

    return {
        "code": 0,
        "message": "卸载成功",
    }


@router.post("/apps/{app_id}/review")
def review_app(
    app_id: str,
    req: ReviewAppRequest,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    app = db.query(MarketApp).filter(MarketApp.id == app_id).first()
    if not app:
        raise HTTPException(status_code=404, detail="应用不存在")

    # 检查是否已评价
    existing = db.query(AppReview).filter(
        and_(AppReview.app_id == app_id, AppReview.user_id == current_user.id)
    ).first()
    if existing:
        # 更新已有评价
        old_rating = existing.rating
        existing.rating = req.rating
        existing.content = req.content
        existing.updated_at = datetime.now()

        # 重新计算平均分 (总数不变，减去旧评分加新评分)
        if app.review_count and app.review_count > 0:
            total_rating = float(app.rating_avg or 0) * app.review_count
            total_rating = total_rating - old_rating + req.rating
            app.rating_avg = total_rating / app.review_count
        else:
            app.rating_avg = req.rating
            app.review_count = 1
    else:
        # 创建新评价
        review = AppReview(
            id=gen_uuid(),
            app_id=app_id,
            user_id=current_user.id,
            rating=req.rating,
            content=req.content,
            created_at=datetime.now(),
            updated_at=datetime.now(),
        )
        db.add(review)

        # 重新计算平均分
        app.review_count = (app.review_count or 0) + 1
        if app.review_count == 1:
            app.rating_avg = req.rating
        else:
            total_rating = float(app.rating_avg or 0) * (app.review_count - 1) + req.rating
            app.rating_avg = round(total_rating / app.review_count, 1)

    app.updated_at = datetime.now()
    db.commit()

    return {
        "code": 0,
        "data": {
            "rating_avg": float(app.rating_avg or 0),
            "review_count": app.review_count or 0,
        },
        "message": "评价成功",
    }


@router.get("/my-apps")
def get_my_apps(
    status: Optional[str] = Query(None),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    query = db.query(AppPurchase).filter(AppPurchase.user_id == current_user.id)
    purchases = query.order_by(desc(AppPurchase.created_at)).all()

    result = []
    for p in purchases:
        app = db.query(MarketApp).filter(MarketApp.id == p.app_id).first()
        if app:
            result.append({
                "id": p.id,
                "app_id": app.id,
                "name": app.name,
                "icon": app.icon,
                "type": app.type,
                "price": float(app.price or 0),
                "purchased_at": str(p.created_at) if p.created_at else None,
            })

    return {"code": 0, "data": result, "message": "ok"}


@router.get("/reviews/{app_id}")
def get_reviews(
    app_id: str,
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    query = db.query(AppReview).filter(AppReview.app_id == app_id)
    total = query.count()

    reviews = (
        query.order_by(desc(AppReview.created_at))
        .offset((page - 1) * page_size)
        .limit(page_size)
        .all()
    )

    result = []
    for r in reviews:
        user = db.query(User).filter(User.id == r.user_id).first()
        result.append({
            "id": r.id,
            "user_id": r.user_id,
            "username": user.username if user else "unknown",
            "avatar": user.avatar if user else None,
            "rating": r.rating,
            "content": r.content,
            "created_at": str(r.created_at) if r.created_at else None,
        })

    return {
        "code": 0,
        "data": {"total": total, "page": page, "page_size": page_size, "items": result},
        "message": "ok",
    }


# ============================================================
# Agent部署资源查询接口
# ============================================================

@router.get("/agent-resources")
def get_agent_resources(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Agent部署时需要的资源列表：可用的应用、知识库、文档"""
    # 用户已发布的应用
    my_apps = db.query(MarketApp).filter(
        MarketApp.publisher_id == current_user.id,
        MarketApp.status == "published",
    ).order_by(desc(MarketApp.updated_at)).all()

    apps_result = []
    for app in my_apps:
        apps_result.append({
            "id": app.id,
            "name": app.name,
            "type": app.type,
            "description": app.description,
            "install_count": app.install_count or 0,
        })

    # 用户知识库
    from ..models import KnowledgeBase, KnowledgeDocument
    kb_list = db.query(KnowledgeBase).filter(
        KnowledgeBase.user_id == current_user.id
    ).order_by(desc(KnowledgeBase.updated_at)).all()

    kb_result = []
    for kb in kb_list:
        doc_count = db.query(KnowledgeDocument).filter(
            KnowledgeDocument.knowledge_base_id == kb.id
        ).count()
        kb_result.append({
            "id": kb.id,
            "name": kb.name,
            "description": kb.description,
            "document_count": doc_count,
        })

    # 用户已安装的应用（从AppPurchase）
    installed = db.query(AppPurchase).filter(
        AppPurchase.user_id == current_user.id
    ).all()
    installed_ids = [p.app_id for p in installed]
    installed_apps = []
    if installed_ids:
        iapps = db.query(MarketApp).filter(MarketApp.id.in_(installed_ids)).all()
        for ia in iapps:
            installed_apps.append({
                "id": ia.id,
                "name": ia.name,
                "type": ia.type,
                "description": ia.description,
            })

    return {
        "code": 0,
        "data": {
            "my_apps": apps_result,
            "knowledge_bases": kb_result,
            "installed_apps": installed_apps,
        },
        "message": "ok",
    }