"""报告直接引用查询快照：单元格 [[v:Q1.r0.amount]] 和整表 [[table:Q1 cols=a,b rows=0-4]]。

一期的报告只能引用口径卡的指标，查询结果只能挂在 [[see:]] 里当依据。问数据页那种
「查一下各区域销售额」的答案，数字全在查询结果里，没有口径卡可引——要么硬塞一张只做
搬运的口径卡，要么模型照抄数字、出处又断了。二期让报告直接引用快照里的那一格：

- 值一律从快照取（取回时复验哈希），按规则渲染；模型只写位置
- 行越界、列不存在、快照取不回来、被改过，都判解析不了，原因写清楚
- 整表由系统从快照生成，每一格都是带出处的片段
- 沙箱代码节点的产出不能直接引用：那种数要进口径卡
- 受管出具没声明 cells 时，复核可以把单元格引用判成解析不了
- 流式渲染和整篇渲染逐字一致
"""
from __future__ import annotations

import copy
import random

import pytest

from app.core import artifact_store
from app.engine.evidence import (
    CELLS_REASON,
    CODE_REASON,
    StreamRenderer,
    build_catalog,
    catalog_prompt,
    compose_doc,
    iter_segments,
    make_eid,
    render_markers,
    resolve_ref,
    verify_doc,
)

# --------------------------------------------------------------------------
# 夹具：一份查询快照（形状同数据源工具落的 query_snapshot），外加一张口径卡
# --------------------------------------------------------------------------

SNAP = {
    "columns": ["region", "amount", "orders", "note"],
    "rows": [
        ["华东", 18230.5, 120, "新客多"],
        ["华南", 12004.0, 98, None],
        ["华北", "9001.25", 77, "含|竖线"],   # DECIMAL 列经 JSON 落盘后是字符串
        ["西南", 0, 0, "多行\n备注"],
        ["西北", -12.5, 3, "x"],
        ["东北", 1, 1, "y"],
        ["中部", 2, 2, "z"],
    ],
    "row_count": 7, "truncated": False, "elapsed_ms": 3,
    "sql": "SELECT region, SUM(amount) AS amount, COUNT(*) AS orders, MAX(note) AS note FROM orders GROUP BY region",
    "source": "shop",
}
# 列名本身带数字：系统生成的表头不能被判成裸数字
DIGITS = {"columns": ["销售额2025", "周"], "rows": [[1.5, "2026-W37"]], "row_count": 1,
          "truncated": False, "elapsed_ms": 1, "sql": "SELECT 1", "source": "shop"}
WIDE = {"columns": [f"c{i}" for i in range(13)], "rows": [list(range(13))], "row_count": 1,
        "truncated": False, "elapsed_ms": 1, "sql": "SELECT 1", "source": "shop"}
EMPTY = {"columns": ["amount"], "rows": [], "row_count": 0, "truncated": False, "elapsed_ms": 1,
         "sql": "SELECT 1", "source": "shop"}

TOOL_SNAP = "b" * 64
GONE = "f" * 64          # 台账里有、工件库里没有的快照
CARD_ART = "c" * 64
CARD = {"kind": "metric_set", "caliber": "周报口径", "caliber_version": "v2", "artifact": CARD_ART,
        "metrics": [{"id": "gmv", "name": "销售额", "unit": "元", "value": 45678.5, "decimals": 1,
                     "format": "thousands", "status": "ok", "expression": "…"}]}


def _query(artifact: str, snap: dict, node: str = "fetch", call: str = "call_1") -> dict:
    return {"kind": "query", "node_id": node, "exec": 1, "artifact": artifact, "via": TOOL_SNAP,
            "call_id": call, "tool": "db_query__shop", "source": "shop", "columns": snap["columns"],
            "rows": len(snap["rows"]), "truncated": False}


