app.py

from __future__ import annotations

import argparse
import getpass
import hashlib
import io
import ipaddress
import json
import os
import re
import secrets
import socket
import sqlite3
import subprocess
import sys
import threading
import webbrowser
import xml.etree.ElementTree as ET
from datetime import UTC, datetime
from html import escape, unescape
from pathlib import Path
from urllib.parse import parse_qsl, urlencode, urljoin, urlsplit, urlunsplit

import httpx
import keyring
import qrcode
from bs4 import BeautifulSoup
from flask import Flask, abort, redirect, render_template_string, request, send_file, url_for


APP_NAME = "WechatAutoShare"
KEYRING_SERVICE = "wechat-auto-share"
MAX_DOWNLOAD_BYTES = 2_000_000
WECOM_TOKEN_URL = "https://qyapi.weixin.qq.com/cgi-bin/gettoken"
WECOM_MOMENT_URL = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/add_moment_task"
DEFAULT_SOURCES = (
    ("OpenAI News", "https://openai.com/news/rss.xml", "rss", "A"),
    ("Google DeepMind", "https://deepmind.google/blog/rss.xml", "rss", "A"),
    ("Hugging Face Blog", "https://huggingface.co/blog/feed.xml", "rss", "A"),
    ("Anthropic News", "https://www.anthropic.com/news", "html", "A"),
    ("DeepSeek Research & News", "https://deepseek.com/en/news/", "html", "A"),
    ("量子位", "https://www.qbitai.com/", "html", "B"),
)
TRACKING_QUERY_KEYS = {
    "from",
    "ref",
    "source",
    "spm",
    "utm_campaign",
    "utm_content",
    "utm_medium",
    "utm_source",
    "utm_term",
}
AI_WORDS = (
    "ai",
    "artificial intelligence",
    "agent",
    "agi",
    "claude",
    "deepseek",
    "gemini",
    "gpt",
    "llm",
    "model",
    "人工智能",
    "大模型",
    "智能体",
    "模型",
)
GENERAL_WORDS = (
    "app",
    "available",
    "launch",
    "product",
    "release",
    "tool",
    "use",
    "应用",
    "产品",
    "发布",
    "上线",
    "工具",
)
HARDCORE_WORDS = (
    "architecture",
    "benchmark",
    "inference",
    "model card",
    "open source",
    "paper",
    "research",
    "training",
    "weights",
    "基准",
    "开源",
    "架构",
    "论文",
    "推理",
    "训练",
)


def now_iso() -> str:
    return datetime.now(UTC).replace(microsecond=0).isoformat()


def data_dir() -> Path:
    override = os.environ.get("WECHAT_AUTO_SHARE_DATA_DIR")
    if override:
        return Path(override).resolve()
    root = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
    return Path(root) / APP_NAME


def db_path() -> Path:
    return data_dir() / "app.db"


class ClosingConnection(sqlite3.Connection):
    def __exit__(self, exc_type, exc_value, traceback):
        try:
            return super().__exit__(exc_type, exc_value, traceback)
        finally:
            self.close()


def connect() -> sqlite3.Connection:
    data_dir().mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(db_path(), factory=ClosingConnection)
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA foreign_keys = ON")
    return conn


def ensure_column(conn: sqlite3.Connection, table: str, column: str, definition: str) -> None:
    columns = {row["name"] for row in conn.execute(f"PRAGMA table_info({table})")}
    if column not in columns:
        conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}")


def init_db() -> None:
    with connect() as conn:
        conn.executescript(
            """
            CREATE TABLE IF NOT EXISTS sources (
                id INTEGER PRIMARY KEY,
                name TEXT NOT NULL UNIQUE,
                url TEXT NOT NULL UNIQUE,
                kind TEXT NOT NULL CHECK(kind IN ('rss', 'html', 'manual')),
                tier TEXT NOT NULL CHECK(tier IN ('A', 'B')),
                enabled INTEGER NOT NULL DEFAULT 1,
                last_scan_at TEXT,
                last_error TEXT
            );
            CREATE TABLE IF NOT EXISTS articles (
                id INTEGER PRIMARY KEY,
                source_id INTEGER NOT NULL REFERENCES sources(id),
                url TEXT NOT NULL UNIQUE,
                title TEXT NOT NULL,
                content TEXT NOT NULL DEFAULT '',
                summary TEXT NOT NULL DEFAULT '',
                published_at TEXT,
                fingerprint TEXT NOT NULL UNIQUE,
                created_at TEXT NOT NULL
            );
            CREATE TABLE IF NOT EXISTS candidates (
                id INTEGER PRIMARY KEY,
                article_id INTEGER NOT NULL UNIQUE REFERENCES articles(id),
                general_score INTEGER NOT NULL,
                hardcore_score INTEGER NOT NULL,
                reason TEXT NOT NULL,
                general_copy TEXT NOT NULL DEFAULT '',
                hardcore_copy TEXT NOT NULL DEFAULT '',
                status TEXT NOT NULL DEFAULT 'pending',
                created_at TEXT NOT NULL
            );
            CREATE TABLE IF NOT EXISTS settings (
                key TEXT PRIMARY KEY,
                value TEXT NOT NULL
            );
            CREATE TABLE IF NOT EXISTS delivery_jobs (
                id INTEGER PRIMARY KEY,
                candidate_id INTEGER NOT NULL REFERENCES candidates(id),
                target TEXT NOT NULL,
                audience TEXT NOT NULL,
                idempotency_key TEXT NOT NULL UNIQUE,
                status TEXT NOT NULL,
                external_id TEXT NOT NULL DEFAULT '',
                request_json TEXT NOT NULL,
                response_json TEXT NOT NULL DEFAULT '',
                error TEXT NOT NULL DEFAULT '',
                confirmed_at TEXT NOT NULL,
                created_at TEXT NOT NULL
            );
            CREATE TABLE IF NOT EXISTS drafts (
                id INTEGER PRIMARY KEY,
                target TEXT NOT NULL,
                audience TEXT NOT NULL,
                title TEXT NOT NULL,
                summary TEXT NOT NULL,
                body_markdown TEXT NOT NULL,
                html TEXT NOT NULL,
                sources_json TEXT NOT NULL,
                status TEXT NOT NULL DEFAULT 'editing',
                created_at TEXT NOT NULL,
                updated_at TEXT NOT NULL
            );
            """
        )
        ensure_column(conn, "candidates", "general_copy", "TEXT NOT NULL DEFAULT ''")
        ensure_column(conn, "candidates", "hardcore_copy", "TEXT NOT NULL DEFAULT ''")
        conn.executemany(
            "INSERT OR IGNORE INTO sources(name, url, kind, tier) VALUES (?, ?, ?, ?)",
            DEFAULT_SOURCES,
        )
        conn.execute(
            "INSERT OR IGNORE INTO sources(name, url, kind, tier) VALUES (?, ?, 'manual', 'B')",
            ("手动提交", "manual://submitted"),
        )
        conn.execute(
            "INSERT OR IGNORE INTO settings(key, value) VALUES ('csrf_token', ?)",
            (secrets.token_urlsafe(24),),
        )


def get_setting(key: str, default: str = "") -> str:
    with connect() as conn:
        row = conn.execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone()
    return row["value"] if row else default


def set_setting(key: str, value: str) -> None:
    with connect() as conn:
        conn.execute(
            "INSERT INTO settings(key, value) VALUES (?, ?) "
            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
            (key, value),
        )


def set_wecom_credentials(corp_id: str, secret: str) -> None:
    corp_id = corp_id.strip()
    secret = secret.strip()
    if not corp_id or len(corp_id) > 128 or not secret or len(secret) > 512:
        raise ValueError("CorpID 和 Secret 不能为空")
    set_setting("wecom_corp_id", corp_id)
    keyring.set_password(KEYRING_SERVICE, "wecom-secret", secret)


