"""seed_profiles 骨架提取脚本(Task 4 词表数据化,Step 0)。

从两个老项目确定性生成每个租户的 seed_profiles/<slug>/ 目录:
  - wall.json         墙词表/话术(boundary_filter.py + conversation.py 的
                      正则/话术常量,AST 解析源码取值,绝不 import 源模块——
                      conversation.py 的 import 链会拉起 ai_service,它
                      import 时读提示词文件,脚本会挂)
  - brand_values.json 品牌值草稿(chat.html / widget.js / chat.js 三处
                      硬编码 + .env NOTIFY_EMAIL 归一;Task 5 人工校对消费)
  - prompts/          提示词 md 逐字节拷贝(Task 6 消费)

幂等: 相同源 → 逐字节相同产出(JSON 固定键序/缩进,无时间戳)。
用法: python scripts/extract_config.py [--jc DIR] [--auto DIR] [--out ROOT]
"""
from __future__ import annotations

import argparse
import ast
import html as html_mod
import json
import re
import shutil
import sys
from bisect import bisect_right
from io import StringIO
from pathlib import Path
from tokenize import COMMENT, generate_tokens

# 本仓库引擎编译器(仅 stdlib 依赖,无源项目 import 链,import 安全——
# "绝不 import 源模块"约束针对的是老项目 app.*,非本文件所在仓库)。
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.engine.wall_schema import (TEMPLATE_PLACEHOLDERS, WallConfigError,
                                    compile_wall)

# ---- 占位符映射(函数体内联话术的插值表达式 → wall 模板占位符) ----
# 源码里的 f"{shown}" / 拼接 NO_CONTACT_WEB 等,在 wall.json 里以
# {shown} / {no_contact_web} 占位,运行期由 conversation.py .format() 回填。
PLACEHOLDER_NAMES = {
    "shown": "shown",
    "intl": "intl",
    "NO_CONTACT_WEB": "no_contact_web",
    "NO_CONTACT_APP": "no_contact_app",
    "NO_CONTACT_ALREADY": "no_contact_already",
}
PLACEHOLDER_CALLS = {"_cc_script": "cc_script"}

# 单一来源反查(审查 I-2): 引擎侧白名单 wall_schema.TEMPLATE_PLACEHOLDERS
# 是唯一权威,本脚本产出的占位符必须 ⊆ 白名单——清单漂移(此处新增映射
# 而引擎未同步)在提取期立即显性失败,而非运行期 .format() KeyError。
if not (set(PLACEHOLDER_NAMES.values()) | set(PLACEHOLDER_CALLS.values())
        <= TEMPLATE_PLACEHOLDERS):
    raise SystemExit(
        "提取失败: 占位符超出 wall_schema.TEMPLATE_PLACEHOLDERS 白名单: "
        + ", ".join(sorted((set(PLACEHOLDER_NAMES.values())
                            | set(PLACEHOLDER_CALLS.values())) - TEMPLATE_PLACEHOLDERS)))


class NotExtractable(Exception):
    """表达式超出受限求值语法(非目标常量,跳过)。"""


# --------------------------------------------------------------------------
# AST 受限求值
# --------------------------------------------------------------------------

def _flag_chars(node: ast.AST) -> str:
    """re.compile 的 flags 实参 → 标志字符串(仅支持 I/IGNORECASE)。"""
    names: set[str] = set()

    def walk(n: ast.AST) -> None:
        if isinstance(n, ast.BinOp):           # re.I | re.M 形态
            walk(n.left)
            walk(n.right)
        elif (isinstance(n, ast.Attribute)
                and isinstance(n.value, ast.Name) and n.value.id == "re"):
            names.add(n.attr)
        else:
            raise NotExtractable("不支持的 flags 形态")

    walk(node)
    chars = []
    for name in sorted(names):
        if name in ("I", "IGNORECASE"):
            chars.append("i")
        else:
            raise NotExtractable(f"不支持的 re 标志: {name}")
    return "".join(chars)