def _store(snap: dict) -> str:
    """按 put_json 的落盘方式写进（测试用的临时）工件库：取回走真实的 load，复验哈希。"""
    text = artifact_store.canonical_json(snap)
    artifact = artifact_store.content_hash(text)
    path = artifact_store._path_of(artifact)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(text, encoding="utf-8")
    return artifact


@pytest.fixture(scope="module")
def stored() -> dict[str, str]:
    return {name: _store(snap) for name, snap in (("snap", SNAP), ("digits", DIGITS), ("wide", WIDE), ("empty", EMPTY))}


@pytest.fixture
def catalog(stored):
    ledger = [
        {"kind": "metric_set", "node_id": "caliber", "exec": 1, "artifact": CARD_ART, "caliber": "周报口径",
         "version": "v2", "metrics": ["gmv"]},
        _query(stored["snap"], SNAP),                                   # Q1
        {"kind": "retrieval", "node_id": "kb", "exec": 1, "artifact": "d" * 64, "source": "docs", "rows": 3},
        _query(GONE, SNAP, call="call_2"),                              # Q2：快照取不回来
        _query(stored["digits"], DIGITS, call="call_3"),                # Q3
        _query(stored["wide"], WIDE, call="call_4"),                    # Q4
        _query(stored["empty"], EMPTY, call="call_5"),                  # Q5
        {"kind": "node_output", "node_id": "calc", "exec": 1, "artifact": "e" * 64, "code_sha": "0" * 64,
         "role": "compute", "language": "python"},
    ]
    return build_catalog(nodes={"caliber": CARD}, ledger=ledger, inputs={"week": "2026-W37"})


def cell_eid(artifact, row, column):
    return make_eid("cell", artifact, {"row": row, "column": column})


def segs(doc, kind=None):
    return [s for s in iter_segments(doc) if kind is None or s["kind"] == kind]


def bad(doc):
    return {v["ref"]: v["message"] for v in doc["violations"] if v["code"] == "unresolved_ref"}


# --------------------------------------------------------------------------
# 单元格
# --------------------------------------------------------------------------


def test_cell_values_come_from_the_snapshot(catalog, stored):
    doc = compose_doc("[[v:Q1.r0.region]]销售额 [[v:Q1.r0.amount]]，订单 [[v:Q1.r0.orders]]。[[see:Q1]]",
                      catalog)
    assert doc["markdown"] == "华东销售额 18,230.5，订单 120。"
    assert doc["violations"] == []
    region, amount, orders = [s for s in segs(doc) if s.get("ref")]
    assert region["kind"] == "value" and amount["kind"] == "number" and orders["kind"] == "number"
    cite = amount["cite"]
    assert cite["status"] == "resolved" and cite["kind"] == "cell" and cite["role"] == "value"
    assert cite["alias"] == "Q1" and cite["ref"] == "Q1.r0.amount"
    assert cite["locator"] == {"row": 0, "column": "amount"} and cite["value"] == 18230.5
    assert cite["eid"] == cell_eid(stored["snap"], 0, "amount")
    assert amount["state"] == "deterministic" and amount["ref"] == "v:Q1.r0.amount"
    assert doc["stats"]["numbers_cited"] == 2 and doc["stats"]["values"] == 1
    assert doc["blocks"][0]["units"][0]["cites"] == ["Q1"]


@pytest.mark.parametrize("marker, shown, value", [
    ("[[v:Q1.r2.amount]]", "9,001.25", 9001.25),        # DECIMAL 字符串按数渲染
    ("[[v:Q1.r1.note]]", "—", None),                    # NULL 就是「—」，不是 0
    ("[[v:Q1.r2.note]]", "含¦竖线", "含|竖线"),           # 竖线换掉，免得把表格切出一格
    ("[[v:Q1.r3.note]]", "多行 备注", "多行\n备注"),       # 文本压成一行
    ("[[v:Q1.r3.amount]]", "0", 0),
    ("[[v:Q1.r4.amount]]", "-12.5", -12.5),
    ("[[v:Q1.r0.amount|万]]", "1.82万", 18230.5),        # 换算由渲染器完成
])
def test_cell_rendering_rules(catalog, marker, shown, value):
    doc = compose_doc(f"值 {marker}", catalog)
    assert doc["violations"] == [], doc["violations"]
    [seg] = [s for s in segs(doc) if s.get("ref")]
    assert seg["text"] == shown and seg["cite"]["value"] == value