def wecom_credentials() -> tuple[str, str]:
    corp_id = get_setting("wecom_corp_id")
    secret = keyring.get_password(KEYRING_SERVICE, "wecom-secret") or ""
    if not corp_id or not secret:
        raise ValueError("请先配置企业微信 CorpID 和 Secret")
    return corp_id, secret


def wecom_access_token() -> str:
    corp_id, secret = wecom_credentials()
    response = httpx.get(
        WECOM_TOKEN_URL,
        params={"corpid": corp_id, "corpsecret": secret},
        timeout=20,
    )
    response.raise_for_status()
    result = response.json()
    if not isinstance(result, dict):
        raise ValueError("企业微信鉴权返回了无效数据")
    if int(result.get("errcode", -1)) != 0 or not result.get("access_token"):
        raise RuntimeError(f"企业微信鉴权失败：{result.get('errcode', -1)} {result.get('errmsg', '未知错误')}")
    return str(result["access_token"])


def split_values(raw: str) -> list[str]:
    return [value.strip() for value in re.split(r"[,，\s]+", raw) if value.strip()]


def safe_error_text(error: Exception) -> str:
    return re.sub(
        r"(?i)(access_token|corpsecret)=([^&\s]+)",
        r"\1=***",
        str(error),
    )[:1000]


def build_wecom_moment_payload(
    candidate: sqlite3.Row,
    audience: str,
    user_list: str,
    department_list: str,
    tag_list: str,
) -> dict[str, object]:
    if audience not in {"general", "hardcore"}:
        raise ValueError("受众模式无效")
    users = split_values(user_list)
    try:
        departments = [int(value) for value in split_values(department_list)]
    except ValueError as exc:
        raise ValueError("部门 ID 必须是整数") from exc
    if any(value <= 0 for value in departments):
        raise ValueError("部门 ID 必须大于 0")
    if not users and not departments:
        raise ValueError("为防止误发，请至少填写一个执行成员或部门")
    sender_list: dict[str, object] = {}
    if users:
        sender_list["user_list"] = users
    if departments:
        sender_list["department_list"] = departments
    visible_range: dict[str, object] = {"sender_list": sender_list}
    tags = split_values(tag_list)
    if tags:
        visible_range["external_contact_list"] = {"tag_list": tags}
    return {
        "text": {"content": str(candidate[f"{audience}_copy"])[:2000]},
        "attachments": [
            {
                "msgtype": "link",
                "link": {"title": str(candidate["title"])[:128], "url": candidate["url"]},
            }
        ],
        "visible_range": visible_range,
    }


def submit_wecom_moment(
    candidate_id: int,
    audience: str,
    user_list: str,
    department_list: str,
    tag_list: str,
) -> dict[str, object]:
    with connect() as conn:
        candidate = conn.execute(
            """
            SELECT c.*, a.title, a.url
            FROM candidates c JOIN articles a ON a.id = c.article_id
            WHERE c.id = ?
            """,
            (candidate_id,),
        ).fetchone()
    if not candidate:
        raise ValueError("候选文章不存在")
    payload = build_wecom_moment_payload(candidate, audience, user_list, department_list, tag_list)
    request_json = json.dumps(payload, ensure_ascii=False, sort_keys=True)
    idempotency_key = hashlib.sha256(f"{candidate_id}\n{request_json}".encode("utf-8")).hexdigest()
    timestamp = now_iso()
    with connect() as conn:
        conn.execute("BEGIN IMMEDIATE")
        existing = conn.execute(
            "SELECT * FROM delivery_jobs WHERE idempotency_key = ?", (idempotency_key,)
        ).fetchone()
        if existing and existing["status"] in {"submitting", "submitted"}:
            return {
                "duplicate": True,
                "status": existing["status"],
                "jobid": existing["external_id"],
            }
        if existing:
            job_id = existing["id"]
            conn.execute(
                "UPDATE delivery_jobs SET status = 'submitting', error = '', confirmed_at = ? WHERE id = ?",
                (timestamp, job_id),
            )
        else:
            cursor = conn.execute(
                """
                INSERT INTO delivery_jobs(
                    candidate_id, target, audience, idempotency_key, status,
                    request_json, confirmed_at, created_at
                ) VALUES (?, 'wecom_moment', ?, ?, 'submitting', ?, ?, ?)
                """,
                (candidate_id, audience, idempotency_key, request_json, timestamp, timestamp),
            )
            job_id = cursor.lastrowid
    try:
        token = wecom_access_token()
        response = httpx.post(
            WECOM_MOMENT_URL,
            params={"access_token": token},
            json=payload,
            timeout=30,
        )
        response.raise_for_status()
        result = response.json()
        if not isinstance(result, dict):
            raise ValueError("企业微信创建任务返回了无效数据")
        if int(result.get("errcode", -1)) != 0 or not result.get("jobid"):
            raise RuntimeError(
                f"企业微信创建任务失败：{result.get('errcode', -1)} {result.get('errmsg', '未知错误')}"
            )
        response_json = json.dumps(result, ensure_ascii=False)
        with connect() as conn:
            conn.execute(
                "UPDATE delivery_jobs SET status = 'submitted', external_id = ?, response_json = ? WHERE id = ?",
                (str(result["jobid"]), response_json, job_id),
            )
        return {"duplicate": False, "status": "submitted", "jobid": str(result["jobid"])}
    except (httpx.HTTPError, KeyError, TypeError, ValueError, RuntimeError, keyring.errors.KeyringError) as exc:
        with connect() as conn:
            conn.execute(
                "UPDATE delivery_jobs SET status = 'failed', error = ? WHERE id = ?",
                (safe_error_text(exc), job_id),
            )
        raise


def normalize_url(url: str) -> str:
    parts = urlsplit(url.strip())
    query = [
        (key, value)
        for key, value in parse_qsl(parts.query, keep_blank_values=True)
        if key.lower() not in TRACKING_QUERY_KEYS and not key.lower().startswith("utm_")
    ]
    path = parts.path or "/"
    if path != "/":
        path = path.rstrip("/")
    return urlunsplit((parts.scheme.lower(), parts.netloc.lower(), path, urlencode(query), ""))


def validate_public_url(url: str, *, resolve: bool = True) -> str:
    normalized = normalize_url(url)
    parts = urlsplit(normalized)
    if parts.scheme not in {"http", "https"} or not parts.hostname or parts.username:
        raise ValueError("只允许不含账号信息的 HTTP/HTTPS 链接")
    if parts.hostname.lower() == "localhost":
        raise ValueError("不允许访问本机地址")
    try:
        literal = ipaddress.ip_address(parts.hostname)
        addresses = [literal]
    except ValueError:
        addresses = []
        if resolve:
            addresses = {
                ipaddress.ip_address(item[4][0])
                for item in socket.getaddrinfo(parts.hostname, parts.port or 443, type=socket.SOCK_STREAM)
            }
    if any(address.is_private or address.is_loopback or address.is_link_local or address.is_reserved for address in addresses):
        raise ValueError("不允许访问内网或保留地址")
    return normalized


def fetch_text(url: str) -> str:
    safe_url = validate_public_url(url)
    headers = {"User-Agent": "WechatAutoShare/0.1 (+local single-user reader)"}
    with httpx.Client(follow_redirects=True, timeout=20, headers=headers) as client:
        response = client.get(safe_url)
        response.raise_for_status()
        final_url = validate_public_url(str(response.url))
        if final_url != normalize_url(str(response.url)):
            raise ValueError("重定向目标无效")
        if int(response.headers.get("content-length", "0") or 0) > MAX_DOWNLOAD_BYTES:
            raise ValueError("页面超过 2 MB 限制")
        if len(response.content) > MAX_DOWNLOAD_BYTES:
            raise ValueError("页面超过 2 MB 限制")
        return response.text


