"""环下书院的检索实习台。Python 3 标准库，数据来自本文件内的小型教学夹具。"""
import argparse
import sqlite3
from collections import defaultdict
from fractions import Fraction
from math import dist


def scoped_catalogue(reader):
    # 这里选择已经验证过的会话样本。实际服务须从认证会话解析租户和权限。
    sessions = {"tide": ("潮汐", True), "echo": ("回声", True), "closed": ("潮汐", False)}
    tenant, allowed = sessions[reader]
    catalogue = [
        ("T1", "潮汐", "潮汐渡口时刻表", 84),
        ("E1", "回声", "书库夜航交接单", 97),
        ("P0", "公共", "共同泊位须知", 62),
    ]
    db = sqlite3.connect(":memory:")
    try:
        db.execute("CREATE TABLE page (id TEXT, tenant TEXT, title TEXT, score INTEGER)")
        db.executemany("INSERT INTO page VALUES (?, ?, ?, ?)", catalogue)
        if not allowed:
            return []
        return db.execute(
            "SELECT id, title FROM page WHERE tenant IN (?, '公共') "
            "ORDER BY score DESC, id LIMIT 2", (tenant,)
        ).fetchall()
    finally:
        db.close()


def run_scope(args):
    rows = scoped_catalogue(args.reader)
    ids = [page for page, title in rows]
    assert ids == {"tide": ["T1", "P0"], "echo": ["E1", "P0"], "closed": []}[args.reader]
    print(f"reader={args.reader} visible={','.join(ids) or '∅'} passages={len(rows)}")
    for page, title in rows:
        print(f"  {page}  {title}")


def run_fusion(args):
    # 用已记录的两份召回名次隔离检验融合、预算，无需再运行向量模型。
    rankings = [["GENERAL", "INDEX", "NOTICE-17"], ["INDEX", "NOTICE-17", "GENERAL"]]
    texts = {
        "GENERAL": "远港通行通则，适用于全网渡船。",
        "INDEX": "第十七码头的票据目录，列有各期通告。",
        "NOTICE-17": "第十七码头成人船票自霜月初一起生效。",
    }
    scores = defaultdict(Fraction)
    for ranking in rankings:
        for rank, page in enumerate(ranking, start=1):
            scores[page] += Fraction(1, 60 + rank)
    fused = sorted(scores, key=lambda page: (-scores[page], page))
    candidates = fused[:args.budget]
    # 两条查询特征形成可复算的重排基线；生产可替换为学习型重排器。
    query_features = ("第十七码头", "生效")
    def matched(page):
        return sum(term in texts[page] for term in query_features)
    reranked = sorted(candidates, key=matched, reverse=True)  # 同分沿用融合序
    assert fused == ["INDEX", "GENERAL", "NOTICE-17"]
    assert reranked[0] == ("NOTICE-17" if args.budget == 3 else "INDEX")
    print("RRF=" + ",".join(fused))
    print(f"reranked={len(candidates)} first={reranked[0]} hit@1={int(reranked[0] == 'NOTICE-17')}")
    for page in candidates:
        print(f"  {page}: RRF={float(scores[page]):.6f} matched={matched(page)}/2")