def test_integer_decimal_text_renders_as_a_number():
    """小数位为 0 的 DECIMAL（整数列的 SUM()）落盘后是没有小数点的 "45678"：照样按数渲染、按数引用。"""
    snap = {"columns": ["gmv", "refunds", "code", "tiny"], "rows": [["45678", "29", "00123", "1E-7"]],
            "row_count": 1, "truncated": False, "elapsed_ms": 1, "sql": "SELECT 1", "source": "shop"}
    catalog = build_catalog(nodes={}, ledger=[_query(_store(snap), snap)])
    doc = compose_doc("销售额 [[v:Q1.r0.gmv]]（[[v:Q1.r0.gmv|万]]），退款 [[v:Q1.r0.refunds]] 单，"
                      "编号 [[v:Q1.r0.code]]，极小值 [[v:Q1.r0.tiny]]。", catalog)
    assert doc["violations"] == [], doc["violations"]
    assert doc["markdown"] == "销售额 45,678（4.57万），退款 29 单，编号 00123，极小值 0.0000001。"
    gmv, wan, refunds, code, tiny = [s for s in segs(doc) if s.get("ref")]
    assert gmv["kind"] == "number" and gmv["cite"]["value"] == 45678 and isinstance(gmv["cite"]["value"], int)
    assert refunds["kind"] == "number" and refunds["cite"]["value"] == 29
    assert code["kind"] == "value" and code["cite"]["value"] == "00123"      # 带前导零的是编号
    assert tiny["kind"] == "number" and tiny["cite"]["value"] == 1e-7
    assert "gmv=45,678" in catalog_prompt(catalog)


@pytest.mark.parametrize("marker, words", [
    ("[[v:Q1.r7.amount]]", "只有 7 行"),
    ("[[v:Q1.r0.gmv]]", "没有列「gmv」"),
    ("[[v:Q9.r0.amount]]", "查询结果 Q9 不存在"),
    ("[[v:K1.r0.amount]]", "不是查询结果"),
    ("[[v:Q1.amount]]", "单元格引用格式无法识别"),
    ("[[v:Q2.r0.amount]]", "无法读取"),
    ("[[v:Q1.r0.region|万]]", "不是数"),
    ("[[v:N:calc.total]]", CODE_REASON),
    ("[[v:N:fetch.total]]", "不支持引用节点字段"),
])
def test_unresolvable_cells_say_why(catalog, marker, words):
    doc = compose_doc(f"值 {marker}。", catalog)
    [(ref, message)] = bad(doc).items()
    assert ref == marker[2:-2] and words in message, message
    [seg] = [s for s in segs(doc) if s.get("ref")]
    assert seg["state"] == "none" and seg["issue"] == "unresolved_ref" and seg["text"].startswith("⟦?v:")