def local_name(tag: str) -> str:
    return tag.rsplit("}", 1)[-1].lower()


def child_text(element: ET.Element, *names: str) -> str:
    wanted = {name.lower() for name in names}
    for child in element.iter():
        if child is element:
            continue
        if local_name(child.tag) in wanted and child.text:
            return child.text.strip()
    return ""


def strip_html(value: str) -> str:
    decoded = unescape(value or "")
    if "<" not in decoded and ">" not in decoded:
        return " ".join(decoded.split())
    return " ".join(BeautifulSoup(decoded, "html.parser").get_text(" ").split())


def parse_rss(xml_text: str, feed_url: str) -> list[dict[str, str]]:
    root = ET.fromstring(xml_text)
    nodes = [node for node in root.iter() if local_name(node.tag) in {"item", "entry"}]
    items: list[dict[str, str]] = []
    for node in nodes:
        title = strip_html(child_text(node, "title"))
        link = child_text(node, "link")
        if not link:
            for child in node.iter():
                if local_name(child.tag) == "link" and child.attrib.get("href"):
                    link = child.attrib["href"]
                    break
        if not title or not link:
            continue
        items.append(
            {
                "title": title,
                "url": urljoin(feed_url, link),
                "summary": strip_html(child_text(node, "description", "summary", "content")),
                "published_at": child_text(node, "pubdate", "published", "updated", "date"),
            }
        )
    return items


def parse_html_index(html_text: str, page_url: str) -> list[dict[str, str]]:
    soup = BeautifulSoup(html_text, "html.parser")
    candidates = soup.select("article a[href], h2 a[href], h3 a[href], a[href*='/news/'], a[href*='/blog/']")
    host = urlsplit(page_url).hostname
    seen: set[str] = set()
    items: list[dict[str, str]] = []
    for anchor in candidates:
        title = " ".join(anchor.get_text(" ", strip=True).split())
        if len(title) < 8:
            continue
        url = normalize_url(urljoin(page_url, anchor.get("href", "")))
        if url in seen or urlsplit(url).hostname != host or url == normalize_url(page_url):
            continue
        seen.add(url)
        items.append({"title": title, "url": url, "summary": "", "published_at": ""})
    return items


def extract_article(html_text: str, fallback_title: str = "") -> tuple[str, str]:
    soup = BeautifulSoup(html_text, "html.parser")
    for node in soup.select("script, style, nav, footer, noscript, svg"):
        node.decompose()
    title_node = soup.select_one("meta[property='og:title']")
    title = title_node.get("content", "").strip() if title_node else ""
    if not title and soup.title:
        title = soup.title.get_text(" ", strip=True)
    title = title or fallback_title
    main = soup.select_one("article") or soup.select_one("main") or soup.body
    paragraphs = main.select("p, li") if main else []
    content = "\n".join(
        text
        for text in (" ".join(node.get_text(" ", strip=True).split()) for node in paragraphs)
        if len(text) >= 30
    )
    return title[:500], content[:30_000]


def heuristic_score(title: str, content: str, source: str, tier: str) -> dict[str, object]:
    text = f"{title}\n{content[:10_000]}".lower()
    ai_hits = sum(1 for word in AI_WORDS if word in text)
    general_hits = sum(1 for word in GENERAL_WORDS if word in text)
    hardcore_hits = sum(1 for word in HARDCORE_WORDS if word in text)
    source_bonus = 10 if tier == "A" else 4
    general = min(100, 10 + source_bonus + ai_hits * 10 + general_hits * 6)
    hardcore = min(100, 10 + source_bonus + ai_hits * 10 + hardcore_hits * 8)
    return {
        "general_score": general,
        "hardcore_score": hardcore,
        "reason": f"本地初筛：AI 关键词 {ai_hits}，应用信号 {general_hits}，技术信号 {hardcore_hits}，来源 {tier} 级。",
        "general_copy": f"推荐一篇 AI 新文章：《{title}》。来自{source}，适合快速了解这项变化会带来什么影响。",
        "hardcore_copy": f"技术向推荐：《{title}》。建议重点关注其中的架构、基准数据、实现限制与可复现信息。来源：{source}。",
    }


def ai_config() -> tuple[str, str, str] | None:
    base_url = get_setting("ai_base_url")
    model = get_setting("ai_model")
    api_key = keyring.get_password(KEYRING_SERVICE, "ai-api-key")
    if base_url and model and api_key:
        return base_url, model, api_key
    return None


def set_ai_credentials(base_url: str, model: str, api_key: str) -> None:
    base_url = validate_public_url(base_url.strip())
    model = model.strip()
    api_key = api_key.strip()
    if not model or len(model) > 200 or not api_key or len(api_key) > 2000:
        raise ValueError("模型名称和 API Key 不能为空")
    set_setting("ai_base_url", base_url.rstrip("/"))
    set_setting("ai_model", model)
    keyring.set_password(KEYRING_SERVICE, "ai-api-key", api_key)


