"""端到端自检脚本（不依赖 pytest，直接 python tests/api_check.py 就能跑）。

它按"一个教务老师一天的活儿"的顺序把系统走一遍：
建班 -> 建老师/顾问 -> 录学生（含 Excel 批量）-> 录成绩（触发红线）->
登记就业（触发状态流转）-> 转班（验证冗余字段同步）-> 删就业（状态回退）->
各项统计 -> 高级筛选 -> 权限与异常分支。

用法：
    python tests/api_check.py [--base http://127.0.0.1:8000]
"""

from __future__ import annotations

import argparse
import json
import sys
import traceback
from datetime import date, timedelta
from pathlib import Path

import httpx

BASE = "http://127.0.0.1:8000"

PASS, FAIL, WARN = [], [], []


class Ctx:
    token: str | None = None
    client: httpx.Client


def call(method: str, path: str, *, expect_code: int = 0, **kw):
    """发一个请求并断言业务 code。"""
    headers = kw.pop("headers", {})
    if Ctx.token:
        headers["Authorization"] = f"Bearer {Ctx.token}"
    response = Ctx.client.request(method, path, headers=headers, **kw)
    try:
        body = response.json()
    except Exception:  # noqa: BLE001
        body = {"code": -1, "msg": response.text[:200], "data": None}
    if expect_code is not None and body.get("code") != expect_code:
        raise AssertionError(
            f"{method} {path} 期望 code={expect_code}，实际 code={body.get('code')} msg={body.get('msg')}"
        )
    return body


def step(title: str):
    """装饰器：包一层异常捕获，定义即执行。"""

    def decorator(func):
        def wrapper():
            try:
                detail = func()
                PASS.append((title, detail))
                print(f"  [PASS] {title}  {detail or ''}")
            except AssertionError as exc:
                FAIL.append((title, str(exc)))
                print(f"  [FAIL] {title}\n         {exc}")
            except Exception as exc:  # noqa: BLE001
                FAIL.append((title, f"{type(exc).__name__}: {exc}"))
                print(f"  [FAIL] {title}\n         {type(exc).__name__}: {exc}")

        wrapper()
        return func

    return decorator


# ==================================================================== 只读接口
def check_reads():
    print("\n== 第一部分：登录与只读接口 ==")

    @step("健康检查")
    def _():
        data = call("GET", "/api/health")["data"]
        return f"dialect={data['dialect']}"

    @step("未登录访问受保护接口应被拒绝")
    def _():
        token = Ctx.token
        Ctx.token = None
        body = call("GET", "/students", expect_code=None)
        Ctx.token = token
        assert body["code"] == 401, f"期望 401，实际 {body['code']}"
        return body["msg"]

    @step("错误密码登录")
    def _():
        body = call("POST", "/auth/login", expect_code=None, json={"username": "admin", "password": "wrong"})
        assert body["code"] == 401, f"期望 401，实际 {body['code']}"
        return body["msg"]

    @step("学生列表 + 分页")
    def _():
        data = call("GET", "/students?page=1&page_size=5")["data"]
        assert len(data["items"]) == 5
        assert data["pages"] >= 1
        return f"total={data['total']} pages={data['pages']}"

    @step("学生按班级编号筛选")
    def _():
        data = call("GET", "/students?class_no=JAVA202601&page_size=100")["data"]
        assert data["total"] > 0
        assert all(i["class_no"] == "JAVA202601" for i in data["items"])
        return f"{data['total']} 人"

    @step("学生按年龄区间筛选")
    def _():
        data = call("GET", "/students?age_min=20&age_max=24&page_size=100")["data"]
        assert all(20 <= i["age"] <= 24 for i in data["items"])
        return f"{data['total']} 人"

    for path, name in [
        ("/classes?page_size=100", "班级列表"),
        ("/teachers?page_size=100", "老师列表（含带班）"),
        ("/advisors?page_size=100", "顾问列表"),
        ("/scores?page_size=5", "成绩列表"),
        ("/employments?page_size=5", "就业列表"),
        ("/students/meta/options", "学生下拉选项"),
        ("/classes/meta/options", "班级下拉选项"),
        ("/scores/meta", "成绩元信息"),
        ("/employments?salary_min=15000&salary_max=8000&page_size=5", "薪资区间写反自动纠正"),
    ]:
        path_local, name_local = path, name

        @step(name_local)
        def _(p=path_local):
            body = call("GET", p)
            return f"code={body['code']}"

    @step("就业按公司模糊 + 薪资区间查询")
    def _():
        data = call("GET", "/employments?company=科技&salary_min=10000&page_size=100")["data"]
        return f"{data['total']} 条"