def test_reasons_for_people_and_rewrite_instructions_for_the_writer_are_separate(catalog):
    """解析不了的原因给人看（证据面板、出具横幅、节点报错），写法指令只交回写作者（模型）改写：
    「单元格要写成 Q<编号>.r<行>.<列>」这类话不上界面，也不存进文档。"""
    from app.engine.evidence import describe_violations

    doc = compose_doc("值 [[v:Q1.amount]]，另见 [[v:Q9.r0.amount]]。", catalog)
    by_ref = {v["ref"]: v for v in doc["violations"] if v["code"] == "unresolved_ref"}
    shape, missing = by_ref["v:Q1.amount"], by_ref["v:Q9.r0.amount"]
    assert shape["message"] == "引用 [[v:Q1.amount]] 无法解析：单元格引用格式无法识别"
    assert "Q<编号>.r<行>.<列>" in shape["for_model"] and "Q<编号>" not in shape["message"]
    assert "查询结果 Q9 不存在" in missing["message"] and "证据目录" in missing["for_model"]
    for seg in segs(doc):
        assert "for_model" not in (seg.get("cite") or {}), "文档里只存给人看的原因"
        assert "Q<编号>" not in str((seg.get("cite") or {}).get("reason") or "")
    written = describe_violations(doc["violations"])
    assert "Q<编号>.r<行>.<列>" in written and "目录里没有 Q9" in written and "单元格引用格式无法识别" not in written


def test_tampered_snapshot_is_refused(stored, tmp_path):
    """取回时复验哈希：工件文件被改过，单元格就解析不了，而不是把改过的数当真。"""
    path = artifact_store._path_of(stored["snap"])
    original = path.read_text(encoding="utf-8")
    try:
        path.write_text(original.replace("18230.5", "99999.5"), encoding="utf-8")
        catalog = build_catalog(nodes={}, ledger=[_query(stored["snap"], SNAP)])
        doc = compose_doc("值 [[v:Q1.r0.amount]]", catalog)
        assert "与哈希不一致" in bad(doc)["v:Q1.r0.amount"]
        assert "99,999.5" not in doc["markdown"]
    finally:
        path.write_text(original, encoding="utf-8")


def test_code_node_outputs_are_not_citable(catalog):
    """沙箱算出来的数不在目录里给编号，也不能按节点字段引用：要进口径卡。"""
    assert catalog["N:calc"]["kind"] == "node_output" and catalog["N:calc"]["code"] is True
    assert not any(e.get("node_id") == "calc" for a, e in catalog.items() if a.startswith("Q"))
    prompt = catalog_prompt(catalog)
    assert "N:calc" not in prompt


# --------------------------------------------------------------------------
# 整表
# --------------------------------------------------------------------------


def test_table_marker_expands_into_a_table_of_cited_cells(catalog, stored):
    doc = compose_doc("各区域如下：\n\n[[table:Q1 cols=region,amount rows=0-2]]\n\n华东最高。", catalog)
    assert doc["violations"] == [], doc["violations"]
    assert doc["markdown"] == ("各区域如下：\n\n| region | amount |\n| --- | --- |\n| 华东 | 18,230.5 |\n"
                               "| 华南 | 12,004 |\n| 华北 | 9,001.25 |\n\n华东最高。")
    assert [b["type"] for b in doc["blocks"]] == ["paragraph", "table", "paragraph"]
    table = doc["blocks"][1]
    header = [u for u in table["units"] if u["loc"]["row"] == -1]
    cells = [u for u in table["units"] if u["loc"]["row"] >= 0]
    assert len(header) == 2 and len(cells) == 6
    for unit in cells:
        [seg] = [s for s in unit["segments"] if s["kind"] != "structural"]
        row, col = unit["loc"]["row"], ["region", "amount"][unit["loc"]["col"]]
        assert seg["ref"] == f"v:Q1.r{row}.{col}" and seg["state"] == "deterministic"
        assert seg["cite"]["eid"] == cell_eid(stored["snap"], row, col)
        assert unit["cites"] == ["Q1"]
    # 模型的原文里只有那一个标记，展开是系统做的
    assert doc["source"].count("[[") == 1


def test_table_defaults_to_the_first_five_rows_and_all_columns(catalog):
    doc = compose_doc("[[table:Q1]]", catalog)
    assert doc["violations"] == []
    table = doc["blocks"][0]
    assert {u["loc"]["row"] for u in table["units"]} == {-1, 0, 1, 2, 3, 4}
    assert {u["loc"]["col"] for u in table["units"]} == {0, 1, 2, 3}