def eval_expr(node: ast.AST, constants: dict, mode: str = "bake"):
    """受限求值: Constant/隐式拼接/JoinedStr/BinOp(+)/List/Dict/Name/re.compile。

    bake 模式(模块级常量): Name 从已收集常量表解析取值(静态组合烘焙成串)。
    placeholder 模式(函数内联话术): Name/插值按 PLACEHOLDER_* 映射为占位符。
    """
    if isinstance(node, ast.Constant):
        return node.value
    if isinstance(node, ast.JoinedStr):
        out = []
        for v in node.values:
            if isinstance(v, ast.Constant):
                out.append(str(v.value))
            elif isinstance(v, ast.FormattedValue):
                fv = v.value
                if isinstance(fv, ast.Name) and fv.id in PLACEHOLDER_NAMES:
                    out.append("{" + PLACEHOLDER_NAMES[fv.id] + "}")
                else:
                    raise NotExtractable("插值非常量名")
            else:
                raise NotExtractable("JoinedStr 内未知节点")
        return "".join(out)
    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
        left = eval_expr(node.left, constants, mode)
        right = eval_expr(node.right, constants, mode)
        if not isinstance(left, str) or not isinstance(right, str):
            raise NotExtractable("非字符串 +")
        return left + right
    if isinstance(node, ast.List):
        return [eval_expr(e, constants, mode) for e in node.elts]
    if isinstance(node, ast.Dict):
        return {eval_expr(k, constants, mode): eval_expr(v, constants, mode)
                for k, v in zip(node.keys, node.values)}
    if isinstance(node, ast.Name):
        if mode == "placeholder":
            if node.id in PLACEHOLDER_NAMES:
                return "{" + PLACEHOLDER_NAMES[node.id] + "}"
            raise NotExtractable("占位符模式未知 Name: " + node.id)
        if node.id in constants:
            return constants[node.id]
        raise NotExtractable("前向引用/未知常量: " + node.id)
    if isinstance(node, ast.Call):
        if (isinstance(node.func, ast.Attribute) and node.func.attr == "compile"
                and isinstance(node.func.value, ast.Name)
                and node.func.value.id == "re"):
            if not node.args:
                raise NotExtractable("re.compile 无参")
            pattern = eval_expr(node.args[0], constants, mode)
            if not isinstance(pattern, str):
                raise NotExtractable("re.compile 非字符串 pattern")
            flags_node = None
            if len(node.args) > 1:
                flags_node = node.args[1]
            else:
                flags_node = next((kw.value for kw in node.keywords
                                   if kw.arg == "flags"), None)
            return {"pattern": pattern,
                    "flags": _flag_chars(flags_node) if flags_node is not None else ""}
        if (mode == "placeholder" and isinstance(node.func, ast.Name)
                and node.func.id in PLACEHOLDER_CALLS):
            return "{" + PLACEHOLDER_CALLS[node.func.id] + "}"
        raise NotExtractable("未知调用")
    raise NotExtractable("未支持节点: " + type(node).__name__)


def extract_module_constants(tree: ast.Module) -> dict:
    """模块顶层赋值按源序受限求值(引用仅限更早常量)。"""
    constants: dict = {}
    for node in tree.body:
        if (isinstance(node, ast.Assign) and len(node.targets) == 1
                and isinstance(node.targets[0], ast.Name)):
            try:
                constants[node.targets[0].id] = eval_expr(node.value, constants)
            except NotExtractable:
                continue   # 非墙数据形态(函数引用等),按名取用时才报错
    return constants


# --------------------------------------------------------------------------
# 函数体内联话术提取(指纹锚定: 内容取自源码,指纹只是定位器)
# --------------------------------------------------------------------------

def _iter_stmts(body: list):
    for stmt in body:
        yield stmt
        for field in ("body", "orelse", "finalbody"):
            sub = getattr(stmt, field, None)
            if isinstance(sub, list):
                yield from _iter_stmts(sub)


def extract_function_templates(tree: ast.Module, func_name: str) -> list[str]:
    """收集函数体内可求值的字符串模板(赋值/parts.append/return),按源序。

    不可求值的语句(f"{key}: {val}" 等非目标插值)自然跳过——指纹匹配
    只在可求值候选里找,找不到/多处命中都是提取错误(显性失败)。
    """
    # 目标是类方法(_build_context_reminder/_cc_confirm_note 在 Manager 类里)
    fn = next((n for n in ast.walk(tree)
               if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
               and n.name == func_name), None)
    if fn is None:
        return []
    out: list[str] = []
    for stmt in _iter_stmts(fn.body):
        value = None
        if isinstance(stmt, ast.Assign) and len(stmt.targets) == 1:
            value = stmt.value
        elif isinstance(stmt, ast.Return):
            value = stmt.value
        elif (isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call)
                and isinstance(stmt.value.func, ast.Attribute)
                and stmt.value.func.attr == "append"
                and len(stmt.value.args) == 1):
            value = stmt.value.args[0]
        if value is None:
            continue
        try:
            v = eval_expr(value, {}, mode="placeholder")
        except NotExtractable:
            continue
        if isinstance(v, str) and v:
            out.append(v)
    return out