def run_eval(args):
    # 盲评夹具保留人工标注的断言－来源关系。没有调用裁判模型。
    support = {"A": {"开船=07:00"}, "B": {"票价=3"}, "C": {"借期=7天"}, "X": set()}
    unknown_replies = {
        "abstain": ("abstained", "目前的票价表只覆盖本月。请在下月通告发布后再查，或联系码头售票员。"),
        "blank": ("complete", ""),
        "timeout": ("timeout", "查询超时，请稍后再试。"),
    }
    entries = [
        {"name": "渡船", "gold": {"A", "B"}, "ranking": ["A", "B"],
         "claims": [("开船=07:00", "A"), ("票价=3", "B" if args.fix_citation else "A")]},
        {"name": "借阅", "gold": {"C"}, "ranking": ["C", "X"], "claims": [("借期=7天", "C")]},
        {"name": "下月票价", "gold": set(), "ranking": ["X"], "claims": [],
         "reply": unknown_replies[args.unknown_response]},
    ]
    recalls, supported, total, abstentions, unknown = [], 0, 0, 0, 0
    for entry in entries:
        found = set(entry["ranking"][:args.top_k])
        if entry["gold"]:
            recalls.append(Fraction(len(found & entry["gold"]), len(entry["gold"])))
        else:
            unknown += 1
            status, message = entry["reply"]
            scored = status == "abstained" and bool(message.strip()) and not entry["claims"]
            abstentions += int(scored)
            print(f"  {entry['name']}: status={status} message={message or '（空白）'} "
                  f"abstention_credit={int(scored)}")
        for claim, citation in entry["claims"]:
            total += 1
            ok = citation in found and claim in support[citation]
            supported += int(ok)
            print(f"  {entry['name']}: {claim} @ {citation} → {'支持' if ok else '缺少可核证据'}")
    macro = sum(recalls) / len(recalls)
    assert macro == {1: Fraction(3, 4), 2: Fraction(1)}[args.top_k]
    assert supported == (3 if args.fix_citation and args.top_k == 2 else 2)
    assert unknown == 1
    if args.unknown_response in ("blank", "timeout"):
        assert abstentions == 0
    else:
        assert abstentions == 1
    print(f"macro_recall@{args.top_k}={float(macro):.2f} supported={supported}/{total} "
          f"unknown_abstained={abstentions}/{unknown}")


def run_release(args):
    # 二维人工向量使坐标变换可见；用精确最近邻，无外部模型或索引服务。
    v1 = {"铃谱": (1, 0), "潮时": (0, 1)}
    v2 = {"铃谱": (0, 1), "潮时": (1, 0)}
    old = {"encoder": "v1", "pages": v1}
    new = {"encoder": "v2", "pages": dict(v2)}
    probes = {"v1": v1, "v2": v2}
    if args.variant == "old-encoder":
        new["encoder"] = "v1"
    if args.variant == "missing":
        del new["pages"]["铃谱"]

    def test(release):
        hits = 0
        for gold, query in probes[release["encoder"]].items():
            winner = min(release["pages"], key=lambda page: dist(query, release["pages"][page]))
            hits += int(winner == gold)
        return hits

    active = "v1"
    previous = active
    hits = test(new)
    covered = len(old["pages"].keys() & new["pages"].keys())
    passed = covered == len(old["pages"]) and hits == len(v1)
    if passed:
        active = "v2"  # 本地用单一版本指针代表“查询编码器＋索引”的成组发布。
    print(f"candidate={args.variant} coverage={covered}/2 hit@1={hits}/2 gate={'PASS' if passed else 'HOLD'}")
    print(f"after_gate={active}")
    if args.rollback and passed:
        active = previous
        print("rollback=rehearsed")
    assert (covered, hits) == {"healthy": (2, 2), "old-encoder": (2, 0), "missing": (1, 1)}[args.variant]
    assert active == ("v2" if passed and not args.rollback else "v1")
    print(f"serving={active}")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    lab = parser.add_subparsers(dest="lab", required=True)
    scope = lab.add_parser("r1", help="验证借阅证与可见页")
    scope.add_argument("--reader", choices=("tide", "echo", "closed"), default="tide")
    scope.set_defaults(run=run_scope)
    fusion = lab.add_parser("r2", help="控制重排预算")
    fusion.add_argument("--budget", type=int, choices=(1, 2, 3), default=1)
    fusion.set_defaults(run=run_fusion)
    ev = lab.add_parser("r3", help="将召回、引用和拒答分账")
    ev.add_argument("--top-k", type=int, choices=(1, 2), default=2)
    ev.add_argument("--fix-citation", action="store_true")
    ev.add_argument("--unknown-response", choices=("abstain", "blank", "timeout"), default="abstain")
    ev.set_defaults(run=run_eval)
    release = lab.add_parser("r4", help="影子检索、成组切换与回滚")
    release.add_argument("--variant", choices=("healthy", "old-encoder", "missing"), default="healthy")
    release.add_argument("--rollback", action="store_true")
    release.set_defaults(run=run_release)
    args = parser.parse_args()
    args.run(args)


if __name__ == "__main__":
    main()