@pytest.mark.parametrize("marker, words", [
    ("[[table:Q1 rows=7-9]]", "只有 7 行，没有第 7 行"),         # 起始行就越界了
    ("[[table:Q1 rows=3-1]]", "rows"),
    ("[[table:Q1 cols=region,gmv]]", "没有列「gmv」"),
    ("[[table:Q1 limit=3]]", "无法识别的选项"),
    ("[[table:Q4]]", "超过整表上限"),
    ("[[table:Q5]]", "0 行"),
    ("[[table:Q2]]", "无法读取"),
    ("[[table:K1]]", "不是查询结果"),
])
def test_table_problems_are_violations(catalog, marker, words):
    doc = compose_doc(f"见下表：\n\n{marker}", catalog)
    [(ref, message)] = bad(doc).items()
    assert ref == marker[2:-2] and words in message, message
    assert "|" not in doc["markdown"]


def test_table_rows_past_the_end_stop_at_the_last_row(catalog):
    """结束行写过了头（只有 7 行却写 rows=5-9）：起始行在范围内，就截到最后一行，不加注、不算违规。部署上撞过：查询回的
    行比写作者以为的少，整张表报「没有第 N 行」被打回重写。"""
    doc = compose_doc("[[table:Q1 cols=region rows=5-9]]", catalog)
    assert doc["violations"] == [], doc["violations"]
    assert doc["markdown"] == "| region |\n| --- |\n| 东北 |\n| 中部 |"
    doc = compose_doc("[[table:Q1 cols=region rows=0-25]]", catalog)   # 要的比上限还多，截完只剩 7 行
    assert doc["violations"] == [], doc["violations"]
    assert {u["loc"]["row"] for u in doc["blocks"][0]["units"]} == {-1, 0, 1, 2, 3, 4, 5, 6}


def test_an_old_document_with_an_overflowing_table_still_verifies_as_it_was(catalog, monkeypatch):
    """改动前（2 版）组装的文档：结束行越界的整表当年判为解析不了、正文是占位。按文档记下的版本复核，照旧是解析不了，
    不能因为今天截得了行，就把它判成「渲染对不上」（文档被改过）。"""
    from app.engine import evidence as ev

    monkeypatch.setattr(ev, "CELL_DISPLAY", 2)
    old = compose_doc("[[table:Q1 cols=region rows=5-9]]", catalog)
    monkeypatch.undo()
    assert "没有第 9 行" in bad(old)["table:Q1 cols=region rows=5-9"] and "cell_display" not in old
    codes = [v["code"] for v in verify_doc(old, catalog)["violations"]]
    assert codes == ["unresolved_ref"], codes


def test_table_over_the_row_limit_is_still_a_violation():
    long = {"columns": ["n"], "rows": [[f"第{i}项"] for i in range(30)], "row_count": 30, "truncated": False,
            "elapsed_ms": 1, "sql": "SELECT n FROM items", "source": "shop"}
    catalog = build_catalog(nodes={}, ledger=[_query(_store(long), long)], inputs={})
    doc = compose_doc("[[table:Q1 rows=0-25]]", catalog)
    [(ref, message)] = bad(doc).items()
    assert ref == "table:Q1 rows=0-25" and "最多 20 行" in message, message


def test_table_written_inline_still_becomes_a_table(catalog):
    doc = compose_doc("见表 [[table:Q1 cols=region rows=0-1]] 如上。", catalog)
    assert doc["violations"] == []
    assert doc["markdown"] == "见表 \n| region |\n| --- |\n| 华东 |\n| 华南 |\n 如上。"
    assert [b["type"] for b in doc["blocks"]] == ["paragraph", "table", "paragraph"]