def find_template(templates: list[str], needle: str, field: str, *,
                  contains: bool = False, required: bool = True) -> str | None:
    """指纹定位唯一模板;required=False 时允许缺失(auto 上游无该特性)。"""
    if contains:
        hits = [t for t in templates if needle in t]
    else:
        hits = [t for t in templates if t.startswith(needle)]
    if len(hits) == 1:
        return hits[0]
    if not required and not hits:
        return None
    raise SystemExit(
        f"提取失败: {field} 锚点应唯一命中,实得 {len(hits)} 处: {needle!r}")


# --------------------------------------------------------------------------
# price_patterns 行内注释保留(tokenize 关联到下一条目)
# --------------------------------------------------------------------------

def attach_price_comments(src: str, assign: ast.Assign,
                          entries: list[dict]) -> None:
    """PRICE_PATTERNS 列表内的 # 注释块挂到紧随其后的条目(comment 键)。

    防误杀断言的设计说明随 pattern 一并数据化,编辑 wall.json 的人能看见。
    边界注释有意丢弃(审查 M-2 备案): 首条目之前/末条目之后的注释没有
    可挂靠的条目(bisect 落在 0/len(entries) 之外)——首条目前的通常是
    分组标题注释,本就不属于任何单条 pattern 的设计说明,丢弃不损信息。
    """
    comments: list[tuple[int, str]] = []
    for tok in generate_tokens(StringIO(src).readline):
        if tok.type == COMMENT and assign.lineno < tok.start[0] < assign.end_lineno:
            comments.append((tok.start[0], tok.string))
    if not comments:
        return
    first_lines = [elt.lineno for elt in assign.value.elts]
    blocks: dict[int, list[str]] = {}
    for row, text in comments:
        idx = bisect_right(first_lines, row)   # 注释属于行号大于它的第一条目
        if 0 < idx < len(entries):
            blocks.setdefault(idx, []).append(text)
    for idx, lines in blocks.items():
        entries[idx]["comment"] = "\n".join(lines)


# --------------------------------------------------------------------------
# wall.json 组装
# --------------------------------------------------------------------------

def _regex_entries(specs: list[dict]) -> list:
    """re.compile 求值结果列表 → JSON 条目列表。

    无标志 → 纯字符串(pattern 与源码逐字一致);
    有标志 → {"pattern": ..., "flags": "i"}(显式承载源码的 re.I/IGNORECASE)。
    """
    return [s["pattern"] if not s["flags"]
            else {"pattern": s["pattern"], "flags": s["flags"]} for s in specs]


def _lang_pools(constants: dict, base: str, suffix: str = "") -> dict:
    """DEFLECTIONS_EN / DEFLECTIONS_EN_CONTACT 形态按在场语言收集
    (auto 无 ES 池,自然缺 es 键)。"""
    return {lang: constants[f"{base}_{lang.upper()}{suffix}"]
            for lang in ("en", "zh", "es")
            if f"{base}_{lang.upper()}{suffix}" in constants}