# ==================================================================== 写流程
def check_write_flow():
    print("\n== 第二部分：完整业务链路 ==")
    stamp = date.today().strftime("%m%d")

    ctx: dict = {}

    @step("新增顾问")
    def _():
        body = call("POST", "/advisors", json={"name": f"自检顾问{stamp}", "gender": 2, "dept": "自检部"})
        ctx["advisor_id"] = body["data"]["id"]
        return f"编号 {body['data']['advisor_no']}"

    @step("新增老师（工号自动生成 T+年份+序号）")
    def _():
        body = call("POST", "/teachers", json={"name": f"自检老师{stamp}", "gender": 1, "subject": "自检方向"})
        ctx["teacher_id"] = body["data"]["id"]
        assert body["data"]["teacher_no"].startswith("T")
        return f"工号 {body['data']['teacher_no']}"

    @step("新增班级（编号自动生成为 方向+年份+序号）")
    def _():
        body = call(
            "POST", "/classes",
            json={
                "name": f"自检班{stamp}", "direction": "SelfTest", "capacity": 30,
                "open_date": "2026-09-01", "head_teacher_id": ctx["teacher_id"],
                "advisor_id": ctx["advisor_id"], "teacher_ids": [ctx["teacher_id"]],
            },
        )
        data = body["data"]
        ctx["class_id"] = data["id"]
        assert data["teacher_ids"] == [ctx["teacher_id"]], "多对多老师没保存上"
        return f"编号 {data['class_no']}"

    @step("新增学生（学号按规则生成）")
    def _():
        body = call(
            "POST", "/students",
            json={
                "name": f"自检学生A{stamp}", "gender": "女", "birth_date": "2003-04-05",
                "native_place": "广东广州", "graduate_school": "自检学院", "major": "软件",
                "education": "大专", "enroll_date": "2026-09-01", "class_id": ctx["class_id"],
                "advisor_id": ctx["advisor_id"], "phone": "13000000001",
            },
        )
        ctx["stu_a"] = body["data"]["id"]
        ctx["stu_a_no"] = body["data"]["stu_no"]
        assert body["data"]["age"] and body["data"]["class_name"]
        return f"学号 {body['data']['stu_no']}，年龄 {body['data']['age']}，班级 {body['data']['class_name']}"

    @step("只给年龄不给生日也能建学生（birth_date_estimated=1）")
    def _():
        body = call(
            "POST", "/students",
            json={"name": f"自检学生B{stamp}", "gender": 1, "age": 21, "class_id": ctx["class_id"]},
        )
        ctx["stu_b"] = body["data"]["id"]
        assert body["data"]["birth_date_estimated"] == 1
        assert body["data"]["age"] == 21
        return f"学号 {body['data']['stu_no']}，推算生日 {body['data']['birth_date']}"

    @step("学号重复应被拒绝")
    def _():
        body = call(
            "POST", "/students", expect_code=None,
            json={"name": "重号测试", "gender": 1, "age": 20, "stu_no": ctx["stu_a_no"]},
        )
        assert body["code"] == 409, f"期望 409，实际 {body['code']} {body['msg']}"
        return body["msg"]

    @step("毕业时间早于入学时间应被拒绝")
    def _():
        body = call(
            "POST", "/students", expect_code=None,
            json={"name": "日期测试", "gender": 1, "age": 20, "enroll_date": "2026-09-01", "graduate_date": "2025-01-01"},
        )
        assert body["code"] == 400, f"期望 400，实际 {body['code']}"
        return body["msg"]

    @step("录入正常成绩")
    def _():
        body = call("POST", "/scores", json={"stu_id": ctx["stu_a"], "exam_seq": 1, "score": 88, "exam_name": "自检一考"})
        assert body["data"]["warning"] is False
        return f"均分 {body['data']['avg_score']}"

    @step("录入低分成绩应触发红线预警")
    def _():
        body = call("POST", "/scores", json={"stu_id": ctx["stu_a"], "exam_seq": 2, "score": 45, "exam_name": "自检二考"})
        data = body["data"]
        assert data["warning"] is True, "没触发预警"
        assert data["record"]["is_warning"] is True
        return data["warning_msg"]

    @step("预警会写进学生备注")
    def _():
        body = call("GET", f"/students/{ctx['stu_a']}")
        remark = body["data"]["remark"] or ""
        assert "成绩预警" in remark, f"备注里没有预警：{remark}"
        return remark[:60]

    @step("同一序次重复录入应提示改用修改")
    def _():
        body = call(
            "POST", "/scores", expect_code=None,
            json={"stu_id": ctx["stu_a"], "exam_seq": 2, "score": 70},
        )
        assert body["code"] == 409, f"期望 409，实际 {body['code']} {body['msg']}"
        return body["msg"]

    @step("修改成绩后预警标记自动撤销")
    def _():
        rows = call("GET", f"/scores?stu_id={ctx['stu_a']}&exam_seq=2")["data"]["items"]
        assert rows, "没查到第 2 次考核成绩"
        score_id = rows[0]["id"]
        body = call("PUT", f"/scores/{score_id}", json={"score": 91})
        assert body["data"]["warning"] is False, f"分数改到 91 分还在预警：{body['data']}"
        return f"均分更新为 {body['data']['avg_score']}"

    @step("批量录入同一学生多次成绩")
    def _():
        body = call(
            "POST", "/scores/batch",
            json={"stu_id": ctx["stu_b"], "scores": [
                {"stu_id": ctx["stu_b"], "exam_seq": 1, "score": 55},
                {"stu_id": ctx["stu_b"], "exam_seq": 2, "score": 92},
                {"stu_id": ctx["stu_b"], "exam_seq": 3, "score": 58},
            ]},
        )
        data = body["data"]
        assert data["count"] == 3
        assert data["warning_count"] == 2, f"应预警 2 条，实际 {data['warning_count']}"
        return body["msg"]

    @step("登记就业：只填开放时间 -> 学生状态变「进入就业」")
    def _():
        body = call(
            "POST", "/employments",
            json={"stu_id": ctx["stu_a"], "open_date": "2026-09-10", "company": "自检科技", "salary": 12000},
        )
        data = body["data"]
        assert data["status_changed"] is True, f"状态没变化：{data}"
        assert data["to_status_text"] == "进入就业", data
        ctx["emp_id"] = data["employment"]["id"]
        return body["msg"]

    @step("补填 offer 时间 -> 学生状态变「已就业」")
    def _():
        body = call(
            "PUT", f"/employments/{ctx['emp_id']}",
            json={"offer_date": "2026-09-25"},
        )
        data = body["data"]
        assert data["to_status_text"] == "已就业", data
        assert data["employment"]["duration_days"] == 15, data["employment"]["duration_days"]
        return body["msg"]

    @step("offer 时间早于开放时间应被拒绝")
    def _():
        body = call("PUT", f"/employments/{ctx['emp_id']}", expect_code=None, json={"offer_date": "2026-09-01"})
        assert body["code"] == 400, f"期望 400，实际 {body['code']} {body['msg']}"
        return body["msg"]

    @step("只填 offer 不填开放时间应被拒绝（否则就业时长算不出来）")
    def _():
        body = call(
            "POST", "/employments", expect_code=None,
            json={"stu_id": ctx["stu_b"], "offer_date": "2026-09-20", "company": "X", "salary": 9000},
        )
        assert body["code"] == 400, f"期望 400，实际 {body['code']} {body['msg']}"
        return body["msg"]

    @step("学生转班 -> 就业表冗余班级同步")
    def _():
        classes = call("GET", "/classes?page_size=100")["data"]["items"]
        other = next(c for c in classes if c["id"] != ctx["class_id"])
        call("PUT", f"/students/{ctx['stu_a']}", json={"class_id": other["id"]})
        emp = call("GET", f"/employments/student/{ctx['stu_a']}")["data"]
        assert emp["class_id"] == other["id"], f"冗余班级没同步：{emp['class_id']} != {other['id']}"
        ctx["other_class_id"] = other["id"]
        return f"已同步到「{emp['class_name']}」"

    @step("删除就业记录 -> 学生状态回退到「在读」")
    def _():
        body = call("DELETE", f"/employments/{ctx['emp_id']}")
        assert body["data"]["status_changed"] is True
        student = call("GET", f"/students/{ctx['stu_a']}")["data"]
        assert student["status"] == 1, student
        return body["msg"]

    @step("有学生的班级不能被删")
    def _():
        body = call("DELETE", f"/classes/{ctx['other_class_id']}", expect_code=None)
        assert body["code"] == 400, f"期望 400，实际 {body['code']} {body['msg']}"
        return body["msg"]

    @step("Excel 模板可下载")
    def _():
        headers = {"Authorization": f"Bearer {Ctx.token}"}
        response = Ctx.client.get("/students/import/template", headers=headers)
        assert response.status_code == 200 and len(response.content) > 1000
        ctx["template"] = response.content
        return f"{len(response.content)} 字节"

    @step("Excel 批量导入（3 行有效 + 1 行班级不存在）")
    def _():
        from io import BytesIO

        from openpyxl import Workbook

        wb = Workbook()
        ws = wb.active
        ws.append(["姓名", "性别", "出生日期", "班级编号", "顾问", "学历", "籍贯", "备注"])
        classes = call("GET", "/classes?page_size=100")["data"]["items"]
        class_no = classes[0]["class_no"]
        ws.append([f"导入甲{stamp}", "男", "2004-01-02", class_no, "", "大专", "湖南", "自检"])
        ws.append([f"导入乙{stamp}", "女", "2003-02-03", class_no, "", "本科", "湖北", "自检"])
        ws.append([f"导入丙{stamp}", "男", "2002-03-04", "", "", "大专", "江西", "自检"])
        ws.append([f"导入丁{stamp}", "男", "2002-03-04", "NOT-EXIST-999", "", "大专", "江西", ""])
        buffer = BytesIO()
        wb.save(buffer)
        result = call(
            "POST", "/students/import?dry_run=false",
            files={"file": ("import.xlsx", buffer.getvalue(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")},
        )["data"]
        assert result["success"] == 3, f"应成功 3 行，实际 {result['success']}：{result['errors']}"
        assert result["failed"] == 1, f"应失败 1 行，实际 {result['failed']}"
        ctx["imported"] = [f"导入甲{stamp}", f"导入乙{stamp}", f"导入丙{stamp}"]
        return f"成功 {result['success']}，失败 {result['failed']}，失败原因：{result['errors'][0]['reason']}"

    @step("导入的学生确实入库了")
    def _():
        data = call("GET", f"/students?keyword=导入&page_size=100")["data"]
        assert data["total"] >= 3, f"只查到 {data['total']} 个"
        return f"{data['total']} 人"

    @step("逻辑删除学生")
    def _():
        call("DELETE", f"/students/{ctx['stu_b']}")
        body = call("GET", f"/students/{ctx['stu_b']}", expect_code=None)
        assert body["code"] == 404, f"删除后还能查到：{body}"
        return body["msg"]

    @step("恢复被删除的学生")
    def _():
        call("POST", f"/students/{ctx['stu_b']}/restore")
        body = call("GET", f"/students/{ctx['stu_b']}")
        return f"已恢复 {body['data']['name']}"

    return ctx


# ==================================================================== 统计与筛选
def check_statistics(ctx: dict):
    print("\n== 第三部分：统计分析与高级筛选 ==")

    checks = [
        ("2.6.1 动态年龄查询 gte", "/statistics/students/by-age?operator=gte&value=24&page_size=100"),
        ("2.6.1 动态年龄查询 between", "/statistics/students/by-age?operator=between&value=20&value2=24&page_size=100"),
        ("2.6.1 班级人数与性别分布", "/statistics/classes/overview"),
        ("2.6.1 年龄分布", "/statistics/students/age-distribution"),
        ("2.6.2 每考都在 80 分以上", "/statistics/scores/all-above?threshold=80"),
        ("2.6.2 不及格 2 次以上", "/statistics/scores/failures?threshold=60&min_times=2"),
        ("2.6.2 各班各场平均分（降序）", "/statistics/scores/class-average?order=desc"),
        ("2.6.2 各班各场平均分（升序）", "/statistics/scores/class-average?order=asc&exam_seq=1"),
        ("2.6.3 薪资 Top 5", "/statistics/employment/top-salary?top_n=5"),
        ("2.6.3 每人就业时长", "/statistics/employment/durations"),
        ("2.6.3 各班平均就业时长", "/statistics/employment/class-avg-duration"),
        ("2.7.2 成绩波动 Top 5（标准差）", "/statistics/scores/volatility?top_n=5&metric=stddev"),
        ("2.7.2 成绩波动 Top 5（最大分差）", "/statistics/scores/volatility?top_n=5&metric=range"),
        ("2.7.2 班级就业漏斗", "/statistics/employment/funnel"),
        ("总览", "/statistics/overview"),
    ]
    for name, path in checks:
        path_local, name_local = path, name

        @step(name_local)
        def _(p=path_local):
            body = call("GET", p)
            data = body["data"]
            count = len(data) if isinstance(data, list) else len(data.get("items", [])) if isinstance(data, dict) else "-"
            return f"code={body['code']} 返回 {count} 项"

    # ---------------- 高级筛选
    @step("2.7.1 需求文档原始示例（年龄+性别+嵌套 OR 薪资/班级）")
    def _():
        body = call("POST", "/advanced/query", json={
            "model": "student",
            "rules": [
                {"field": "age", "operator": ">", "value": 25},
                {"field": "gender", "operator": "=", "value": "男"},
                {"logic": "OR", "sub_rules": [
                    {"field": "salary", "operator": ">=", "value": 15000},
                    {"field": "class_name", "operator": "like", "value": "Java"},
                ]},
            ],
            "order_by": "salary", "order": "desc", "page": 1, "page_size": 10,
        })
        data = body["data"]
        assert data["explain"], "没有返回 SQL 说明"
        return f"命中 {data['total']} 条"

    @step("2.7.1 嵌套两组 AND/OR 三层")
    def _():
        body = call("POST", "/advanced/query", json={
            "model": "student",
            "rules": [
                {"logic": "AND", "sub_rules": [
                    {"field": "age", "operator": "between", "value": [19, 26]},
                    {"logic": "OR", "sub_rules": [
                        {"field": "education", "operator": "in", "value": ["大专", "本科"]},
                        {"logic": "AND", "sub_rules": [
                            {"field": "major", "operator": "like", "value": "软件"},
                            {"field": "gender", "operator": "=", "value": 2},
                        ]},
                    ]},
                ]},
            ],
            "page_size": 5,
        })
        return f"命中 {body['data']['total']} 条"

    @step("2.7.1 操作符 != / not_like / is_null / not_null / not_in")
    def _():
        total = 0
        for rule in [
            {"field": "gender", "operator": "!=", "value": "男"},
            {"field": "major", "operator": "not_like", "value": "软件"},
            {"field": "remark", "operator": "is_null"},
            {"field": "phone", "operator": "not_null"},
            {"field": "education", "operator": "not_in", "value": ["中专"]},
        ]:
            body = call("POST", "/advanced/query", json={"model": "student", "rules": [rule], "page_size": 1})
            total += body["data"]["total"]
        return f"五种操作符均可用，命中数合计 {total}"

    @step("2.7.1 非法字段给出可用字段提示")
    def _():
        body = call("POST", "/advanced/query", expect_code=422, json={
            "model": "student", "rules": [{"field": "salary2", "operator": ">", "value": 1}]
        })
        assert "可用字段" in body["msg"]
        return body["msg"][:50]

    @step("2.7.1 非法操作符被拒")
    def _():
        return call("POST", "/advanced/query", expect_code=422, json={
            "model": "student", "rules": [{"field": "age", "operator": "; drop table", "value": 1}]
        })["msg"][:50]

    @step("2.7.1 嵌套过深被拒")
    def _():
        rule = {"field": "age", "operator": ">", "value": 1}
        for _i in range(10):
            rule = {"logic": "AND", "sub_rules": [rule]}
        body = call("POST", "/advanced/query", expect_code=422, json={"model": "student", "rules": [rule]})
        return body["msg"][:50]

    @step("2.7.2 通用聚合：按班级统计人数/平均分/最高分")
    def _():
        body = call("POST", "/advanced/aggregate", json={
            "model": "score", "group_by": ["class_name"],
            "metrics": [{"func": "count", "alias": "成绩数"},
                        {"func": "avg", "field": "score", "alias": "平均分"},
                        {"func": "max", "field": "score", "alias": "最高分"}],
            "order_by": "平均分", "order": "desc", "limit": 10,
        })
        return f"{len(body['data']['rows'])} 行，列：{body['data']['columns']}"

    @step("2.7.2 聚合 + HAVING 过滤")
    def _():
        body = call("POST", "/advanced/aggregate", json={
            "model": "employment", "group_by": ["class_name"],
            "metrics": [{"func": "count", "alias": "就业人数"},
                        {"func": "avg", "field": "salary", "alias": "平均薪资"}],
            "having": [{"field": "平均薪资", "operator": ">", "value": 13000}],
            "order_by": "平均薪资", "order": "desc", "limit": 10,
        })
        assert all(r["平均薪资"] > 13000 for r in body["data"]["rows"])
        return f"{len(body['data']['rows'])} 个班达标"

    # ---------------- 权限
    @step("只读账号不能写")
    def _():
        admin_token = Ctx.token
        Ctx.token = None
        viewer = call("POST", "/auth/login", json={"username": "viewer", "password": "viewer123"})["data"]["access_token"]
        token = Ctx.token
        Ctx.token = viewer
        body = call("POST", "/students", expect_code=None, json={"name": "越权", "gender": 1, "age": 20})
        Ctx.token = admin_token
        assert body["code"] == 403, f"期望 403，实际 {body['code']} {body['msg']}"
        return body["msg"]


def cleanup_selftest() -> None:
    """删掉自检造出来的业务数据，避免污染演示库。

    自检用的名字都带 `自检` / `导入` 前缀 + 当天日期戳（如 自检学生A0916），
    这里按「前缀 + 日期戳」精确匹配删除，不会误伤正常的演示数据。

    走 ORM 而不是 HTTP：要按外键顺序连删 成绩/就业/学生/班级/老师/顾问 + 中间表，
    用 SQL 一次搞定最可靠。导入失败（比如脚本被拷到别的机器上跑）只提示一句，不算测试失败。
    """
    stamp = date.today().strftime("%m%d")
    # 以 `python tests/api_check.py` 方式运行时，sys.path[0] 是 tests/，
    # 直接 import app 会失败 —— 这里把项目根补进搜索路径。
    project_root = str(Path(__file__).resolve().parent.parent)
    if project_root not in sys.path:
        sys.path.insert(0, project_root)
    try:
        from sqlalchemy import or_

        from app.core.database import SessionLocal
        from app.model import Advisor, Clazz, Employment, Score, Student, Teacher, class_teachers
    except Exception as exc:  # noqa: BLE001
        print(f"  [SKIP] 连不上数据库，跳过清理（要清理请跑 seed_data.py --reset）：{exc}")
        return

    def name_hit(model):
        return or_(model.name.like(f"%自检%{stamp}%"), model.name.like(f"%导入%{stamp}%"))

    counts: dict[str, int] = {}
    with SessionLocal() as db:
        stu_ids = [r[0] for r in db.query(Student.id).filter(name_hit(Student)).all()]
        cls_ids = [r[0] for r in db.query(Clazz.id).filter(name_hit(Clazz)).all()]
        tea_ids = [r[0] for r in db.query(Teacher.id).filter(name_hit(Teacher)).all()]
        adv_ids = [r[0] for r in db.query(Advisor.id).filter(name_hit(Advisor)).all()]

        if stu_ids:
            counts["成绩"] = db.query(Score).filter(Score.stu_id.in_(stu_ids)).delete(synchronize_session=False)
            counts["就业"] = db.query(Employment).filter(Employment.stu_id.in_(stu_ids)).delete(
                synchronize_session=False
            )
            counts["学生"] = db.query(Student).filter(Student.id.in_(stu_ids)).delete(synchronize_session=False)
        if cls_ids:
            db.execute(class_teachers.delete().where(class_teachers.c.class_id.in_(cls_ids)))
            counts["班级"] = db.query(Clazz).filter(Clazz.id.in_(cls_ids)).delete(synchronize_session=False)
        if tea_ids:
            db.execute(class_teachers.delete().where(class_teachers.c.teacher_id.in_(tea_ids)))
            counts["老师"] = db.query(Teacher).filter(Teacher.id.in_(tea_ids)).delete(synchronize_session=False)
        if adv_ids:
            counts["顾问"] = db.query(Advisor).filter(Advisor.id.in_(adv_ids)).delete(synchronize_session=False)
        db.commit()

    hit = "，".join(f"{k} {v} 条" for k, v in counts.items() if v)
    print(f"  [清理] 自检数据已删除：{hit or '无残留'}")


def main():
    global BASE
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", default=BASE)
    parser.add_argument("--keep", action="store_true", help="保留自检造的数据（默认跑完会清掉）")
    args = parser.parse_args()
    BASE = args.base

    Ctx.client = httpx.Client(base_url=BASE, timeout=60)

    print("\n== 登录 ==")
    try:
        body = call("POST", "/auth/login", json={"username": "admin", "password": "admin123"})
        Ctx.token = body["data"]["access_token"]
        print(f"  [PASS] 管理员登录：{body['msg']}")
        PASS.append(("管理员登录", body["msg"]))
    except Exception as exc:  # noqa: BLE001
        print(f"  [FAIL] 登录失败：{exc}")
        FAIL.append(("管理员登录", str(exc)))
        sys.exit(1)

    check_reads()
    ctx = check_write_flow()
    check_statistics(ctx)

    if not args.keep:
        print("\n== 收尾清理 ==")
        cleanup_selftest()

    print("\n" + "=" * 70)
    print(f"通过 {len(PASS)} 项，失败 {len(FAIL)} 项")
    if FAIL:
        print("\n失败明细：")
        for title, reason in FAIL:
            print(f"  - {title}\n      {reason}")
        sys.exit(2)
    print("全部通过 ✅")


if __name__ == "__main__":
    main()