def test_generated_header_digits_are_not_bare_numbers(catalog):
    doc = compose_doc("[[table:Q3]]", catalog)
    assert doc["violations"] == [], doc["violations"]
    # 同样的字写在正文里照样要出处
    doc = compose_doc("销售额2025 是多少", catalog)
    assert [v["code"] for v in doc["violations"]] == ["uncited_number"]


# --------------------------------------------------------------------------
# 复核
# --------------------------------------------------------------------------


def test_verify_doc_rechecks_cells_independently(catalog):
    doc = compose_doc("华东 [[v:Q1.r0.amount]]。\n\n[[table:Q1 cols=amount rows=0-1]]", catalog)
    again = verify_doc(copy.deepcopy(doc), catalog)
    assert again["violations"] == doc["violations"] == [] and again["stats"] == doc["stats"]
    forged = copy.deepcopy(doc)
    seg = next(s for s in iter_segments(forged) if s.get("ref") == "v:Q1.r0.amount")
    seg["cite"]["eid"] = cell_eid("0" * 64, 0, "amount")
    assert "eid_mismatch" in [v["code"] for v in verify_doc(forged, catalog)["violations"]]


def test_cells_can_be_refused_by_the_checker(catalog):
    """受管出具没声明 cells：复核按参数把每一个单元格引用（含整表里的格）判成解析不了。"""
    doc = compose_doc("华东 [[v:Q1.r0.amount]]，指标 [[m:gmv]]。\n\n[[table:Q1 cols=amount rows=0-1]]", catalog)
    assert doc["violations"] == []
    checked = verify_doc(doc, catalog, cells_allowed=False)
    refused = [v for v in checked["violations"] if v["code"] == "unresolved_ref"]
    assert [v["ref"] for v in refused] == ["v:Q1.r0.amount", "v:Q1.r0.amount", "v:Q1.r1.amount"]
    assert all(CELLS_REASON in v["message"] for v in refused)
    assert resolve_ref("m:gmv", catalog, cells_allowed=False)["status"] == "resolved"
    # 写的时候就不许：整表标记整个解析不了，不展开
    early = compose_doc("[[table:Q1 cols=amount rows=0-1]] 和 [[v:Q1.r0.amount]]", catalog, cells_allowed=False)
    assert set(bad(early)) == {"table:Q1 cols=amount rows=0-1", "v:Q1.r0.amount"}
    assert all(CELLS_REASON in m for m in bad(early).values())


# --------------------------------------------------------------------------
# 流式 = 整篇
# --------------------------------------------------------------------------

STREAMED = [
    "各区域如下：\n\n[[table:Q1 cols=region,amount rows=0-2]]\n\n华东 [[v:Q1.r0.amount]] 最高。",
    "见表 [[table:Q1 cols=region rows=0-1]] 如上。",
    "[[table:Q1]]",
    "开头[[table:Q1 rows=0-0]]",
    "[[table:Q1 rows=0-0]]结尾",
    "[[[table:Q1 rows=0-0]]]]",
    "两张\n[[table:Q1 cols=region rows=0-1]][[table:Q3]]\n完",
    "坏的 [[table:Q1 rows=0-30]] 和 [[v:Q1.r9.amount]]，好的 [[v:Q1.r2.amount|万]]。",
    "**加粗 [[v:Q1.r0.amount]]** 与 [[m:gmv]]",
]


def _chunks(text: str, rng: random.Random) -> list[str]:
    out, i = [], 0
    while i < len(text):
        step = rng.randint(1, 7)
        out.append(text[i:i + step])
        i += step
    return out


@pytest.mark.parametrize("text", STREAMED)
def test_streaming_equals_full_rendering(catalog, text):
    full = render_markers(text, catalog)
    rng = random.Random(len(text))
    for _ in range(60):
        renderer = StreamRenderer(catalog)
        streamed = "".join(renderer.feed(c) for c in _chunks(text, rng)) + renderer.flush()
        assert streamed == full
    # 一个字一个字地喂也一样
    renderer = StreamRenderer(catalog)
    assert "".join(renderer.feed(c) for c in text) + renderer.flush() == full
    # 不含粗体的，流里看到的就是最终文档的正文
    if "**" not in text:
        assert compose_doc(text, catalog)["markdown"] == full.strip()