def build_wall(project_root: Path, slug: str) -> dict:
    bf_src = (project_root / "app" / "services" / "boundary_filter.py").read_text(encoding="utf-8")
    cv_src = (project_root / "app" / "services" / "conversation.py").read_text(encoding="utf-8")
    bf_tree = ast.parse(bf_src)
    cv_tree = ast.parse(cv_src)
    bf, cv = extract_module_constants(bf_tree), extract_module_constants(cv_tree)

    def need(table: dict, name: str):
        if name not in table:
            raise SystemExit(f"提取失败: {slug} 源码缺常量 {name}")
        return table[name]

    # price_patterns: 统一先建 dict 以便挂行内注释,无 flags 且无 comment 再瘦回字符串
    price_assign = next((n for n in bf_tree.body
                         if isinstance(n, ast.Assign)
                         and getattr(n.targets[0], "id", "") == "PRICE_PATTERNS"),
                        None)
    if price_assign is None:   # 防呆(审查 M-1): 源码重构挪走赋值节点时显性失败
        raise SystemExit(f"提取失败: {slug} 源码缺 PRICE_PATTERNS 赋值节点")
    price_entries: list[dict] = []
    for r in need(bf, "PRICE_PATTERNS"):
        e: dict = {"pattern": r["pattern"]}
        if r["flags"]:
            e["flags"] = r["flags"]
        price_entries.append(e)
    attach_price_comments(bf_src, price_assign, price_entries)
    price_entries_json = [e if (e.get("flags") or e.get("comment")) else e["pattern"]
                          for e in price_entries]

    reminders_inline = extract_function_templates(cv_tree, "_build_context_reminder")
    cc_guide = extract_function_templates(cv_tree, "_cc_confirm_note")

    def fp(needle: str, field: str, **kw) -> str | None:
        return find_template(reminders_inline, needle, f"{slug} {field}", **kw)

    return {
        "price_patterns": price_entries_json,
        "deflections": _lang_pools(bf, "DEFLECTIONS"),
        "deflections_contact": _lang_pools(bf, "DEFLECTIONS", "_CONTACT"),
        "pivots": _lang_pools(bf, "PIVOTS"),
        "pivots_contact": _lang_pools(bf, "PIVOTS", "_CONTACT"),
        "no_contact": {
            "web": need(bf, "NO_CONTACT_WEB"),
            "app": need(bf, "NO_CONTACT_APP"),
            "already": need(bf, "NO_CONTACT_ALREADY"),
        },
        "zero_number": {
            "long_number": _regex_entries([need(bf, "LONG_NUMBER_RE")])[0],
            "any_email": _regex_entries([need(bf, "ANY_EMAIL_RE")])[0],
        },
        "reask_patterns": _regex_entries(need(bf, "REASK_PATTERNS")),
        "triggers": {
            "boundary": _regex_entries([need(cv, "BOUNDARY_TRIGGER_RE")])[0],
            "budget": _regex_entries([need(cv, "BUDGET_TRIGGER_RE")])[0],
            "contact_ask": _regex_entries([need(cv, "CONTACT_ASK_TRIGGER_RE")])[0],
        },
        "reminders": {
            "boundary": {
                "budget": fp("⚠️ 职能边界提醒：客户报预算求推荐", "reminders.boundary.budget"),
                "normal": fp("⚠️ 职能边界提醒：客户正在询问价格", "reminders.boundary.normal"),
            },
            "contact_ask": {
                "app_already": fp("⚠️ 客户正在索要我方联系方式，且客户已留过",
                                  "reminders.contact_ask.app_already"),
                "app": fp("⚠️ 客户正在索要我方联系方式（最高意向信号）。当前为 App 会话",
                          "reminders.contact_ask.app"),
                "web": fp("⚠️ 客户正在索要我方联系方式（最高意向信号）。请逐字使用这句指路",
                          "reminders.contact_ask.web"),
            },
            # auto 上游无语言跟随特性 → 空键集(主流程以 jiancai 引擎标准回填)
            "language_follow": {k: v for k, v in {
                "zh": cv.get("LANG_NOTE_ZH"), "es": cv.get("LANG_NOTE_ES"),
            }.items() if v is not None},
            "lead_given": _lead_given(slug, reminders_inline),
            "cc_guide": {k: v for k, v in {
                "echo": find_template(cc_guide, "系统已按 IP 推测补全为",
                                      f"{slug} reminders.cc_guide.echo",
                                      contains=True, required=False),
                "ask": find_template(cc_guide, "且系统无法按 IP 推测补全",
                                     f"{slug} reminders.cc_guide.ask",
                                     contains=True, required=False),
            }.items() if v is not None},
            "email_light": {k: v for k, v in {
                "en": cv.get("_EMAIL_NOTE_EN"), "zh": cv.get("_EMAIL_NOTE_ZH"),
            }.items() if v is not None},
        },
        "cc_templates": {group: {lang: cv[f"_CC_{kind}_{lang.upper()}"]
                                 for lang in ("en", "zh", "es")
                                 if f"_CC_{kind}_{lang.upper()}" in cv}
                         for group, kind in (("ask", "ASK"), ("wall", "WALL"),
                                             ("note", "NOTE"), ("echo", "ECHO"))},
    }