def score_article(title: str, content: str, source: str, tier: str) -> dict[str, object]:
    config = ai_config()
    if not config:
        return heuristic_score(title, content, source, tier)
    base_url, model, api_key = config
    endpoint = base_url.rstrip("/")
    if not endpoint.endswith("/chat/completions"):
        endpoint += "/chat/completions"
    prompt = {
        "title": title,
        "source": source,
        "source_tier": tier,
        "content": content[:12_000],
    }
    payload = {
        "model": model,
        "temperature": 0,
        "messages": [
            {
                "role": "system",
                "content": (
                    "评估一篇 AI 文章。只返回 JSON，字段为 general_score、hardcore_score、reason、"
                    "general_copy、hardcore_copy。"
                    "两个分数均为 0-100 整数。通俗分衡量普通人可理解的产品与影响价值；"
                    "硬核分衡量架构、论文、基准、训练、推理与开源价值。未经证实的传闻应降分。"
                    "两段 copy 分别是自然、不夸张的朋友圈推荐语，不包含文章链接，每段不超过 180 字。"
                ),
            },
            {"role": "user", "content": json.dumps(prompt, ensure_ascii=False)},
        ],
    }
    try:
        response = httpx.post(
            endpoint,
            headers={"Authorization": f"Bearer {api_key}"},
            json=payload,
            timeout=45,
        )
        response.raise_for_status()
        raw = response.json()["choices"][0]["message"]["content"]
        raw = re.sub(r"^```(?:json)?|```$", "", raw.strip(), flags=re.IGNORECASE).strip()
        result = json.loads(raw)
        return {
            "general_score": max(0, min(100, int(result["general_score"]))),
            "hardcore_score": max(0, min(100, int(result["hardcore_score"]))),
            "reason": str(result["reason"])[:1000],
            "general_copy": str(result["general_copy"])[:500],
            "hardcore_copy": str(result["hardcore_copy"])[:500],
        }
    except (httpx.HTTPError, KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
        fallback = heuristic_score(title, content, source, tier)
        fallback["reason"] = f"AI 评分失败，已使用本地初筛：{type(exc).__name__}。{fallback['reason']}"
        return fallback


def markdown_body_html(body: str) -> str:
    parts: list[str] = []
    in_list = False
    for raw_line in body.splitlines():
        line = raw_line.strip()
        if not line:
            if in_list:
                parts.append("</ul>")
                in_list = False
            continue
        if line.startswith("## "):
            if in_list:
                parts.append("</ul>")
                in_list = False
            parts.append(f"<h2>{escape(line[3:])}</h2>")
        elif line.startswith("### "):
            if in_list:
                parts.append("</ul>")
                in_list = False
            parts.append(f"<h3>{escape(line[4:])}</h3>")
        elif line.startswith("- "):
            if not in_list:
                parts.append("<ul>")
                in_list = True
            parts.append(f"<li>{escape(line[2:])}</li>")
        else:
            if in_list:
                parts.append("</ul>")
                in_list = False
            parts.append(f"<p>{escape(line)}</p>")
    if in_list:
        parts.append("</ul>")
    return "\n".join(parts)


def render_draft_html(title: str, summary: str, body: str, sources: list[dict[str, str]]) -> str:
    source_items = "\n".join(
        f'<li>[{index}] {escape(item["source"])}：<a href="{escape(item["url"], quote=True)}">{escape(item["title"])}</a></li>'
        for index, item in enumerate(sources, 1)
    )
    return (
        f"<article><h1>{escape(title)}</h1><p class=\"summary\">{escape(summary)}</p>"
        f"{markdown_body_html(body)}<h2>参考来源</h2><ol>{source_items}</ol></article>"
    )


def draft_markdown(draft: sqlite3.Row) -> str:
    sources = json.loads(draft["sources_json"])
    source_lines = "\n".join(
        f'{index}. [{item["source"]}：{item["title"]}]({item["url"]})'
        for index, item in enumerate(sources, 1)
    )
    return f'# {draft["title"]}\n\n> {draft["summary"]}\n\n{draft["body_markdown"]}\n\n## 参考来源\n\n{source_lines}\n'


def fallback_draft(rows: list[sqlite3.Row], audience: str) -> dict[str, str]:
    topic = rows[0]["title"]
    source_points = "\n".join(
        f'- {row["source_name"]}发布了《{row["title"]}》[{index}]。'
        for index, row in enumerate(rows, 1)
    )
    focus = (
        "这些变化会影响哪些真实使用场景、普通用户何时能够接触到，以及现阶段有哪些限制。"
        if audience == "general"
        else "建议逐项核对架构、训练与推理方法、基准口径、开放程度和复现条件。"
    )
    return {
        "title": f"从多方信息看：{topic}",
        "summary": "基于多个来源整理的编辑提纲；配置 AI API 后可生成完整原创稿。",
        "body": (
            "## 已确认的信息\n\n"
            f"{source_points}\n\n"
            "## 值得关注的问题\n\n"
            f"{focus}\n\n"
            "## 编辑说明\n\n"
            "当前未使用云端模型，因此这里只生成可核对来源的结构提纲，不建议未经补充和审校直接发布。"
        ),
    }


def generate_draft_content(rows: list[sqlite3.Row], audience: str) -> dict[str, str]:
    config = ai_config()
    if not config:
        return fallback_draft(rows, audience)
    base_url, model, api_key = config
    endpoint = base_url.rstrip("/")
    if not endpoint.endswith("/chat/completions"):
        endpoint += "/chat/completions"
    source_data = [
        {
            "number": index,
            "source": row["source_name"],
            "title": row["title"],
            "url": row["url"],
            "content": row["content"][:3000],
        }
        for index, row in enumerate(rows, 1)
    ]
    system = (
        "根据多个可靠来源写一篇中文微信公众号原创专题稿。只返回 JSON，字段为 title、summary、"
        "introduction、sections、conclusion；sections 是含 heading 和 body 的数组。"
        f"受众模式为{'通俗' if audience == 'general' else '硬核'}。"
        "事实陈述必须在句末用 [1]、[2] 标出来源编号；不得编造来源未提供的数字、评价或结论。"
        "区分事实、来源观点和分析，写明限制；不要输出参考来源列表，系统会自动追加。"
    )
    try:
        response = httpx.post(
            endpoint,
            headers={"Authorization": f"Bearer {api_key}"},
            json={
                "model": model,
                "temperature": 0.2,
                "messages": [
                    {"role": "system", "content": system},
                    {"role": "user", "content": json.dumps(source_data, ensure_ascii=False)},
                ],
            },
            timeout=90,
        )
        response.raise_for_status()
        raw = response.json()["choices"][0]["message"]["content"]
        raw = re.sub(r"^```(?:json)?|```$", "", raw.strip(), flags=re.IGNORECASE).strip()
        result = json.loads(raw)
        sections = result["sections"]
        if not isinstance(sections, list) or not sections:
            raise ValueError("缺少文章章节")
        body_parts = [str(result["introduction"])[:4000]]
        for section in sections[:8]:
            body_parts.extend(
                [f'## {str(section["heading"])[:120]}', str(section["body"])[:8000]]
            )
        body_parts.extend(["## 结语", str(result["conclusion"])[:4000]])
        title = str(result["title"]).strip()[:200]
        summary = str(result["summary"]).strip()[:500]
        body = "\n\n".join(body_parts)
        if not title or not summary or not all(f"[{index}]" in body for index in range(1, len(rows) + 1)):
            raise ValueError("草稿缺少标题、摘要或完整来源标注")
        return {
            "title": title,
            "summary": summary,
            "body": body,
        }
    except (httpx.HTTPError, KeyError, TypeError, ValueError, json.JSONDecodeError):
        return fallback_draft(rows, audience)


def create_official_draft(candidate_ids: list[int], audience: str) -> int:
    if audience not in {"general", "hardcore"}:
        raise ValueError("受众模式无效")
    ids = sorted(set(candidate_ids))
    if len(ids) < 2 or len(ids) > 5:
        raise ValueError("请选择 2–5 篇候选文章")
    placeholders = ",".join("?" for _ in ids)
    with connect() as conn:
        rows = conn.execute(
            f"""
            SELECT c.id AS candidate_id, a.title, a.url, a.content, a.published_at,
                   s.id AS source_id, s.name AS source_name, s.tier
            FROM candidates c
            JOIN articles a ON a.id = c.article_id
            JOIN sources s ON s.id = a.source_id
            WHERE c.id IN ({placeholders})
            ORDER BY c.id
            """,
            ids,
        ).fetchall()
    if len(rows) != len(ids):
        raise ValueError("部分候选文章不存在")
    if len({row["source_id"] for row in rows}) < 2:
        raise ValueError("公众号专题至少需要两个不同来源")
    sources = [
        {
            "source": row["source_name"],
            "title": row["title"],
            "url": row["url"],
            "published_at": row["published_at"] or "",
        }
        for row in rows
    ]
    content = generate_draft_content(rows, audience)
    html = render_draft_html(content["title"], content["summary"], content["body"], sources)
    timestamp = now_iso()
    with connect() as conn:
        cursor = conn.execute(
            """
            INSERT INTO drafts(
                target, audience, title, summary, body_markdown, html,
                sources_json, created_at, updated_at
            ) VALUES ('official_account', ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                audience,
                content["title"],
                content["summary"],
                content["body"],
                html,
                json.dumps(sources, ensure_ascii=False),
                timestamp,
                timestamp,
            ),
        )
        return int(cursor.lastrowid)


def article_exists(url: str) -> bool:
    with connect() as conn:
        row = conn.execute("SELECT 1 FROM articles WHERE url = ?", (normalize_url(url),)).fetchone()
    return row is not None


def store_candidate(source: sqlite3.Row, item: dict[str, str], content: str) -> bool:
    url = normalize_url(item["url"])
    title = item["title"].strip()[:500]
    fingerprint = hashlib.sha256(f"{url}\n{title.lower()}".encode("utf-8")).hexdigest()
    score = score_article(title, content, source["name"], source["tier"])
    if max(int(score["general_score"]), int(score["hardcore_score"])) < 45:
        return False
    with connect() as conn:
        cursor = conn.execute(
            """
            INSERT OR IGNORE INTO articles(
                source_id, url, title, content, summary, published_at, fingerprint, created_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                source["id"],
                url,
                title,
                content,
                item.get("summary", "")[:2000],
                item.get("published_at", "")[:200],
                fingerprint,
                now_iso(),
            ),
        )
        if not cursor.rowcount:
            return False
        article_id = cursor.lastrowid
        conn.execute(
            """
            INSERT INTO candidates(
                article_id, general_score, hardcore_score, reason,
                general_copy, hardcore_copy, created_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?)
            """,
            (
                article_id,
                score["general_score"],
                score["hardcore_score"],
                score["reason"],
                score["general_copy"],
                score["hardcore_copy"],
                now_iso(),
            ),
        )
    return True


def scan_source(source: sqlite3.Row, max_items: int) -> dict[str, object]:
    added = 0
    error = ""
    item_failures: list[str] = []
    try:
        index = fetch_text(source["url"])
        items = parse_rss(index, source["url"]) if source["kind"] == "rss" else parse_html_index(index, source["url"])
        for item in items[:max_items]:
            item["url"] = validate_public_url(item["url"], resolve=False)
            if article_exists(item["url"]):
                continue
            try:
                article_html = fetch_text(item["url"])
                extracted_title, content = extract_article(article_html, item["title"])
                item["title"] = extracted_title
            except (httpx.HTTPError, OSError, ValueError) as exc:
                content = item.get("summary", "")
                item_failures.append(f"{type(exc).__name__}: {item['url']}")
                if not content:
                    continue
            if store_candidate(source, item, content or item.get("summary", "")):
                added += 1
    except (ET.ParseError, httpx.HTTPError, OSError, ValueError) as exc:
        error = f"{type(exc).__name__}: {exc}"[:1000]
    if not error and item_failures:
        error = f"部分正文不可抓取，已使用摘要或跳过：{len(item_failures)} 条。{item_failures[0]}"[:1000]
    with connect() as conn:
        conn.execute(
            "UPDATE sources SET last_scan_at = ?, last_error = ? WHERE id = ?",
            (now_iso(), error, source["id"]),
        )
    return {"source": source["name"], "added": added, "error": error}


def scan_all(max_items: int = 3) -> list[dict[str, object]]:
    init_db()
    with connect() as conn:
        sources = conn.execute(
            "SELECT * FROM sources WHERE enabled = 1 AND kind != 'manual' ORDER BY tier, id"
        ).fetchall()
    return [scan_source(source, max_items) for source in sources]


TOAST_SCRIPT = r"""
[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null
[Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null
[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType=WindowsRuntime] > $null
$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
$title = [Security.SecurityElement]::Escape($env:WECHAT_AUTO_SHARE_TOAST_TITLE)
$message = [Security.SecurityElement]::Escape($env:WECHAT_AUTO_SHARE_TOAST_MESSAGE)
$xml.LoadXml("<toast><visual><binding template='ToastGeneric'><text>$title</text><text>$message</text></binding></visual></toast>")
$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Microsoft.Windows.PowerShell').Show($toast)
"""


def notify_windows(title: str, message: str) -> bool:
    if os.name != "nt":
        return False
    env = os.environ.copy()
    env["WECHAT_AUTO_SHARE_TOAST_TITLE"] = title[:100]
    env["WECHAT_AUTO_SHARE_TOAST_MESSAGE"] = message[:500]
    flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
    try:
        result = subprocess.run(
            ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", TOAST_SCRIPT],
            env=env,
            capture_output=True,
            timeout=10,
            creationflags=flags,
            check=False,
        )
        return result.returncode == 0
    except (OSError, subprocess.TimeoutExpired):
        return False


def maybe_notify(added: int) -> bool:
    if added <= 0:
        return False
    local_now = datetime.now()
    if local_now.hour >= 22 or local_now.hour < 8:
        return False
    today = local_now.date().isoformat()
    if get_setting("notification_date") != today:
        set_setting("notification_date", today)
        set_setting("notification_count", "0")
    count = int(get_setting("notification_count", "0"))
    if count >= 2:
        return False
    sent = notify_windows("AI 内容分发助手", f"发现 {added} 篇新的候选文章，点击本地管理页查看。")
    if sent:
        set_setting("notification_count", str(count + 1))
    return sent


def scheduled_action() -> str:
    if getattr(sys, "frozen", False):
        return f'"{sys.executable}" scan --max-items 3'
    return f'"{sys.executable}" "{Path(__file__).resolve()}" scan --max-items 3'


def install_schedule() -> None:
    action = scheduled_action()
    flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
    for suffix, time in (("Morning", "09:00"), ("Evening", "18:00")):
        result = subprocess.run(
            [
                "schtasks.exe",
                "/Create",
                "/TN",
                f"WechatAutoShare-{suffix}",
                "/TR",
                action,
                "/SC",
                "DAILY",
                "/ST",
                time,
                "/F",
            ],
            capture_output=True,
            text=True,
            creationflags=flags,
            check=False,
        )
        if result.returncode:
            raise RuntimeError(result.stderr.strip() or result.stdout.strip())


def remove_schedule() -> None:
    flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
    for suffix in ("Morning", "Evening"):
        subprocess.run(
            ["schtasks.exe", "/Delete", "/TN", f"WechatAutoShare-{suffix}", "/F"],
            capture_output=True,
            creationflags=flags,
            check=False,
        )


def add_manual_url(url: str) -> bool:
    safe_url = validate_public_url(url)
    if article_exists(safe_url):
        return False
    html_text = fetch_text(safe_url)
    title, content = extract_article(html_text)
    if not title or len(content) < 100:
        raise ValueError("未能从页面提取足够的标题和正文")
    with connect() as conn:
        source = conn.execute("SELECT * FROM sources WHERE kind = 'manual'").fetchone()
    return store_candidate(source, {"title": title, "url": safe_url}, content)


PAGE = """
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <title>AI 内容分发助手</title>
  <style>
    :root { color-scheme: light; font-family: system-ui, sans-serif; background:#f5f7fb; color:#172033; }
    body { max-width:960px; margin:0 auto; padding:32px 20px 80px; }
    header, .toolbar { display:flex; gap:12px; align-items:center; justify-content:space-between; flex-wrap:wrap; }
    h1 { margin:0; font-size:28px; } h2 { margin:0 0 8px; font-size:20px; }
    .muted { color:#667085; } .notice { padding:12px 16px; background:#eaf3ff; border-radius:10px; margin:18px 0; }
    form { display:flex; gap:8px; flex-wrap:wrap; } input[type=url] { min-width:320px; flex:1; }
    input, button { padding:10px 12px; border-radius:8px; border:1px solid #cfd6e4; font:inherit; }
    button { background:#1d66d1; color:white; border:0; cursor:pointer; }
    .grid { display:grid; gap:14px; margin-top:22px; }
    article { background:white; border:1px solid #e1e6ef; border-radius:12px; padding:18px; box-shadow:0 2px 8px #14213d0a; }
    .scores { display:flex; gap:10px; margin:10px 0; }
    .score { background:#eef3fb; border-radius:999px; padding:5px 10px; font-size:14px; }
    .share { display:grid; grid-template-columns:1fr auto; gap:8px; align-items:start; margin-top:12px; }
    textarea { width:100%; min-height:82px; padding:10px; box-sizing:border-box; border:1px solid #cfd6e4; border-radius:8px; resize:vertical; }
    .qr { width:112px; height:112px; border:1px solid #e1e6ef; border-radius:8px; }
    .actions { display:flex; gap:8px; margin-top:12px; }
    .settings, details { background:white; border:1px solid #e1e6ef; border-radius:12px; padding:14px; margin-top:18px; }
    details form { margin-top:12px; } details input[type=text] { flex:1; min-width:180px; }
    .picker { display:grid; gap:6px; width:100%; margin:10px 0; }
    .picker label { display:block; }
    .confirm { width:100%; color:#9a3412; }
    .secondary { background:#667085; }
    a { color:#175bb6; text-decoration:none; } a:hover { text-decoration:underline; }
  </style>
</head>
<body>
  <header><div><h1>AI 内容分发助手</h1><div class="muted">个人朋友圈辅助 + 企业微信确认发布</div></div>
    <div class="actions">
      <form method="post" action="{{ url_for('scan_route') }}">
        <input type="hidden" name="csrf" value="{{ csrf }}"><button>立即扫描</button>
      </form>
      <form method="post" action="{{ url_for('quit_route') }}">
        <input type="hidden" name="csrf" value="{{ csrf }}"><button class="secondary">退出程序</button>
      </form>
    </div>
  </header>
  {% if message %}<div class="notice">{{ message }}</div>{% endif %}
  <section class="settings">
    <strong>AI：{{ '已配置' if ai_configured else '未配置（将使用本地初筛和编辑提纲）' }}</strong>
    <form method="post" action="{{ url_for('ai_config_route') }}">
      <input type="hidden" name="csrf" value="{{ csrf }}">
      <input type="url" name="base_url" value="{{ ai_base_url }}" required placeholder="兼容 OpenAI 的 API 地址">
      <input type="text" name="model" value="{{ ai_model }}" required placeholder="模型名称">
      <input type="password" name="api_key" required autocomplete="new-password" placeholder="API Key">
      <button>保存 AI 配置</button>
    </form>
    <div class="muted">首次使用：先保存 AI 配置，再立即扫描；也可暂不配置并使用本地规则。</div>
  </section>
  <section class="settings">
    <strong>自动扫描</strong>
    <form method="post" action="{{ url_for('schedule_route') }}">
      <input type="hidden" name="csrf" value="{{ csrf }}">
      <button name="action" value="install">启用每天 09:00、18:00 扫描</button>
      <button class="secondary" name="action" value="remove">停用自动扫描</button>
    </form>
    <div class="muted">只有点击启用后才会修改 Windows 任务计划。</div>
  </section>
  <section class="settings">
    <strong>企业微信：{{ '已配置' if wecom_configured else '未配置' }}</strong>
    <form method="post" action="{{ url_for('wecom_config_route') }}">
      <input type="hidden" name="csrf" value="{{ csrf }}">
      <input type="text" name="corp_id" value="{{ wecom_corp_id }}" required placeholder="企业 CorpID">
      <input type="password" name="secret" required autocomplete="new-password" placeholder="客户联系 Secret">
      <button>保存凭据</button>
    </form>
    {% if wecom_configured %}
      <form method="post" action="{{ url_for('wecom_test_route') }}">
        <input type="hidden" name="csrf" value="{{ csrf }}"><button class="secondary">测试连接</button>
      </form>
    {% endif %}
    <div class="muted">Secret 仅存入 Windows 凭据系统；建议使用“客户联系”Secret，或具有对应权限的自建应用 Secret。</div>
  </section>
  <section class="toolbar">
    <form method="post" action="{{ url_for('add_url_route') }}">
      <input type="hidden" name="csrf" value="{{ csrf }}">
      <input type="url" name="url" required placeholder="粘贴文章链接（含公众号文章）">
      <button>添加链接</button>
    </form>
    <div class="muted">{{ rows|length }} 条候选</div>
  </section>
  <section class="settings">
    <strong>生成公众号专题稿</strong>
    <form method="post" action="{{ url_for('official_generate_route') }}">
      <input type="hidden" name="csrf" value="{{ csrf }}">
      <div class="picker">
        {% for row in rows %}
          <label><input type="checkbox" name="candidate_ids" value="{{ row.id }}"> {{ row.source_name }}：{{ row.title }}</label>
        {% endfor %}
      </div>
      <button name="audience" value="general">生成通俗版</button>
      <button name="audience" value="hardcore">生成硬核版</button>
    </form>
    <div class="muted">请选择 2–5 篇、至少两个不同来源。未配置 AI 时仅生成编辑提纲。</div>
    {% if drafts %}
      <div>最近草稿：{% for draft in drafts %}<a href="{{ url_for('draft_view', draft_id=draft.id) }}">{{ draft.title }}</a>{% if not loop.last %} · {% endif %}{% endfor %}</div>
    {% endif %}
  </section>
  <main class="grid">
    {% for row in rows %}
      <article>
        <h2><a href="{{ row.url }}" target="_blank" rel="noopener noreferrer">{{ row.title }}</a></h2>
        <div class="muted">{{ row.source_name }} · {{ row.created_at }}</div>
        <div class="scores"><span class="score">通俗 {{ row.general_score }}</span><span class="score">硬核 {{ row.hardcore_score }}</span></div>
        <div>{{ row.reason }}</div>
        <div class="share">
          <div>
            <textarea id="general-{{ row.id }}" readonly>{{ row.general_copy }}&#10;&#10;{{ row.url }}</textarea>
            <button type="button" onclick="copyText('general-{{ row.id }}', this)">复制通俗版</button>
          </div>
          <img class="qr" src="{{ url_for('candidate_qr', candidate_id=row.id) }}" alt="原文二维码">
        </div>
        <div class="share">
          <div>
            <textarea id="hardcore-{{ row.id }}" readonly>{{ row.hardcore_copy }}&#10;&#10;{{ row.url }}</textarea>
            <button type="button" onclick="copyText('hardcore-{{ row.id }}', this)">复制硬核版</button>
          </div>
        </div>
        <details>
          <summary>发布到企业微信客户朋友圈{% if row.wecom_status %} · 最近状态：{{ row.wecom_status }}{% endif %}</summary>
          <form method="post" action="{{ url_for('wecom_submit_route', candidate_id=row.id) }}">
            <input type="hidden" name="csrf" value="{{ csrf }}">
            <input type="text" name="user_list" placeholder="执行成员 userid，逗号分隔">
            <input type="text" name="department_list" placeholder="执行部门 ID，逗号分隔">
            <input type="text" name="tag_list" placeholder="客户标签 ID，可不填">
            <label class="confirm"><input type="checkbox" name="confirm" value="yes" required> 我确认创建企业微信发表任务；成员仍需在企业微信中确认发表。</label>
            <button name="audience" value="general">确认提交通俗版</button>
            <button name="audience" value="hardcore">确认提交硬核版</button>
          </form>
        </details>
        <form class="actions" method="post" action="{{ url_for('candidate_status', candidate_id=row.id) }}">
          <input type="hidden" name="csrf" value="{{ csrf }}">
          <button name="status" value="published">标记已发布</button>
          <button class="secondary" name="status" value="ignored">忽略</button>
        </form>
      </article>
    {% else %}
      <article>还没有候选。点击“立即扫描”或提交一条文章链接。</article>
    {% endfor %}
  </main>
  <script>
    async function copyText(id, button) {
      const field = document.getElementById(id);
      try {
        await navigator.clipboard.writeText(field.value);
      } catch (_) {
        field.select(); document.execCommand('copy');
      }
      const old = button.textContent; button.textContent = '已复制';
      setTimeout(() => button.textContent = old, 1200);
    }
  </script>
</body>
</html>
"""

DRAFT_PAGE = """
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
  <title>{{ draft.title }}</title>
  <style>
    body { max-width:900px; margin:0 auto; padding:28px 18px 70px; color:#172033; font:16px/1.75 system-ui,sans-serif; }
    nav { display:flex; gap:12px; flex-wrap:wrap; margin-bottom:22px; }
    nav a, button { padding:9px 12px; border:0; border-radius:8px; background:#1d66d1; color:white; text-decoration:none; font:inherit; }
    .editor { display:grid; gap:10px; padding:18px; background:#f5f7fb; border-radius:12px; margin-bottom:24px; }
    input, textarea { width:100%; box-sizing:border-box; padding:10px; border:1px solid #cfd6e4; border-radius:8px; font:inherit; }
    textarea { min-height:360px; }
    article { border-top:1px solid #e1e6ef; padding-top:20px; } .summary { color:#667085; font-size:18px; }
    article img { max-width:100%; } article a { color:#175bb6; }
  </style>
</head>
<body>
  <nav>
    <a href="{{ url_for('index') }}">返回候选</a>
    <a href="{{ url_for('draft_export', draft_id=draft.id, kind='md') }}">下载 Markdown</a>
    <a href="{{ url_for('draft_export', draft_id=draft.id, kind='html') }}">下载 HTML</a>
    <a href="{{ url_for('draft_cover', draft_id=draft.id) }}">下载封面占位图</a>
  </nav>
  {% if message %}<p>{{ message }}</p>{% endif %}
  <form class="editor" method="post" action="{{ url_for('draft_update', draft_id=draft.id) }}">
    <input type="hidden" name="csrf" value="{{ csrf }}">
    <label>标题<input name="title" value="{{ draft.title }}" required maxlength="200"></label>
    <label>摘要<textarea name="summary" required style="min-height:90px">{{ draft.summary }}</textarea></label>
    <label>正文 Markdown<textarea name="body" required>{{ draft.body_markdown }}</textarea></label>
    <button>保存修改并刷新预览</button>
  </form>
  <h2>公众号排版预览</h2>
  {{ draft.html|safe }}
</body>
</html>
"""


def create_web_app() -> Flask:
    init_db()
    web_app = Flask(__name__)

    def require_csrf() -> None:
        if not secrets.compare_digest(request.form.get("csrf", ""), get_setting("csrf_token")):
            abort(403)

    @web_app.get("/")
    def index():
        with connect() as conn:
            rows = conn.execute(
                """
                SELECT c.*, a.title, a.url, s.name AS source_name,
                       (SELECT status FROM delivery_jobs d
                        WHERE d.candidate_id = c.id AND d.target = 'wecom_moment'
                        ORDER BY d.id DESC LIMIT 1) AS wecom_status
                FROM candidates c
                JOIN articles a ON a.id = c.article_id
                JOIN sources s ON s.id = a.source_id
                WHERE c.status = 'pending'
                ORDER BY c.created_at DESC
                LIMIT 100
                """
            ).fetchall()
            drafts = conn.execute(
                "SELECT id, title FROM drafts WHERE target = 'official_account' ORDER BY id DESC LIMIT 5"
            ).fetchall()
        return render_template_string(
            PAGE,
            rows=rows,
            drafts=drafts,
            csrf=get_setting("csrf_token"),
            message=request.args.get("message", ""),
            ai_base_url=get_setting("ai_base_url"),
            ai_model=get_setting("ai_model"),
            ai_configured=bool(
                get_setting("ai_base_url")
                and get_setting("ai_model")
                and keyring.get_password(KEYRING_SERVICE, "ai-api-key")
            ),
            wecom_corp_id=get_setting("wecom_corp_id"),
            wecom_configured=bool(
                get_setting("wecom_corp_id")
                and keyring.get_password(KEYRING_SERVICE, "wecom-secret")
            ),
        )

    @web_app.post("/scan")
    def scan_route():
        require_csrf()
        results = scan_all(max_items=2)
        added = sum(int(result["added"]) for result in results)
        failed = sum(bool(result["error"]) for result in results)
        maybe_notify(added)
        return redirect(url_for("index", message=f"扫描完成：新增 {added} 条，失败来源 {failed} 个。"))

    @web_app.post("/add-url")
    def add_url_route():
        require_csrf()
        try:
            added = add_manual_url(request.form.get("url", ""))
            message = "已加入候选。" if added else "该文章已存在，或未达到候选阈值。"
        except (httpx.HTTPError, OSError, ValueError) as exc:
            message = f"添加失败：{exc}"
        return redirect(url_for("index", message=message))

    @web_app.post("/ai/config")
    def ai_config_route():
        require_csrf()
        try:
            set_ai_credentials(
                request.form.get("base_url", ""),
                request.form.get("model", ""),
                request.form.get("api_key", ""),
            )
            message = "AI 配置已保存到本机。"
        except (OSError, ValueError, keyring.errors.KeyringError) as exc:
            message = f"AI 配置失败：{safe_error_text(exc)}"
        return redirect(url_for("index", message=message))

    @web_app.post("/quit")
    def quit_route():
        require_csrf()
        threading.Timer(0.2, lambda: os._exit(0)).start()
        return "<!doctype html><meta charset=utf-8><title>已退出</title><p>程序已退出，可以关闭此页面。</p>"

    @web_app.post("/schedule")
    def schedule_route():
        require_csrf()
        action = request.form.get("action")
        try:
            if action == "install":
                install_schedule()
                message = "已启用每天 09:00、18:00 的自动扫描。"
            elif action == "remove":
                remove_schedule()
                message = "已停用自动扫描。"
            else:
                abort(400)
        except RuntimeError as exc:
            message = f"修改自动扫描失败：{safe_error_text(exc)}"
        return redirect(url_for("index", message=message))

    @web_app.post("/wecom/config")
    def wecom_config_route():
        require_csrf()
        try:
            set_wecom_credentials(request.form.get("corp_id", ""), request.form.get("secret", ""))
            message = "企业微信凭据已保存到本机。"
        except (ValueError, keyring.errors.KeyringError) as exc:
            message = f"企业微信配置失败：{safe_error_text(exc)}"
        return redirect(url_for("index", message=message))

    @web_app.post("/wecom/test")
    def wecom_test_route():
        require_csrf()
        try:
            wecom_access_token()
            message = "企业微信连接成功，凭据可用；朋友圈权限会在创建任务时验证。"
        except (httpx.HTTPError, ValueError, RuntimeError, keyring.errors.KeyringError) as exc:
            message = f"企业微信连接失败：{safe_error_text(exc)}"
        return redirect(url_for("index", message=message))

    @web_app.post("/candidate/<int:candidate_id>/wecom")
    def wecom_submit_route(candidate_id: int):
        require_csrf()
        if request.form.get("confirm") != "yes":
            abort(400)
        try:
            result = submit_wecom_moment(
                candidate_id,
                request.form.get("audience", ""),
                request.form.get("user_list", ""),
                request.form.get("department_list", ""),
                request.form.get("tag_list", ""),
            )
            if result["duplicate"]:
                message = f"该范围的任务已提交过，没有重复创建。JobID：{result['jobid'] or '处理中'}"
            else:
                message = f"企业微信发表任务已创建。JobID：{result['jobid']}"
        except (httpx.HTTPError, ValueError, RuntimeError, keyring.errors.KeyringError) as exc:
            message = f"企业微信提交失败，未自动重试：{safe_error_text(exc)}"
        return redirect(url_for("index", message=message))

    @web_app.post("/official-account/generate")
    def official_generate_route():
        require_csrf()
        try:
            candidate_ids = [int(value) for value in request.form.getlist("candidate_ids")]
            draft_id = create_official_draft(candidate_ids, request.form.get("audience", ""))
            return redirect(url_for("draft_view", draft_id=draft_id))
        except ValueError as exc:
            return redirect(url_for("index", message=f"公众号草稿生成失败：{safe_error_text(exc)}"))

    @web_app.get("/draft/<int:draft_id>")
    def draft_view(draft_id: int):
        with connect() as conn:
            draft = conn.execute("SELECT * FROM drafts WHERE id = ?", (draft_id,)).fetchone()
        if not draft:
            abort(404)
        return render_template_string(
            DRAFT_PAGE,
            draft=draft,
            csrf=get_setting("csrf_token"),
            message=request.args.get("message", ""),
        )

    @web_app.post("/draft/<int:draft_id>")
    def draft_update(draft_id: int):
        require_csrf()
        title = request.form.get("title", "").strip()[:200]
        summary = request.form.get("summary", "").strip()[:500]
        body = request.form.get("body", "").strip()[:50_000]
        if not title or not summary or not body:
            abort(400)
        with connect() as conn:
            draft = conn.execute("SELECT sources_json FROM drafts WHERE id = ?", (draft_id,)).fetchone()
            if not draft:
                abort(404)
            sources = json.loads(draft["sources_json"])
            html = render_draft_html(title, summary, body, sources)
            conn.execute(
                "UPDATE drafts SET title = ?, summary = ?, body_markdown = ?, html = ?, updated_at = ? WHERE id = ?",
                (title, summary, body, html, now_iso(), draft_id),
            )
        return redirect(url_for("draft_view", draft_id=draft_id, message="草稿已保存。"))

    @web_app.get("/draft/<int:draft_id>/export/<kind>")
    def draft_export(draft_id: int, kind: str):
        if kind not in {"md", "html"}:
            abort(404)
        with connect() as conn:
            draft = conn.execute("SELECT * FROM drafts WHERE id = ?", (draft_id,)).fetchone()
        if not draft:
            abort(404)
        if kind == "md":
            content = draft_markdown(draft)
            mimetype = "text/markdown"
        else:
            content = (
                "<!doctype html><html lang=\"zh-CN\"><head><meta charset=\"utf-8\">"
                "<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">"
                "<style>body{max-width:760px;margin:auto;padding:24px;font:16px/1.8 sans-serif}"
                ".summary{color:#667085;font-size:18px}a{color:#175bb6}</style></head><body>"
                f"{draft['html']}</body></html>"
            )
            mimetype = "text/html"
        return send_file(
            io.BytesIO(content.encode("utf-8")),
            mimetype=mimetype,
            as_attachment=True,
            download_name=f"wechat-draft-{draft_id}.{kind}",
        )

    @web_app.get("/draft/<int:draft_id>/cover.svg")
    def draft_cover(draft_id: int):
        with connect() as conn:
            draft = conn.execute("SELECT title, audience FROM drafts WHERE id = ?", (draft_id,)).fetchone()
        if not draft:
            abort(404)
        title = draft["title"]
        lines = [title[:18], title[18:36]] if len(title) > 18 else [title]
        text_nodes = "".join(
            f'<text x="64" y="{170 + index * 70}" font-size="48" font-weight="700" fill="white">{escape(line)}</text>'
            for index, line in enumerate(lines)
        )
        svg = (
            '<svg xmlns="http://www.w3.org/2000/svg" width="900" height="383" viewBox="0 0 900 383">'
            '<rect width="900" height="383" fill="#173f7a"/><circle cx="790" cy="70" r="150" fill="#2f6fce"/>'
            '<text x="64" y="86" font-size="24" fill="#bcd5ff">AI 内容专题</text>'
            f'{text_nodes}<text x="64" y="340" font-size="22" fill="#bcd5ff">'
            f'{"通俗版" if draft["audience"] == "general" else "硬核版"}</text></svg>'
        )
        return send_file(
            io.BytesIO(svg.encode("utf-8")),
            mimetype="image/svg+xml",
            as_attachment=True,
            download_name=f"wechat-draft-{draft_id}-cover.svg",
        )

    @web_app.get("/candidate/<int:candidate_id>/qr.png")
    def candidate_qr(candidate_id: int):
        with connect() as conn:
            row = conn.execute(
                "SELECT a.url FROM candidates c JOIN articles a ON a.id = c.article_id WHERE c.id = ?",
                (candidate_id,),
            ).fetchone()
        if not row:
            abort(404)
        image = qrcode.make(row["url"])
        buffer = io.BytesIO()
        image.save(buffer, format="PNG")
        buffer.seek(0)
        return send_file(buffer, mimetype="image/png", max_age=3600)

    @web_app.post("/candidate/<int:candidate_id>/status")
    def candidate_status(candidate_id: int):
        require_csrf()
        status = request.form.get("status", "")
        if status not in {"published", "ignored"}:
            abort(400)
        with connect() as conn:
            cursor = conn.execute("UPDATE candidates SET status = ? WHERE id = ?", (status, candidate_id))
        if not cursor.rowcount:
            abort(404)
        return redirect(url_for("index", message="候选状态已更新。"))

    return web_app


def configure_ai(base_url: str, model: str) -> None:
    api_key = getpass.getpass("API Key（输入不会显示）: ").strip()
    set_ai_credentials(base_url, model, api_key)


def local_server_running(port: int) -> bool:
    try:
        with socket.create_connection(("127.0.0.1", port), timeout=0.4):
            return True
    except OSError:
        return False


def main() -> None:
    parser = argparse.ArgumentParser(description="AI 内容分发助手 V1 单机原型")
    parser.set_defaults(command="serve", port=8765)
    subparsers = parser.add_subparsers(dest="command")
    subparsers.add_parser("init", help="初始化数据库和默认来源")
    scan_parser = subparsers.add_parser("scan", help="扫描所有启用来源")
    scan_parser.add_argument("--max-items", type=int, default=3)
    serve_parser = subparsers.add_parser("serve", help="启动本地管理页")
    serve_parser.add_argument("--port", type=int, default=8765)
    add_parser = subparsers.add_parser("add-url", help="手动加入文章 URL")
    add_parser.add_argument("url")
    ai_parser = subparsers.add_parser("set-ai", help="配置 AI API")
    ai_parser.add_argument("--base-url", required=True)
    ai_parser.add_argument("--model", required=True)
    subparsers.add_parser("install-schedule", help="注册每天 09:00 和 18:00 的 Windows 扫描任务")
    subparsers.add_parser("remove-schedule", help="删除 Windows 扫描任务")
    args = parser.parse_args()
    if args.command is None:
        args.command = "serve"
        args.port = 8765

    init_db()
    if args.command == "init":
        print(f"已初始化：{db_path()}")
    elif args.command == "scan":
        results = scan_all(max(1, min(args.max_items, 10)))
        maybe_notify(sum(int(result["added"]) for result in results))
        print(json.dumps(results, ensure_ascii=False, indent=2))
    elif args.command == "add-url":
        print("已加入候选。" if add_manual_url(args.url) else "文章已存在或未达到阈值。")
    elif args.command == "set-ai":
        configure_ai(args.base_url, args.model)
        print("AI 配置已保存到本机。")
    elif args.command == "install-schedule":
        install_schedule()
        print("已注册每天 09:00 和 18:00 的扫描任务。")
    elif args.command == "remove-schedule":
        remove_schedule()
        print("已删除扫描任务。")
    elif args.command == "serve":
        url = f"http://127.0.0.1:{args.port}/"
        if local_server_running(args.port):
            if not os.environ.get("WECHAT_AUTO_SHARE_NO_BROWSER"):
                webbrowser.open(url)
            return
        if not os.environ.get("WECHAT_AUTO_SHARE_NO_BROWSER"):
            threading.Timer(0.8, lambda: webbrowser.open(url)).start()
        create_web_app().run(host="127.0.0.1", port=args.port, debug=False)


if __name__ == "__main__":
    main()