def test_streaming_with_cells_refused_matches_full(catalog):
    text = STREAMED[0]
    full = render_markers(text, catalog, cells_allowed=False)
    renderer = StreamRenderer(catalog, cells_allowed=False)
    assert "".join(renderer.feed(c) for c in text) + renderer.flush() == full
    assert "⟦?table:Q1" in full and "⟦?v:Q1.r0.amount⟧" in full


# --------------------------------------------------------------------------
# 性质：带单元格和整表的任意原文，片段铺满正文，组装和复核一致
# --------------------------------------------------------------------------

INTEGRITY = {"segment_mismatch", "structural_text", "state_mismatch", "render_mismatch", "eid_mismatch", "bad_schema"}


def _corpus(n: int) -> list[str]:
    rng = random.Random(20260928)
    alphabet = [*"我们。！？\n- *#>|`[]:0123 .,", "[[v:Q1.r0.amount]]", "[[v:Q1.r1.note]]", "[[v:Q1.r9.x]]",
                "[[table:Q1 cols=region rows=0-1]]", "[[table:Q3]]", "[[table:Q1 rows=0-40]]", "[[m:gmv]]",
                "**", "\n\n", "| a |", "[[see:Q1]]"]
    return ["".join(rng.choice(alphabet) for _ in range(rng.randint(1, 30))) for _ in range(n)]


@pytest.mark.parametrize("raw", _corpus(250))
def test_composition_invariants_with_cells(catalog, raw):
    doc = compose_doc(raw, catalog)
    assert "".join(s["text"] for s in iter_segments(doc)) == doc["markdown"]
    again = verify_doc(copy.deepcopy(doc), catalog)
    assert again["violations"] == doc["violations"] and again["stats"] == doc["stats"]
    assert not INTEGRITY & {v["code"] for v in doc["violations"]}, doc["violations"]


# --------------------------------------------------------------------------
# 给写作者看的目录
# --------------------------------------------------------------------------


def test_catalog_prompt_shows_query_rows_and_how_to_cite(catalog):
    prompt = catalog_prompt(catalog)
    assert "Q1" in prompt and "region, amount, orders, note" in prompt
    assert "[[v:Q1.r0.amount]]" in prompt and "[[table:Q1" in prompt
    assert "r0" in prompt and "华东" in prompt and "18,230.5" in prompt
    assert "Q2" in prompt and "无法读取" in prompt
    refused = catalog_prompt(catalog, cells_allowed=False)
    assert "[[v:" not in refused and "[[see:Q1]]" in refused


def test_cell_rules_only_show_when_there_are_cells_to_cite(catalog):
    """写作规则本身还是一期那份：升级前发起的运行在升级后跑到报告节点，提示一字不差；只有口径卡的目录
    也不该教写作者去引用不存在的 Q1。单元格和整表的写法跟着目录里的查询出现。"""
    from app.engine.evidence import MARKER_RULES

    assert "[[v:" not in MARKER_RULES and "[[table:" not in MARKER_RULES and "Q1" not in MARKER_RULES
    for kinds in (("metric", "input"), ("metric", "retrieval")):
        partial = {a: e for a, e in catalog.items() if e.get("kind") in kinds}
        prompt = catalog_prompt(partial) + MARKER_RULES
        assert "[[v:" not in prompt and "[[table:" not in prompt, kinds
    full = catalog_prompt(catalog)
    assert "[[v:Q1.r0.列名]]" in full and "[[table:Q1 cols=列a,列b rows=0-4]]" in full
    refused = catalog_prompt(catalog, cells_allowed=False)
    assert "[[v:" not in refused and "[[table:" not in refused