def _lead_given(slug: str, templates: list[str]) -> dict:
    """已留资禁令四件套。jc 为两条独立 append;auto 是单条合并串(按固定
    标记"需要回应时可直接逐字使用"切分回两段,值不变)。"""
    field = f"{slug} reminders.lead_given"
    combined = find_template(templates, "⚠️ 客户已提供联系方式（",
                             f"{field}.forbidden")
    marker = "需要回应时可直接逐字使用"
    if marker in combined:
        head, tail = combined.split(marker, 1)
        forbidden, respond = head, marker + tail
    else:
        forbidden = combined
        respond = find_template(templates, marker, f"{field}.respond_script")
    return {
        "forbidden": forbidden,
        "respond_script": respond,
        "boundary_tail": find_template(
            templates, "客户已留过联系方式——边界请求直接告知", f"{field}.boundary_tail"),
        "suspect": find_template(
            templates, "⚠️ 客户疑似已提供联系方式（", f"{field}.suspect"),
    }


# --------------------------------------------------------------------------
# brand_values.json 草稿 / prompts 拷贝
# --------------------------------------------------------------------------

def build_brand_values(project_root: Path) -> dict:
    static = project_root / "static"
    chat = (static / "chat.html").read_text(encoding="utf-8")
    widget = (static / "widget.js").read_text(encoding="utf-8")
    chatjs = (static / "js" / "chat.js").read_text(encoding="utf-8")
    env: dict[str, str] = {}
    env_path = project_root / ".env"
    if env_path.exists():
        for line in env_path.read_text(encoding="utf-8").splitlines():
            if "=" in line and not line.lstrip().startswith("#"):
                k, _, v = line.partition("=")
                env[k.strip()] = v.strip()

    def find1(pattern: str, text: str) -> str | None:
        m = re.search(pattern, text)
        return m.group(1) if m else None

    def js_default(attr: str, text: str) -> str | None:
        # widget.js: getAttribute("data-x") || "…";chat.js 多一层括号: …")) || "…"
        return find1(r'data-%s"\)+\s*\|\|\s*"([^"]*)"' % attr, text)

    def leaf_values(d):
        for v in d.values():
            if isinstance(v, str):
                yield v
            elif isinstance(v, list):
                yield from (x for x in v if isinstance(x, str))
            elif isinstance(v, dict):
                yield from leaf_values(v)

    def with_conflict(field: dict) -> dict:
        vals = {v for v in leaf_values(field) if v}
        return {**field, "conflict": len(vals) > 1}

    title = {
        "chat_html_title": find1(r"<title>(.*?)</title>", chat),
        "chat_html_h1": find1(r"<h1>(.*?)</h1>", chat),
        "widget_js_default": js_default("title", widget),
    }
    whatsapp = {
        "chat_html_href": find1(r'href="(https://wa\.me/[^"]*)"', chat),
        "widget_js_default": js_default("whatsapp", widget),
        "chat_js_default": js_default("whatsapp", chatjs),
    }
    email = {
        "chat_html_href": find1(r'href="(mailto:[^"]*)"', chat),
        "widget_js_default": js_default("email", widget),
        "chat_js_default": js_default("email", chatjs),
    }
    return {
        "_doc": ("品牌值机器提取草稿(Task 5 消费): 值取自 chat.html/widget.js/"
                 "chat.js 硬编码与 .env;conflict=true 处需人工归一定稿"),
        "title": with_conflict(title),
        "whatsapp": with_conflict(whatsapp),
        "email": with_conflict(email),
        "notify_email": {"env": env.get("NOTIFY_EMAIL", "")},
        "help_description": {
            "chat_html": html_mod.unescape(
                find1(r'help-description">(.*?)</div>', chat) or ""),
        },
        "popular_topics": {
            "chat_html": [html_mod.unescape(t)
                          for t in re.findall(r'data-topic="([^"]*)"', chat)],
        },
    }


def copy_prompts(project_root: Path, out_dir: Path) -> list[str]:
    copied = []
    for md in sorted((project_root / "app" / "prompts").glob("*.md")):
        target = out_dir / "prompts" / md.name
        target.parent.mkdir(parents=True, exist_ok=True)
        shutil.copyfile(md, target)
        copied.append(md.name)
    return copied


# --------------------------------------------------------------------------
# 主流程
# --------------------------------------------------------------------------

# auto 上游不存在的引擎特性(jc 后期 Task 的引擎能力)——对应字段沿用
# jiancai 出厂(引擎标准)话术,以 _meta 显性标注,Task 5+ 校对时可见。
FALLBACK_FIELDS = ["reminders.language_follow", "reminders.cc_guide",
                   "reminders.email_light", "cc_templates"]
# 租户自有词表(auto 用自己的值整体替换 jiancai 基座)
OWN_FIELDS = ["price_patterns", "deflections", "deflections_contact", "pivots",
              "pivots_contact", "no_contact", "zero_number", "reask_patterns",
              "triggers"]
OWN_REMINDER_CATS = ["boundary", "contact_ask", "lead_given"]


def write_json(path: Path, data: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n",
                    encoding="utf-8", newline="\n")


def _self_check(wall: dict, slug: str) -> None:
    """提取自检(审查 I-4): 落盘前跑 compile_wall,把"提取静默漏项"
    (锚点漂移/结构缺失/坏 regex/非法占位符)收敛到提取期失败——带 slug
    上下文显性报错,而非留到引擎加载或客户会话运行期才炸。"""
    try:
        compile_wall(wall)
    except WallConfigError as exc:
        raise SystemExit(f"提取自检失败({slug}): {exc}") from exc


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--jc", default=r"D:\refactor\ai-kefu-jc",
                        help="jiancai 老项目根目录")
    parser.add_argument("--auto", default=r"D:\refactor\ai-kefu",
                        help="auto 老项目根目录")
    parser.add_argument("--out", default=str(Path(__file__).resolve().parents[1]),
                        help="seed_profiles 输出根目录(仓库根)")
    args = parser.parse_args()
    out_root = Path(args.out)
    jc_root, auto_root = Path(args.jc), Path(args.auto)
    for root in (jc_root, auto_root):
        if not (root / "app" / "services" / "boundary_filter.py").exists():
            raise SystemExit(f"源项目不存在或结构不符: {root}")

    # jiancai(主线,完整提取;多语言墙 = 引擎出厂默认)
    jc_wall = build_wall(jc_root, "jiancai")
    _self_check(jc_wall, "jiancai")
    jc_dir = out_root / "seed_profiles" / "jiancai"
    write_json(jc_dir / "wall.json", jc_wall)
    write_json(jc_dir / "brand_values.json", build_brand_values(jc_root))
    jc_prompts = copy_prompts(jc_root, jc_dir)

    # auto: 自有词表覆盖 jiancai 基座;引擎特性字段沿用基座(见 FALLBACK_FIELDS)
    auto_own = build_wall(auto_root, "auto")
    auto_wall = json.loads(json.dumps(jc_wall, ensure_ascii=False))
    for key in OWN_FIELDS:
        auto_wall[key] = auto_own[key]
    for cat in OWN_REMINDER_CATS:
        auto_wall["reminders"][cat] = auto_own["reminders"][cat]
    auto_wall["_meta"] = {
        "doc": ("auto 上游无语言跟随/CC 回显确认/邮箱轻补引擎特性,"
                "以下字段沿用 jiancai 出厂(引擎标准)话术"),
        "fallback_from": "jiancai",
        "fields": FALLBACK_FIELDS,
    }
    _self_check(auto_wall, "auto")
    auto_dir = out_root / "seed_profiles" / "auto"
    write_json(auto_dir / "wall.json", auto_wall)
    write_json(auto_dir / "brand_values.json", build_brand_values(auto_root))
    auto_prompts = copy_prompts(auto_root, auto_dir)

    print(f"jiancai: price {len(jc_wall['price_patterns'])} 条 / "
          f"deflections {'+'.join(sorted(jc_wall['deflections']))} / "
          f"prompts {jc_prompts}")
    print(f"auto:    price {len(auto_wall['price_patterns'])} 条 / "
          f"deflections {'+'.join(sorted(auto_wall['deflections']))} / "
          f"prompts {auto_prompts}")
    print(f"auto fallback(引擎标准)字段: {', '.join(FALLBACK_FIELDS)}")


if __name__ == "__main__":
    main()