"""账号管理（Account Management）—— 从 auto(Node) 项目移植的 `plus`(GPT 管理) 功能。

本模块是「加法式」的：仅新增一个 Flask Blueprint，挂到主 app（app.register_blueprint）。
不改动任何既有功能。页面地址 /account-manager/，API 前缀 /api/plus。

数据存储：card-binding/data/plus.json（记录形状与 auto/data/plus.json 一致：
  email, password, clientId, refreshToken, note, createdAt，拿 RT 后追加
  codexRt, codexClientId, codexAccessToken, codexIdToken, codexStatus, banned, banReason）。

两类操作的实现：
  纯 Python（列表/导入/删除/删封号/导出）—— 忠实复刻 Node 的纯数据逻辑；
  Node 子进程（查收 inbox / 批量拿 RT）—— 直接复用 auto 的 get-rt.js / plus-mailbox.js，
  经 account-manager/node/*.mjs 包装，用 `node <script>` + stdin(JSON) 调用，mirror
  项目里既有的“Python 调子进程”做法。
"""
from __future__ import annotations

import base64
import json
import os
import random
import re
import subprocess
import sys
import threading
import time
import uuid
from pathlib import Path

try:
    import httpx
except Exception:  # pragma: no cover - httpx ships with the server interpreter
    httpx = None

from flask import Blueprint, Response, jsonify, render_template, request

ROOT = Path(__file__).resolve().parent
DATA_DIR = ROOT / "data"
PLUS_FILE = DATA_DIR / "plus.json"
NODE_DIR = ROOT / "account-manager" / "node"
CONFIG_DIR = ROOT / "account-manager" / "config"
SETTINGS_FILE = CONFIG_DIR / "settings.json"
PROXY_FILE = CONFIG_DIR / "proxies.json"
MAILBOX_FILE = CONFIG_DIR / "mailbox.json"

# Node 可执行文件：默认走 PATH 上的 node，可用环境变量覆盖。
NODE_BIN = os.getenv("ACCOUNT_MGR_NODE", "").strip() or os.getenv("NODE_BIN", "").strip() or "node"
INBOX_RUNNER = str(NODE_DIR / "inbox_runner.mjs")
RT_RUNNER = str(NODE_DIR / "rt_runner.mjs")
REG_RUNNER = str(NODE_DIR / "reg_runner.mjs")
# 浏览器注册（CloakBrowser 隐身 Chromium）runner —— 与 REG_RUNNER（HTTP 协议注册）并列，
# 由「注册方式」决定调用哪一个；两者输入/输出协议一致，故批量编排逻辑可共用。
CLOAK_REG_RUNNER = str(NODE_DIR / "cloak_reg_runner.mjs")
REFETCH_RUNNER = str(NODE_DIR / "refetch_runner.mjs")
# 注册子进程回读邮箱验证码用的内部地址（主 app 端口）
OTP_INTERNAL_BASE = os.getenv("ACCOUNT_MGR_BASE", "").strip() or "http://127.0.0.1:5088"

# 实时套餐校验(accounts/check)需 curl_cffi(firefox144) 绕过 Cloudflare；主程序解释器 curl_cffi 版本可能过旧，
# 故用 .venv 的 python 以子进程执行 plan_check_session.py（与 card_bind_session.py 同源）。
def _default_venv_python() -> str:
    venv_dir = ROOT.parent / ".venv"
    candidates = (
        venv_dir / "Scripts" / "python.exe",  # Windows
        venv_dir / "bin" / "python",          # Linux/macOS
    )
    return next((str(candidate) for candidate in candidates if candidate.exists()), sys.executable)
PY_BIN = os.getenv("PAY153_PYTHON", "").strip() or _default_venv_python()
PLAN_CHECK_SCRIPT = str(ROOT / "plan_check_session.py")

SUB2API_DEFAULT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"

bp = Blueprint("account_manager", __name__)

_plus_lock = threading.RLock()

# 批量拿 RT 运行态（mirror server.js 的 rtRunning + pushLog 日志环）
_rt_state = {
    "running": False,
    "total": 0,
    "done": 0,
    "ok": 0,
    "banned": 0,
    "fail": 0,
    "logs": [],  # [{ ts, level, msg, account }]
    "started_at": 0,
    "finished_at": 0,
}
_rt_lock = threading.RLock()
_MAX_LOGS = 500

# 协议注册运行态
_reg_state = {
    "running": False,
    "stop": False,
    "total": 0,
    "done": 0,
    "ok": 0,
    "fail": 0,
    "logs": [],
    "started_at": 0,
    "finished_at": 0,
}
_reg_lock = threading.RLock()


# ---------- JSON 存储 ----------
def load_plus() -> list:
    with _plus_lock:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        if not PLUS_FILE.exists():
            return []
        try:
            data = json.loads(PLUS_FILE.read_text(encoding="utf-8"))
            return data if isinstance(data, list) else []
        except Exception:
            return []


def save_plus(items: list) -> None:
    with _plus_lock:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        PLUS_FILE.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")


def load_settings() -> dict:
    try:
        return json.loads(SETTINGS_FILE.read_text(encoding="utf-8")) or {}
    except Exception:
        return {}


def load_proxies() -> list:
    try:
        data = json.loads(PROXY_FILE.read_text(encoding="utf-8"))
        return data if isinstance(data, list) else []
    except Exception:
        return []


# ---------- 解析导入格式（忠实复刻 plus-mailbox.js parsePlus）----------
# 每行：email----password----clientId----refreshToken（兼容制表符 / | / 空白分隔）
_EMAIL_RE = re.compile(r"^[^\s@]+@[^\s@]+\.[^\s@]+$")


def parse_plus(text: str) -> list:
    out: list = []
    seen: set = set()
    for raw in str(text or "").split("\n"):
        line = raw.replace("\r", "").strip()
        if not line:
            continue
        if "----" in line:
            parts = line.split("----")
        elif "\t" in line:
            parts = line.split("\t")
        elif "|" in line:
            parts = line.split("|")
        else:
            parts = re.split(r"\s+", line)
        parts = [s.strip() for s in parts if s.strip()]
        if len(parts) < 4:
            continue
        email, password, client_id, refresh_token = parts[0], parts[1], parts[2], parts[3]
        if not _EMAIL_RE.match(email):
            continue
        key = email.lower()
        if key in seen:
            continue
        seen.add(key)
        out.append({"email": email, "password": password, "clientId": client_id, "refreshToken": refresh_token})
    return out


# ---------- 页面 ----------
@bp.get("/account-manager/")
def account_manager_page():
    return render_template("account-manager.html")


# ---------- GET /api/plus ----------
@bp.get("/api/plus")
def api_plus_list():
    return jsonify({"accounts": load_plus()})


# ---------- POST /api/plus/import ----------
@bp.post("/api/plus/import")
def api_plus_import():
    body = request.get_json(silent=True) or {}
    parsed = parse_plus(body.get("text") or "")
    with _plus_lock:
        items = load_plus()
        by_email = {a.get("email", "").lower(): a for a in items}
        added = 0
        updated = 0
        for item in parsed:
            key = item["email"].lower()
            existing = by_email.get(key)
            if existing:
                changed = False
                for f in ("password", "clientId", "refreshToken"):
                    if existing.get(f) != item.get(f):
                        existing[f] = item[f]
                        changed = True
                if changed:
                    updated += 1
            else:
                rec = {
                    "email": item["email"],
                    "password": item["password"],
                    "clientId": item["clientId"],
                    "refreshToken": item["refreshToken"],
                    "note": "",
                    "createdAt": int(time.time() * 1000),
                }
                items.append(rec)
                by_email[key] = rec
                added += 1
        save_plus(items)
        total = len(items)
    return jsonify({"added": added, "updated": updated, "parsed": len(parsed), "total": total})


# ---------- DELETE /api/plus ----------
# 按 emails 删除；「批量删除封号」由前端收集封号邮箱后走同一入口（与 Node 一致）。
@bp.delete("/api/plus")
def api_plus_delete():
    body = request.get_json(silent=True) or {}
    emails = body.get("emails") or []
    target = {str(e).lower() for e in emails}
    with _plus_lock:
        items = load_plus()
        before = len(items)
        items = [a for a in items if a.get("email", "").lower() not in target]
        save_plus(items)
        total = len(items)
    return jsonify({"removed": before - total, "total": total})


# ---------- POST /api/plus/inbox（查收，Node 子进程）----------
@bp.post("/api/plus/inbox")
def api_plus_inbox():
    body = request.get_json(silent=True) or {}
    email = str(body.get("email") or "")
    items = load_plus()
    acc = next((a for a in items if a.get("email", "").lower() == email.lower()), None)
    if not acc:
        return jsonify({"error": "账号不存在"}), 404
    payload = {
        "email": acc.get("email"),
        "clientId": acc.get("clientId"),
        "refreshToken": acc.get("refreshToken"),
    }
    try:
        proc = subprocess.run(
            [NODE_BIN, INBOX_RUNNER],
            input=json.dumps(payload),
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            cwd=str(NODE_DIR),
            timeout=90,
        )
    except FileNotFoundError:
        return jsonify({"error": f"未找到 Node 可执行文件：{NODE_BIN}"}), 500
    except subprocess.TimeoutExpired:
        return jsonify({"error": "查收超时"}), 504
    out = (proc.stdout or "").strip()
    if not out:
        return jsonify({"error": f"查收进程无输出（stderr: {(proc.stderr or '').strip()[:300]}）"}), 502
    try:
        result = json.loads(out)
    except Exception:
        return jsonify({"error": f"查收结果解析失败：{out[:300]}"}), 502
    if not result.get("ok"):
        status = int(result.get("status") or 502)
        return jsonify({"error": result.get("error") or "查收失败"}), (401 if status == 401 else 502)
    return jsonify({"address": result.get("address"), "via": result.get("via"), "messages": result.get("messages") or []})


# ---------- 拿 RT 编排（mirror server.js runGetRtBatch）----------
def _rt_log(level: str, msg: str, account: str = "") -> None:
    entry = {"ts": int(time.time() * 1000), "level": level, "msg": str(msg), "account": account or ""}
    with _rt_lock:
        _rt_state["logs"].append(entry)
        if len(_rt_state["logs"]) > _MAX_LOGS:
            del _rt_state["logs"][: len(_rt_state["logs"]) - _MAX_LOGS]


def _run_get_rt_batch(targets: list) -> None:
    settings = load_settings()
    sms = settings.get("sms") or {}
    provider = sms.get("provider") or "smscode"
    sms_configured = bool((sms.get(provider) or {}).get("apiKey"))
    proxies = load_proxies()
    ok_proxies = [p for p in proxies if p.get("status") == "ok"]
    pool = ok_proxies if ok_proxies else proxies
    try:
        concurrency = int(settings.get("concurrency") or 1)
    except (TypeError, ValueError):
        concurrency = 1
    concurrency = max(1, min(concurrency, len(targets) or 1))

    with _rt_lock:
        _rt_state.update({"running": True, "total": len(targets), "done": 0, "ok": 0,
                          "banned": 0, "fail": 0, "started_at": int(time.time() * 1000), "finished_at": 0})
    _rt_log("info", f"====== 批量拿 RT 开始：{len(targets)} 个账号 ｜ 并发 {concurrency} ｜ "
                     f"可用代理 {len(ok_proxies)}/{len(proxies)} ｜ 接码 {'已配置' if sms_configured else '未配置'} ======")

    queue = list(enumerate(targets))
    q_lock = threading.Lock()

    def worker(wid: int) -> None:
        while True:
            with q_lock:
                if not queue:
                    return
                idx, target = queue.pop(0)
            proxy = pool[idx % len(pool)] if pool else None
            with _rt_lock:
                _rt_state["done"] += 1
                done = _rt_state["done"]
            _rt_log("info", f"—— [{done}/{len(targets)}] 线程#{wid} 拿 RT ——", target.get("email"))
            payload = {
                "account": {
                    "email": target.get("email"),
                    "password": target.get("password"),
                    "clientId": target.get("clientId"),
                    "refreshToken": target.get("refreshToken"),
                },
                "settings": settings,
                "proxy": proxy,
            }
            result = None
            try:
                proc = subprocess.run(
                    [NODE_BIN, RT_RUNNER],
                    input=json.dumps(payload),
                    capture_output=True,
                    text=True,
                    encoding="utf-8",
                    errors="replace",
                    cwd=str(NODE_DIR),
                    timeout=600,
                )
                for line in (proc.stderr or "").splitlines():
                    line = line.strip()
                    if not line:
                        continue
                    try:
                        rec = json.loads(line)
                        _rt_log(rec.get("level") or "info", rec.get("msg") or "", rec.get("account") or target.get("email"))
                    except Exception:
                        _rt_log("info", line, target.get("email"))
                out = (proc.stdout or "").strip()
                result = json.loads(out) if out else {"ok": False, "banned": False, "error": "拿 RT 进程无输出"}
            except FileNotFoundError:
                result = {"ok": False, "banned": False, "error": f"未找到 Node 可执行文件：{NODE_BIN}"}
            except subprocess.TimeoutExpired:
                result = {"ok": False, "banned": False, "error": "拿 RT 超时（600s）"}
            except Exception as exc:  # noqa: BLE001
                result = {"ok": False, "banned": False, "error": str(exc)}

            # 写回 plus.json
            with _plus_lock:
                items = load_plus()
                rec = next((x for x in items if x.get("email", "").lower() == target.get("email", "").lower()), None)
                if result.get("ok"):
                    if rec is not None:
                        rec["codexRt"] = result.get("refreshToken")
                        if result.get("clientId"):
                            rec["codexClientId"] = result.get("clientId")
                        if result.get("accessToken"):
                            rec["codexAccessToken"] = result.get("accessToken")
                        if result.get("idToken"):
                            rec["codexIdToken"] = result.get("idToken")
                        rec["codexStatus"] = "ok"
                        rec["banned"] = False
                    with _rt_lock:
                        _rt_state["ok"] += 1
                    _rt_log("ok", "已获取 refresh_token 并写回", target.get("email"))
                elif result.get("banned"):
                    if rec is not None:
                        rec["banned"] = True
                        rec["banReason"] = result.get("reason") or ""
                        rec["codexStatus"] = "banned"
                    with _rt_lock:
                        _rt_state["banned"] += 1
                    _rt_log("warn", "账号已封禁（403 停用/删除），标注为不可用", target.get("email"))
                else:
                    if rec is not None:
                        rec["codexStatus"] = "failed"
                    with _rt_lock:
                        _rt_state["fail"] += 1
                    _rt_log("error", "拿 RT 失败：" + (result.get("error") or "未知原因"), target.get("email"))
                save_plus(items)

    threads = [threading.Thread(target=worker, args=(k + 1,), name=f"rt-{k+1}", daemon=True) for k in range(concurrency)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

    with _rt_lock:
        _rt_state["running"] = False
        _rt_state["finished_at"] = int(time.time() * 1000)
        ok, banned, fail = _rt_state["ok"], _rt_state["banned"], _rt_state["fail"]
    _rt_log("ok", f"====== 批量拿 RT 结束：成功 {ok} ｜ 封号 {banned} ｜ 失败 {fail} ======")


# ---------- POST /api/plus/get-rt ----------
@bp.post("/api/plus/get-rt")
def api_plus_get_rt():
    body = request.get_json(silent=True) or {}
    emails = [str(e).lower() for e in (body.get("emails") or [])]
    items = load_plus()
    targets = [a for a in items if a.get("email", "").lower() in emails]
    if not targets:
        return jsonify({"error": "没有匹配的账号"}), 400
    with _rt_lock:
        if _rt_state["running"]:
            return jsonify({"error": "已有拿 RT 任务正在进行"}), 409
    _rt_log("info", f"收到批量拿 RT 请求：{len(targets)} 个账号")
    threading.Thread(target=_run_get_rt_batch, args=(targets,), name="rt-batch", daemon=True).start()
    return jsonify({"started": len(targets)})


# ---------- GET /api/plus/rt-status（拿 RT 进度/日志，供前端轮询）----------
@bp.get("/api/plus/rt-status")
def api_plus_rt_status():
    with _rt_lock:
        return jsonify({
            "running": _rt_state["running"],
            "total": _rt_state["total"],
            "done": _rt_state["done"],
            "ok": _rt_state["ok"],
            "banned": _rt_state["banned"],
            "fail": _rt_state["fail"],
            "logs": list(_rt_state["logs"][-200:]),
        })


# ==========================================================================
# 协议注册（复用 get-rt.js 的无密码 OAuth 协议流程，跑在邮箱池的未使用邮箱上）
# ==========================================================================
# ---------- 日志美化：把注册/重拿RT 的技术日志压成「纯中文 ≤15 字 脱敏」短语 ----------
# 设计：集中一个「关键词→中文短语」有序映射；命中即替换；未命中且含技术噪声则丢弃，
# 未命中但本身已是短中文则原样保留。时间戳/邮箱由前端浮层展示，文本不再重复技术串。
_BEAUTIFY_RULES = [
    (r"开始注册|协议注册开始|====== 协议注册开始|浏览器注册开始|====== 浏览器注册开始", "开始注册"),
    (r"本次完成|协议注册结束|====== 协议注册结束|浏览器注册结束|====== 浏览器注册结束", "本次完成"),
    (r"浏览器启动|启动浏览器", "启动浏览器"),
    (r"获取授权成功|获取授权中|授权成功", "获取授权中"),
    (r"账号登录成功|登录成功", "账号登录成功"),
    (r"开始重拿|重拿RT中|重新登录中", "重拿RT中"),
    (r"重拿成功", "重拿成功"),
    (r"重拿失败", "重拿失败"),
    # 批量绑手机拿RT：与重拿RT同一套 codex 登录+手机+换RT 流程，仅日志用词区分。
    (r"开始绑机|绑手机拿RT|绑机拿RT", "绑机拿RT中"),
    (r"绑机成功|绑手机成功", "绑机成功"),
    (r"绑机失败|绑手机失败", "绑机失败"),
    (r"步骤1|初始化 ?OAuth|初始化会话", "正在初始化"),
    (r"已建号但后续失败|burned", "建号后失败"),
    (r"user/?register|创建账号|create-account/password|POST .*register", "创建账号中"),
    (r"authorize/?continue|提交邮箱", "提交邮箱"),
    (r"email-?otp/?send|请求邮箱验证码|发送验证码", "发送验证码"),
    (r"命中新鲜.*验证码|已收到验证码|已收到.*码：", "已收到验证码"),
    (r"从 ?Outlook 收取|收取邮箱验证码|等待 ?verification|查收.*等待|等待短信验证码|等待验证码", "等待验证码"),
    (r"email-?otp/?validate.*(200|通过)|邮箱验证通过", "邮箱验证通过"),
    (r"suspicious|号码被拒|拒绝手机号", "号码被拒重试"),
    (r"NO_BALANCE|余额不足|接码余额", "接码余额不足"),
    (r"手机验证失败|拿号失败|短信验证码校验失败|拿号超时|短信.*超时", "手机验证失败"),
    (r"add[_-]?phone|需要手机验证|要求手机验证|phone[_-]?verification", "需要手机验证"),
    (r"请求号码|拿号|获取手机号|已获取号码|提交手机号", "获取手机号中"),
    (r"phone-?otp/?validate.*(200|通过)|手机验证完成|手机验证通过", "手机验证通过"),
    (r"about[_-]?you|补充资料|完善资料", "完善资料中"),
    (r"consent|workspace/?select|oauth2/?auth|authorization code|获取授权|提取.*code", "获取授权中"),
    (r"/oauth/?token|换取.*token|换取令牌|获取令牌", "获取令牌中"),
    (r"refresh_token（第一阶段）|拿到令牌|第一阶段.*成功", "账号登录成功"),
    (r"获取SUB|开始 ?SUB|第二阶段.*开始", "获取SUB中"),
    (r"SUB获取成功|SUB 成功|独立 ?SUB", "SUB获取成功"),
    (r"SUB获取失败|SUB 未取得|SUB.*失败", "SUB获取失败"),
    (r"注册成功|已保存为 ?GPT|落库", "注册成功"),
    (r"账号已保存|容错保存", "账号已保存"),
    (r"已建号但后续失败|burned", "建号后失败"),
    (r"账号已停用|deactivat|deleted", "账号已停用"),
    (r"账号已存在|already (registered|exists)|Failed to create account", "账号已存在"),
    (r"fetch failed|网络|timeout|超时|ECONN|ETIMEDOUT", "网络异常，重试中"),
    (r"sentinel|安全校验", "安全校验失败"),
    (r"region|territory|unsupported_country|无资格|不支持|该号不可用", "该号不可用"),
]
_BEAUTIFY_COMPILED = [(re.compile(p, re.I), t) for p, t in _BEAUTIFY_RULES]
# 含以下技术噪声、且未命中任何映射的日志 → 丢弃不展示
_NOISE_RE = re.compile(
    r"https?://|HTTP\b|状态：|status|code=|page\.type|continue_url|follow\[|cookie|/api/|"
    r"login_verifier|consent_challenge|workspace_id|session_dump|localhost|%[0-9A-Fa-f]{2}|"
    r"\bGET\b|\bPOST\b|refresh_token|access_token|oai-|device|订单|referer|json|body=|"
    r"仅接受收件时间|返回 page|结果状态|线程#|收到协议注册请求|收尾状态机|"
    r"使用接码平台|换号重试|次：国家|第 ?\d+/\d+|channel=|订单|WAIT_CODE",
    re.I,
)
_HAN_RE = re.compile(r"[\u4e00-\u9fff]")


def _beautify_log(msg: str) -> str | None:
    """把一条原始日志压成 ≤15 字纯中文短语；返回 None 表示丢弃（纯技术噪声）。"""
    s = (msg or "").strip()
    if not s:
        return None
    for rx, text in _BEAUTIFY_COMPILED:
        if rx.search(s):
            return text
    # 未命中映射：含技术噪声 → 丢弃；否则若是短中文原样保留（截断 15 字）
    if _NOISE_RE.search(s):
        return None
    if _HAN_RE.search(s) and len(s) <= 30:
        return s[:15]
    return None


def _reg_log(level: str, msg: str, email: str = "") -> None:
    clean = _beautify_log(str(msg))
    if clean is None:
        return
    entry = {"ts": int(time.time() * 1000), "level": level, "msg": clean, "account": email or ""}
    with _reg_lock:
        _reg_state["logs"].append(entry)
        if len(_reg_state["logs"]) > _MAX_LOGS:
            del _reg_state["logs"][: len(_reg_state["logs"]) - _MAX_LOGS]


def _save_registered_account(email: str, result: dict) -> None:
    with _plus_lock:
        items = load_probe()
        key = email.lower()
        rec = next((x for x in items if x.get("email", "").lower() == key), None)
        if rec is None:
            rec = {
                "id": str(uuid.uuid4()),
                "email": email,
                "password": "",
                "clientId": result.get("clientId") or SUB2API_DEFAULT_CLIENT_ID,
                "refreshToken": "",
                "accessToken": "",
                "chatgptAccountId": "",
                "planType": "",
                "createdAt": int(time.time() * 1000),
            }
            items.append(rec)
        # 兜底：历史注册记录可能缺 id，补上以免前端编辑/复制按 id 查不到（find 返回 undefined）
        if not rec.get("id"):
            rec["id"] = str(uuid.uuid4())
        rec["refreshToken"] = result.get("refreshToken") or rec.get("refreshToken", "")
        rec["accessToken"] = result.get("accessToken") or rec.get("accessToken", "")
        if result.get("password"):
            rec["password"] = result.get("password")
        if result.get("clientId"):
            rec["clientId"] = result.get("clientId")
        # 第二阶段 SUB / sub2api 授权结果（best-effort）：拿到则记 subOk=True 并保存 SUB 令牌，
        # 没拿到则 subOk=False（账号第一阶段信息仍然落库，SUB 列显示"否"）。
        rec["subOk"] = bool(result.get("subOk"))
        if result.get("subOk"):
            rec["subClientId"] = result.get("subClientId") or ""
            rec["subRefreshToken"] = result.get("subRefreshToken") or ""
            if result.get("subAccessToken"):
                rec["subAccessToken"] = result.get("subAccessToken")
        # 网页注册产物（无手机验证策略）：持久化 网页AT / 网页RT / 会话cookie(CK) / 2FA密钥 到账号记录。
        # 这些字段只要 runner 返回就存，不再局限于 phonePending 分支（用户要求核实密码/AT/RT/2FA 均落库）。
        if result.get("webAccessToken"):
            rec["webAccessToken"] = result.get("webAccessToken")
        if result.get("webRefreshToken"):
            rec["webRefreshToken"] = result.get("webRefreshToken")
        if result.get("twoFactorSecret"):
            rec["twoFactorSecret"] = result.get("twoFactorSecret")
        if result.get("chatgptAccountId"):
            rec["chatgptAccountId"] = result.get("chatgptAccountId")
        cookies = result.get("cookies")
        if isinstance(cookies, list) and cookies:
            rec["cookies"] = cookies
        # phonePending：网页号尚无 codex RT，标记「手机/RT 待补」，SUB 列显示否（现策略不再自动绑手机）。
        if result.get("phonePending"):
            rec["phonePending"] = True
        rec["registeredAt"] = int(time.time() * 1000)
        save_probe(items)


def _run_reg_batch(targets: list, threads: int, mode: str = "protocol", headless: bool = True,
                   skip_phone: bool = True, web_client: bool = True) -> None:
    settings = load_settings()
    proxies = load_proxies()
    pool = [p for p in proxies if p.get("status") == "ok"] or proxies
    threads = max(1, min(int(threads or 1), len(targets) or 1, 20))
    # 注册方式：protocol=HTTP 直连（reg_runner.mjs）；browser=CloakBrowser 浏览器（cloak_reg_runner.mjs）。
    is_browser = str(mode or "protocol").lower() == "browser"
    runner = CLOAK_REG_RUNNER if is_browser else REG_RUNNER
    license_key = str(settings.get("cloakLicenseKey") or "").strip()
    with _reg_lock:
        _reg_state.update({"running": True, "stop": False, "total": len(targets), "done": 0,
                           "ok": 0, "fail": 0, "started_at": int(time.time() * 1000), "finished_at": 0})
    if is_browser:
        _reg_log("info", f"====== 浏览器注册开始：{len(targets)} 个邮箱 ｜ 并发 {threads} ｜ "
                          f"{'无头' if headless else '有头'} ｜ 可用代理 {len(pool)} ｜ "
                          f"KEY {'已配置' if license_key else '未配置'} ======")
        if not license_key:
            _reg_log("warn", "未配置 CloakBrowser KEY，将以免费额度启动（可能受限）")
    else:
        _reg_log("info", f"====== 协议注册开始：{len(targets)} 个邮箱 ｜ 并发 {threads} ｜ 可用代理 {len(pool)} ======")

    queue = list(enumerate(targets))
    q_lock = threading.Lock()

    def worker(wid: int) -> None:
        while True:
            with _reg_lock:
                if _reg_state["stop"]:
                    return
            with q_lock:
                if not queue:
                    return
                idx, target = queue.pop(0)
            # 随机取代理：这些代理是同一网关的不同 session（sid），随机可换出口 IP，
            # 避免单号测试时永远命中同一个坏 session 导致 fetch failed。
            proxy = random.choice(pool) if pool else None
            email = target.get("email")
            with _reg_lock:
                _reg_state["done"] += 1
                done = _reg_state["done"]
            _reg_log("info", f"—— [{done}/{len(targets)}] 线程#{wid} 开始{'浏览器' if is_browser else '协议'}注册 ——", email)
            payload = {"email": email, "settings": settings, "proxy": proxy, "otpBase": OTP_INTERNAL_BASE}
            # 浏览器模式额外透传：无头开关 + CloakBrowser license key（协议模式忽略这些字段）。
            if is_browser:
                payload["headless"] = bool(headless)
                payload["licenseKey"] = license_key
                # 新策略：注册阶段不做手机验证——走到手机页就采集 CK+AT 入库（手机/RT 由后续批量绑手机再补）。
                payload["skipPhone"] = bool(skip_phone)
                # 走 chatgpt.com 网页客户端注册（app_X8zY6…）：实测无密码(邮箱验证码即登录)、不强制手机，
                # 注册完成即拿「会话 cookie(CK)+网页 AT」。codex 授权流(app_EMoam…)会强制手机，只留给
                # 后续「批量绑手机拿RT」。默认开启；如需回退 codex 注册流，前端传 webClient=false。
                payload["webClient"] = bool(web_client)
            result = None
            try:
                # 用 Popen 实时把 Node 的 stderr 日志逐行喂给 reg 日志（原来 subprocess.run 只能在子进程
                # 结束后一次性读取，导致跑手机验证等长耗时步骤时前端完全看不到进度）。
                proc = subprocess.Popen(
                    [NODE_BIN, runner],
                    stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                    text=True, encoding="utf-8", errors="replace", cwd=str(NODE_DIR),
                )
                try:
                    proc.stdin.write(json.dumps(payload))
                    proc.stdin.close()
                except Exception:
                    pass

                def _pump_stderr() -> None:
                    try:
                        for line in proc.stderr:
                            line = (line or "").strip()
                            if not line:
                                continue
                            try:
                                rec = json.loads(line)
                                _reg_log(rec.get("level") or "info", rec.get("msg") or "", rec.get("account") or email)
                            except Exception:
                                _reg_log("info", line, email)
                    except Exception:
                        pass

                et = threading.Thread(target=_pump_stderr, name=f"reg-err-{wid}", daemon=True)
                et.start()

                timed_out = {"v": False}

                def _kill_on_timeout() -> None:
                    timed_out["v"] = True
                    try:
                        proc.kill()
                    except Exception:
                        pass

                # 浏览器模式首启会下载隐身 Chromium(~200MB) 且有真实渲染/手机验证，耗时更长，
                # 放宽到 900s；协议模式维持 600s。
                reg_timeout = 900 if is_browser else 600
                timer = threading.Timer(reg_timeout, _kill_on_timeout)
                timer.start()
                try:
                    out = (proc.stdout.read() or "").strip()
                    proc.wait()
                finally:
                    timer.cancel()
                    et.join(timeout=5)

                if timed_out["v"]:
                    result = {"ok": False, "error": f"注册超时（{reg_timeout}s）"}
                else:
                    result = json.loads(out) if out else {"ok": False, "error": "注册进程无输出"}
            except FileNotFoundError:
                result = {"ok": False, "error": f"未找到 Node 可执行文件：{NODE_BIN}"}
            except Exception as exc:  # noqa: BLE001
                result = {"ok": False, "error": str(exc)}

            if result.get("ok"):
                _save_registered_account(email, result)
                with _plus_lock:
                    mb = load_mailbox()
                    me = next((x for x in mb.get("entries", []) if x.get("email", "").lower() == email.lower()), None)
                    if me:
                        me["used"] = True
                        me["usedAt"] = int(time.time() * 1000)
                        save_mailbox(mb)
                with _reg_lock:
                    _reg_state["ok"] += 1
                _reg_log("ok", "注册成功，已保存为 GPT 账号并标记邮箱已使用", email)
            else:
                # user/register 已成功但后续失败：账号已在 OpenAI 侧创建，把邮箱标记 burned，
                # 避免下次再用同一邮箱注册命中"账号已存在"（burned 也计入 used，不再进未使用池）。
                if result.get("registered"):
                    with _plus_lock:
                        mb = load_mailbox()
                        me = next((x for x in mb.get("entries", []) if x.get("email", "").lower() == email.lower()), None)
                        if me:
                            me["used"] = True
                            me["burned"] = True
                            me["usedAt"] = int(time.time() * 1000)
                            me["burnReason"] = (result.get("error") or "注册中途失败")[:200]
                            save_mailbox(mb)
                    _reg_log("warn", "该邮箱已建号但后续失败，已标记 burned（不再复用）", email)
                with _reg_lock:
                    _reg_state["fail"] += 1
                _reg_log("error", "注册失败：" + (result.get("error") or "未知原因"), email)

    ts = [threading.Thread(target=worker, args=(k + 1,), name=f"reg-{k+1}", daemon=True) for k in range(threads)]
    for t in ts:
        t.start()
    for t in ts:
        t.join()

    with _reg_lock:
        _reg_state["running"] = False
        _reg_state["finished_at"] = int(time.time() * 1000)
        ok, fail = _reg_state["ok"], _reg_state["fail"]
    _reg_log("ok", f"====== {'浏览器' if is_browser else '协议'}注册结束：成功 {ok} ｜ 失败 {fail} ======")


@bp.post("/api/reg/start")
def api_reg_start():
    body = request.get_json(silent=True) or {}
    try:
        count = max(1, int(body.get("count") or 1))
    except (TypeError, ValueError):
        count = 1
    try:
        threads = max(1, int(body.get("threads") or 1))
    except (TypeError, ValueError):
        threads = 1
    # 注册方式：protocol（默认，HTTP 直连）/ browser（CloakBrowser）；headless 仅浏览器模式有意义。
    mode = str(body.get("mode") or "protocol").lower()
    if mode not in ("protocol", "browser"):
        mode = "protocol"
    headless = body.get("headless")
    headless = True if headless is None else bool(headless)
    # 新策略默认注册阶段跳过手机（浏览器模式）；前端可显式传 skipPhone=false 恢复「注册即绑手机」旧行为。
    skip_phone = body.get("skipPhone")
    skip_phone = True if skip_phone is None else bool(skip_phone)
    # 浏览器注册默认走 chatgpt.com 网页客户端（不强制手机、拿 CK+AT）；传 webClient=false 回退 codex 注册流。
    web_client = body.get("webClient")
    web_client = True if web_client is None else bool(web_client)
    with _reg_lock:
        if _reg_state["running"]:
            return jsonify({"error": "已有注册任务正在进行"}), 409
    mb = load_mailbox()
    unused = [e for e in mb.get("entries", []) if not e.get("used") and e.get("credential")]
    if not unused:
        return jsonify({"error": "邮箱池没有可用的未使用邮箱"}), 400
    targets = unused[:count]
    label = "浏览器" if mode == "browser" else "协议"
    _reg_log("info", f"收到{label}注册请求：计划 {len(targets)} 个（未使用剩余 {len(unused)}），并发 {threads}"
                     + (f"，{'无头' if headless else '有头'}" if mode == "browser" else ""))
    threading.Thread(target=_run_reg_batch, args=(targets, threads, mode, headless, skip_phone, web_client),
                     name="reg-batch", daemon=True).start()
    return jsonify({"started": len(targets), "mode": mode})


# ---------- 重拿RT：对已存在账号跑一次全新 codex 登录（register:false, 全新 device_id） ----------
# 复用协议注册的日志浮层（_reg_state / _reg_log）显示进度；成功则用新拿到的 codex RT 更新
# 账号 refreshToken / accessToken / clientId，并标记 SUB=是（这份 RT 本身就是 codex/sub2api 凭据）。
def _run_refetch_batch(accounts: list, threads: int, label: str = "重拿RT") -> None:
    # label 用于区分「重拿RT」与「批量绑手机拿RT」——两者底层完全一致（codex 客户端全新登录→
    # 需要手机则接码→换独立 RT），只是入口/日志用词不同。bind 时成功后额外清 phonePending。
    is_bind = label.startswith("绑机")
    prog_msg = f"{label}中"
    ok_msg = "绑机成功" if is_bind else "重拿成功"
    fail_prefix = "绑机失败：" if is_bind else "重拿失败："
    settings = load_settings()
    proxies = load_proxies()
    pool = [p for p in proxies if p.get("status") == "ok"] or proxies
    threads = max(1, min(int(threads or 1), len(accounts) or 1, 20))
    with _reg_lock:
        _reg_state.update({"running": True, "stop": False, "total": len(accounts), "done": 0,
                           "ok": 0, "fail": 0, "started_at": int(time.time() * 1000), "finished_at": 0})
    _reg_log("info", f"====== 开始{label}：{len(accounts)} 个账号 ｜ 并发 {threads} ======")

    queue = list(accounts)
    q_lock = threading.Lock()

    def worker(wid: int) -> None:
        while True:
            with _reg_lock:
                if _reg_state["stop"]:
                    return
            with q_lock:
                if not queue:
                    return
                acc = queue.pop(0)
            proxy = random.choice(pool) if pool else None
            email = acc.get("email") or ""
            with _reg_lock:
                _reg_state["done"] += 1
            _reg_log("info", prog_msg, email)
            # 运行方式按账号数据分流：
            #   有 CK(cookies) 的「网页无密码号」→ 浏览器 bindPhone（CK 恢复/邮箱码重登 → codex 授权 → 手机 → RT）；
            #   无 CK 的「有密码号」（协议模式产出）→ 原 HTTP 密码重登（get-rt.js）。
            ck = acc.get("cookies") if isinstance(acc.get("cookies"), list) else []
            use_browser = bool(ck)
            if use_browser:
                runner_path = CLOAK_REG_RUNNER
                payload = {
                    "email": email,
                    "password": acc.get("password") or "",
                    "cookies": ck,
                    "bindPhone": True,
                    "settings": settings,
                    "proxy": proxy,
                    "otpBase": OTP_INTERNAL_BASE,
                    # 浏览器 bindPhone 默认有头（与已验证的注册路径一致、便于观测、抗检测更稳）。
                    "headless": False,
                    "licenseKey": str(settings.get("cloakLicenseKey") or "").strip(),
                }
            else:
                runner_path = REFETCH_RUNNER
                payload = {
                    "email": email,
                    "password": acc.get("password") or "",
                    "settings": settings,
                    "proxy": proxy,
                    "otpBase": OTP_INTERNAL_BASE,
                }
            result = None
            try:
                proc = subprocess.Popen(
                    [NODE_BIN, runner_path],
                    stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                    text=True, encoding="utf-8", errors="replace", cwd=str(NODE_DIR),
                )
                try:
                    proc.stdin.write(json.dumps(payload))
                    proc.stdin.close()
                except Exception:
                    pass

                def _pump_stderr() -> None:
                    try:
                        for line in proc.stderr:
                            line = (line or "").strip()
                            if not line:
                                continue
                            # 诊断行（[CAP-DIAG]/[BIND-DIAG]/[CLOAK-DIAG]）不进用户日志，保持纯中文≤15字。
                            if line.startswith("["):
                                continue
                            try:
                                rec = json.loads(line)
                                _reg_log(rec.get("level") or "info", rec.get("msg") or "", rec.get("account") or email)
                            except Exception:
                                pass
                    except Exception:
                        pass

                et = threading.Thread(target=_pump_stderr, name=f"refetch-err-{wid}", daemon=True)
                et.start()
                timed_out = {"v": False}

                def _kill_on_timeout() -> None:
                    timed_out["v"] = True
                    try:
                        proc.kill()
                    except Exception:
                        pass

                # 浏览器 bindPhone（CK 恢复/邮箱码重登 + 手机多国轮试）更耗时，放宽到 1200s；HTTP 重登 600s。
                to_sec = 1200 if use_browser else 600
                timer = threading.Timer(to_sec, _kill_on_timeout)
                timer.start()
                try:
                    out = (proc.stdout.read() or "").strip()
                    proc.wait()
                finally:
                    timer.cancel()
                    et.join(timeout=5)
                if timed_out["v"]:
                    result = {"ok": False, "error": f"绑机/重拿RT超时（{to_sec}s）"}
                else:
                    result = json.loads(out) if out else {"ok": False, "error": "重拿RT进程无输出"}
            except FileNotFoundError:
                result = {"ok": False, "error": f"未找到 Node 可执行文件：{NODE_BIN}"}
            except Exception as exc:  # noqa: BLE001
                result = {"ok": False, "error": str(exc)}

            if result.get("ok") and result.get("refreshToken"):
                with _plus_lock:
                    items = load_probe()
                    rec = next((x for x in items if str(x.get("id")) == str(acc.get("id"))), None)
                    if rec is None:
                        rec = next((x for x in items if x.get("email", "").lower() == email.lower()), None)
                    if rec is not None:
                        rec["refreshToken"] = result.get("refreshToken") or rec.get("refreshToken")
                        if result.get("accessToken"):
                            rec["accessToken"] = result.get("accessToken")
                        rec["clientId"] = result.get("clientId") or rec.get("clientId") or SUB2API_DEFAULT_CLIENT_ID
                        # 新拿到的 codex RT 本身即 sub2api(SUB) 凭据
                        rec["subOk"] = True
                        rec["subClientId"] = result.get("clientId") or rec.get("clientId")
                        rec["subRefreshToken"] = result.get("refreshToken")
                        if result.get("accessToken"):
                            rec["subAccessToken"] = result.get("accessToken")
                        rec["status"] = "valid"
                        # 绑手机拿到 RT 后，该账号不再是「待绑手机」态：清 phonePending。
                        rec["phonePending"] = False
                        rec["lastCheckedAt"] = int(time.time() * 1000)
                        save_probe(items)
                with _reg_lock:
                    _reg_state["ok"] += 1
                _reg_log("ok", ok_msg, email)
            else:
                with _reg_lock:
                    _reg_state["fail"] += 1
                _reg_log("error", fail_prefix + (result.get("error") or "未知原因"), email)

    ts = [threading.Thread(target=worker, args=(k + 1,), name=f"refetch-{k+1}", daemon=True) for k in range(threads)]
    for t in ts:
        t.start()
    for t in ts:
        t.join()

    with _reg_lock:
        _reg_state["running"] = False
        _reg_state["finished_at"] = int(time.time() * 1000)
        ok, fail = _reg_state["ok"], _reg_state["fail"]
    _reg_log("ok", f"====== {label}结束：成功 {ok} ｜ 失败 {fail} ======")


@bp.post("/api/probe/refetch-rt")
def api_probe_refetch_rt():
    body = request.get_json(silent=True) or {}
    ids = body.get("ids") or []
    emails = body.get("emails") or []
    try:
        threads = max(1, min(int(body.get("threads") or 3), 5))
    except (TypeError, ValueError):
        threads = 3
    with _reg_lock:
        if _reg_state["running"]:
            return jsonify({"error": "已有注册/重拿任务正在进行，请稍后"}), 409
    items = load_probe()
    idset = {str(x) for x in ids}
    emset = {str(x).lower() for x in emails}
    picked = [a for a in items
              if (idset and str(a.get("id")) in idset) or (emset and str(a.get("email", "")).lower() in emset)]
    if not picked:
        return jsonify({"error": "未选择有效账号"}), 400
    threading.Thread(target=_run_refetch_batch, args=(picked, threads), name="refetch-batch", daemon=True).start()
    return jsonify({"started": len(picked)})


@bp.post("/api/probe/bind-phone-rt")
def api_probe_bind_phone_rt():
    """批量绑手机拿RT：对「跳过手机注册」产出的 phonePending（有CK、无RT）账号，
    用邮箱+固定密码重新登录（路径A）→ 需要手机则走现有 smsbower 多国轮试 → codex 授权换独立 RT。
    与 /api/probe/refetch-rt 共用 _run_refetch_batch，仅目标筛选与日志用词不同：
      - 传了 ids/emails：绑手机指定账号（尊重人工选择）；
      - 未传：自动挑库里所有「phonePending 且无 RT」的账号。
    成功后 _run_refetch_batch 会写 RT/clientId、SUB=是、并清 phonePending。"""
    body = request.get_json(silent=True) or {}
    ids = body.get("ids") or []
    emails = body.get("emails") or []
    try:
        threads = max(1, min(int(body.get("threads") or 3), 5))
    except (TypeError, ValueError):
        threads = 3
    with _reg_lock:
        if _reg_state["running"]:
            return jsonify({"error": "已有注册/重拿/绑机任务正在进行，请稍后"}), 409
    items = load_probe()
    idset = {str(x) for x in ids}
    emset = {str(x).lower() for x in emails}
    if idset or emset:
        picked = [a for a in items
                  if str(a.get("id")) in idset or str(a.get("email", "")).lower() in emset]
    else:
        picked = [a for a in items
                  if a.get("phonePending") and not str(a.get("refreshToken") or "").strip()]
    # 绑手机拿RT 必须有邮箱+密码才能重登；过滤掉缺密码的（避免白跑）。
    picked = [a for a in picked if a.get("email") and str(a.get("password") or "").strip()]
    if not picked:
        return jsonify({"error": "没有可绑手机的账号（需 待绑手机/无RT 且有邮箱密码）"}), 400
    threading.Thread(target=_run_refetch_batch, args=(picked, threads, "绑机拿RT"),
                     name="bindphone-batch", daemon=True).start()
    return jsonify({"started": len(picked)})


@bp.get("/api/reg/status")
def api_reg_status():
    mb = load_mailbox()
    unused = sum(1 for e in mb.get("entries", []) if not e.get("used") and e.get("credential"))
    with _reg_lock:
        return jsonify({
            "running": _reg_state["running"],
            "total": _reg_state["total"],
            "done": _reg_state["done"],
            "ok": _reg_state["ok"],
            "fail": _reg_state["fail"],
            "logs": list(_reg_state["logs"][-200:]),
            "unused": unused,
            "finishedAt": _reg_state["finished_at"],
        })


@bp.post("/api/reg/stop")
def api_reg_stop():
    with _reg_lock:
        if not _reg_state["running"]:
            return jsonify({"ok": True})
        _reg_state["stop"] = True
    _reg_log("warn", "收到停止请求，将在当前进行中的账号完成后结束（不再领取新邮箱）")
    return jsonify({"ok": True})


@bp.post("/api/reg/logs/clear")
def api_reg_logs_clear():
    """清空注册日志缓冲（前端点“清空”时调用，后端也一并清掉，避免下次恢复浮层又灌回旧日志）。"""
    with _reg_lock:
        _reg_state["logs"].clear()
    return jsonify({"ok": True})


@bp.get("/api/reg/inbox")
def api_reg_inbox():
    """供 reg_runner 回读邮箱验证码：按 email 在邮箱池查凭证并读信。"""
    email = (request.args.get("email") or "").strip()
    if not email:
        return jsonify({"messages": []})
    mb = load_mailbox()
    e = next((x for x in mb.get("entries", []) if x.get("email", "").lower() == email.lower()), None)
    if not e or not e.get("credential"):
        return jsonify({"messages": [], "error": "邮箱不在池中或缺少凭证"})
    try:
        msgs = _mailbox_messages(email, e.get("credential", ""), 15)
        return jsonify({"messages": msgs})
    except Exception as exc:  # noqa: BLE001
        return jsonify({"messages": [], "error": f"{type(exc).__name__}: {exc}"})


# ---------- POST /api/plus/export（批量导出 SUB2API 格式）----------
# Export = 返回与 Node 批量导出一致的 SUB2API JSON。默认导出选中且已有 codexRt 的账号。
@bp.post("/api/plus/export")
def api_plus_export():
    body = request.get_json(silent=True) or {}
    emails = body.get("emails")
    items = load_plus()
    if emails:
        target_set = {str(e).lower() for e in emails}
        base = [a for a in items if a.get("email", "").lower() in target_set]
    else:
        base = items
    with_rt = [a for a in base if isinstance(a.get("codexRt"), str) and a.get("codexRt")]

    accounts = []
    for a in with_rt:
        credentials = {
            "refresh_token": a.get("codexRt"),
            "client_id": a.get("codexClientId") or SUB2API_DEFAULT_CLIENT_ID,
            "email": a.get("email"),
        }
        if a.get("codexAccessToken"):
            credentials["access_token"] = a.get("codexAccessToken")
        if a.get("codexIdToken"):
            credentials["id_token"] = a.get("codexIdToken")
        accounts.append({
            "name": a.get("email"),
            "platform": "openai",
            "type": "oauth",
            "credentials": credentials,
            "extra": {"email": a.get("email")},
            "concurrency": 1,
            "priority": 1,
            "rate_multiplier": 1,
            "auto_pause_on_expired": True,
        })

    payload = {
        "type": "sub2api-data",
        "version": 1,
        "exported_at": time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime()),
        "proxies": [],
        "accounts": accounts,
    }
    ts = time.strftime("%Y-%m-%dT%H-%M-%S", time.gmtime())
    filename = f"sub2api_export_{ts}.json"
    return Response(
        json.dumps(payload, ensure_ascii=False, indent=2),
        mimetype="application/json",
        headers={"Content-Disposition": f'attachment; filename="{filename}"',
                 "X-Export-Count": str(len(accounts))},
    )


# ==========================================================================
# GPT 账号管理（probe / sub2api）—— 从 auto probe.js + server.js 的 /api/probe/accounts
# 组忠实移植。数据存储：card-binding/data/probe_accounts.json。
# TOKEN 刷新是对 https://auth.openai.com/oauth/token 的普通表单 POST（无 sentinel/PoW），
# 因此用 httpx 在 Python 里原样复刻，并可经代理池转发（应对区域限制）。
# ==========================================================================
PROBE_FILE = DATA_DIR / "probe_accounts.json"
OPENAI_TOKEN_URL = "https://auth.openai.com/oauth/token"
OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
OPENAI_SCOPE = "openid profile email offline_access"
CHROME_UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
             "(KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36")
PROBE_TOKEN_NEAR_EXP_SEC = 24 * 3600  # 临近过期阈值：1 天

_probe_lock = threading.RLock()
_probe_rr = {"i": 0}  # 代理池 round-robin 游标

# 自动刷新运行态（mirror server.js 的 probeTokenAuto）
_probe_auto = {"running": False, "lastRunAt": 0, "lastResult": None}
_probe_auto_lock = threading.RLock()
_probe_auto_wake = threading.Event()

# 批量检测运行态（≤5 线程并发跑实时套餐校验）
_probe_detect = {"running": False, "total": 0, "done": 0, "ok": 0, "fail": 0, "startedAt": 0, "finishedAt": 0}
_probe_detect_lock = threading.RLock()


def load_probe() -> list:
    with _probe_lock:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        if not PROBE_FILE.exists():
            return []
        try:
            data = json.loads(PROBE_FILE.read_text(encoding="utf-8"))
            if not isinstance(data, list):
                return []
        except Exception:
            return []
    # 兜底补 id：历史/注册落库的记录可能缺 id，导致前端按 id 查不到而无法编辑/复制。
    changed = False
    for a in data:
        if isinstance(a, dict) and not a.get("id"):
            a["id"] = str(uuid.uuid4())
            changed = True
    if changed:
        save_probe(data)
    return data


def save_probe(items: list) -> None:
    with _probe_lock:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        PROBE_FILE.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")


def save_settings(data: dict) -> None:
    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
    SETTINGS_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


# ---------- 邮箱池（email----专用密码 / email----取件API链接）----------
def load_mailbox() -> dict:
    try:
        data = json.loads(MAILBOX_FILE.read_text(encoding="utf-8"))
    except Exception:
        data = {}
    if not isinstance(data, dict):
        return {"split": False, "entries": []}
    entries = data.get("entries")
    return {
        "split": bool(data.get("split")),
        "entries": entries if isinstance(entries, list) else [],
    }


def save_mailbox(data: dict) -> None:
    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
    MAILBOX_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


def parse_mailbox_lines(text: str) -> list:
    """每行 email----credential；credential 为 http(s) 链接则视为取件 API，否则为 IMAP 专用密码。"""
    out: list = []
    seen: set = set()
    for raw in str(text or "").split("\n"):
        line = raw.replace("\r", "").strip()
        if not line:
            continue
        if "----" in line:
            parts = line.split("----", 1)
        elif "\t" in line:
            parts = line.split("\t", 1)
        elif "|" in line:
            parts = line.split("|", 1)
        else:
            parts = re.split(r"\s+", line, maxsplit=1)
        if len(parts) < 2:
            continue
        email = parts[0].strip()
        cred = parts[1].strip()
        if not _EMAIL_RE.match(email) or not cred:
            continue
        key = email.lower()
        if key in seen:
            continue
        seen.add(key)
        typ = "api" if re.match(r"^https?://", cred, re.I) else "imap"
        out.append({"email": email, "credential": cred, "type": typ, "used": False})
    return out


def merge_mailbox_entries(existing: list, parsed: list) -> tuple:
    """把 parsed 合并进 existing：已存在的邮箱更新凭证但保留 used 状态；新邮箱追加(used=False)。"""
    by_email = {e.get("email", "").lower(): e for e in existing}
    added = 0
    for item in parsed:
        key = item["email"].lower()
        cur = by_email.get(key)
        if cur:
            cur["credential"] = item["credential"]
            cur["type"] = item["type"]
        else:
            existing.append(item)
            by_email[key] = item
            added += 1
    return existing, added


def _mailbox_public(e: dict) -> dict:
    return {
        "email": e.get("email", ""),
        "type": e.get("type", "imap"),
        "used": bool(e.get("used")),
        "credential": e.get("credential", ""),
    }


def _mailbox_to_line(e: dict) -> str:
    return f"{e.get('email', '')}----{e.get('credential', '')}"


_IMAP_HOSTS = {
    "icloud.com": "imap.mail.me.com",
    "me.com": "imap.mail.me.com",
    "mac.com": "imap.mail.me.com",
    "gmail.com": "imap.gmail.com",
    "googlemail.com": "imap.gmail.com",
    "outlook.com": "outlook.office365.com",
    "hotmail.com": "outlook.office365.com",
    "live.com": "outlook.office365.com",
}


def _imap_host_for(email: str) -> str:
    dom = email.rsplit("@", 1)[-1].lower()
    return _IMAP_HOSTS.get(dom, "imap." + dom)


def _extract_code(text: str) -> str:
    s = str(text or "")
    # OpenAI 验证码固定 6 位，优先匹配独立的 6 位数字（避免误取年份/金额等）
    m = re.search(r"(?<!\d)(\d{6})(?!\d)", s)
    if m:
        return m.group(1)
    # 退回 4-8 位，但跳过明显的 4 位年份
    for mm in re.finditer(r"(?<!\d)(\d{4,8})(?!\d)", s):
        val = mm.group(1)
        if len(val) == 4 and 1990 <= int(val) <= 2100:
            continue
        return val
    return ""


def _strip_html_text(html: str) -> str:
    """去掉 style/script/标签，得到可见正文，用于提取验证码。"""
    s = re.sub(r"<style[^>]*>.*?</style>", " ", str(html or ""), flags=re.S | re.I)
    s = re.sub(r"<script[^>]*>.*?</script>", " ", s, flags=re.S | re.I)
    s = re.sub(r"<[^>]+>", " ", s)
    s = re.sub(r"&nbsp;|&amp;|&zwnj;|&#\d+;", " ", s)
    return re.sub(r"\s+", " ", s).strip()


def _clean_header_text(s: str) -> str:
    """清理发件人/主题/日期等短字段：解码常见实体并折叠空白，
    但保留形如 <addr@domain> 的邮箱地址（不当作 HTML 标签删除）。"""
    t = str(s or "")
    t = t.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
    t = re.sub(r"&nbsp;|&zwnj;|&#\d+;", " ", t)
    return re.sub(r"\s+", " ", t).strip()


def _parse_api_mailbox_html(html: str, limit: int = 15) -> list:
    """解析第三方取件 API 返回的 HTML（icloud-api.top 等）为逐封邮件记录。
    页面结构：每封邮件为一个 <div class="card">，内含 .fr(发件人)/.su(主题)/.dt(日期)/.bd(正文)。
    返回 get-rt.js 期望的形状：[{from_addr, subject, body, received_at(ISO), extracted_code}]。"""
    from email.utils import parsedate_to_datetime

    text = str(html or "")
    chunks = text.split('<div class="card">')[1:]
    out: list = []
    for ch in chunks[:limit]:
        frm_m = re.search(r'<div class="fr">(.*?)</div>', ch, re.S)
        su_m = re.search(r'<div class="su">(.*?)</div>', ch, re.S)
        dt_m = re.search(r'<div class="dt">(.*?)</div>', ch, re.S)
        bd_m = re.search(r'<div class="bd">(.*)$', ch, re.S)
        frm = _clean_header_text(frm_m.group(1)) if frm_m else ""
        subject = _clean_header_text(su_m.group(1)) if su_m else ""
        raw_date = _clean_header_text(dt_m.group(1)) if dt_m else ""
        body = _strip_html_text(bd_m.group(1)) if bd_m else ""
        try:
            dt = parsedate_to_datetime(raw_date)
            recv_iso = dt.isoformat() if dt else raw_date
        except Exception:
            recv_iso = raw_date
        code = _extract_code(subject) or _extract_code(body)
        out.append({
            "from_addr": frm,
            "subject": subject,
            "body": body,
            "received_at": recv_iso,
            "extracted_code": code,
        })
    # 无 card 结构时退回整页扫描（尽量仍可取到码）
    if not out:
        clean = _strip_html_text(text)
        code = _extract_code(clean)
        if clean:
            out.append({
                "from_addr": "",
                "subject": clean[:120],
                "body": clean,
                "received_at": "",
                "extracted_code": code,
            })
    return out


def _msg_text(msg) -> str:
    parts: list = []
    try:
        walk = msg.walk() if msg.is_multipart() else [msg]
        for p in walk:
            if p.get_content_type() not in ("text/plain", "text/html"):
                continue
            try:
                payload = p.get_payload(decode=True)
                if payload:
                    parts.append(payload.decode(p.get_content_charset() or "utf-8", "replace"))
            except Exception:
                continue
    except Exception:
        pass
    return "\n".join(parts)


def _mailbox_test_imap(email: str, credential: str, limit: int = 5) -> dict:
    import imaplib
    import email as emaillib
    from email.header import decode_header, make_header

    host = _imap_host_for(email)
    M = imaplib.IMAP4_SSL(host, 993, timeout=20)
    try:
        M.login(email, credential.replace(" ", ""))
        M.select("INBOX", readonly=True)
        typ, data = M.search(None, "ALL")
        ids = data[0].split() if data and data[0] else []
        ids = ids[-limit:][::-1]
        messages: list = []
        for i in ids:
            # iCloud 对 (RFC822) 返回空，需用 BODY.PEEK[]（且不置 \Seen 标记）
            typ, md = M.fetch(i, "(BODY.PEEK[])")
            if typ != "OK" or not md:
                continue
            raw = next((p[1] for p in md if isinstance(p, tuple) and len(p) >= 2 and p[1]), None)
            if not raw:
                continue
            msg = emaillib.message_from_bytes(raw)
            try:
                subject = str(make_header(decode_header(msg.get("Subject", ""))))
            except Exception:
                subject = msg.get("Subject", "")
            try:
                frm = str(make_header(decode_header(msg.get("From", ""))))
            except Exception:
                frm = msg.get("From", "")
            body = _msg_text(msg)
            code = _extract_code(subject) or _extract_code(re.sub(r"<[^>]+>", " ", body))
            messages.append({
                "from": frm,
                "subject": subject,
                "date": msg.get("Date", ""),
                "code": code,
            })
        return {"ok": True, "type": "imap", "host": host, "count": len(messages), "messages": messages}
    finally:
        try:
            M.logout()
        except Exception:
            pass


def _mailbox_test_api(email: str, url: str) -> dict:
    if httpx is None:
        raise RuntimeError("httpx 不可用，无法请求取件 API")
    r = httpx.get(url, timeout=25, follow_redirects=True)
    parsed = _parse_api_mailbox_html(r.text or "", 15)
    # 展示层：优先展示 OpenAI/ChatGPT 验证码那封
    def _score(m):
        blob = f"{m.get('from_addr','')} {m.get('subject','')}".lower()
        s = 0
        if "openai" in blob or "chatgpt" in blob:
            s += 2
        if "verification" in blob or "验证" in blob:
            s += 1
        return s
    best = sorted(parsed, key=_score, reverse=True)[0] if parsed else None
    return {
        "ok": r.status_code == 200,
        "type": "api",
        "status": r.status_code,
        "code": (best or {}).get("extracted_code", ""),
        "count": len(parsed),
        "messages": [{
            "from": m.get("from_addr", ""),
            "subject": m.get("subject", "")[:200],
            "date": m.get("received_at", ""),
            "code": m.get("extracted_code", ""),
        } for m in parsed],
    }


def _decode_header(v: str) -> str:
    from email.header import decode_header, make_header
    try:
        return str(make_header(decode_header(v or "")))
    except Exception:
        return str(v or "")


def _mailbox_messages(email: str, credential: str, limit: int = 15) -> list:
    """读取邮箱最新邮件，返回 get-rt.js 期望的形状：
    [{from_addr, subject, body, received_at(ISO), extracted_code}]。"""
    if re.match(r"^https?://", credential, re.I):
        if httpx is None:
            return []
        try:
            r = httpx.get(credential, timeout=25, follow_redirects=True)
        except Exception:
            return []
        return _parse_api_mailbox_html(r.text or "", limit)

    import imaplib
    import email as emaillib
    from email.utils import parsedate_to_datetime

    host = _imap_host_for(email)
    M = imaplib.IMAP4_SSL(host, 993, timeout=20)
    try:
        M.login(email, credential.replace(" ", ""))
        M.select("INBOX", readonly=True)
        typ, data = M.search(None, "ALL")
        ids = (data[0].split() if data and data[0] else [])[-limit:][::-1]
        msgs: list = []
        for i in ids:
            typ, md = M.fetch(i, "(BODY.PEEK[])")
            raw = None
            if typ == "OK" and md:
                raw = next((p[1] for p in md if isinstance(p, tuple) and len(p) >= 2 and p[1]), None)
            if not raw:
                continue
            m = emaillib.message_from_bytes(raw)
            subject = _decode_header(m.get("Subject", ""))
            frm = _decode_header(m.get("From", ""))
            body = _msg_text(m)
            recv = m.get("Date", "")
            try:
                dt = parsedate_to_datetime(recv)
                recv_iso = dt.isoformat() if dt else recv
            except Exception:
                recv_iso = recv
            code = _extract_code(subject) or _extract_code(re.sub(r"<[^>]+>", " ", body))
            msgs.append({
                "from_addr": frm,
                "subject": subject,
                "body": body,
                "received_at": recv_iso,
                "extracted_code": code,
            })
        return msgs
    finally:
        try:
            M.logout()
        except Exception:
            pass


def _clamp_int(v, lo, hi, default):
    try:
        n = int(round(float(v)))
    except (TypeError, ValueError):
        return default
    return max(lo, min(hi, n))


# ---------- sub2api 解析：兼容 JSON 与 email----password----clientId----refreshToken 行格式 ----------
def parse_sub2api(raw) -> list:
    text = raw if isinstance(raw, str) else json.dumps(raw)
    text = str(text or "").strip()
    if not text:
        return []
    # 1) 优先尝试 sub2api JSON（导出文件 / 账号数组）
    obj = None
    try:
        obj = json.loads(text)
    except Exception:
        obj = None
    if obj is not None:
        if isinstance(obj, list):
            arr = obj
        elif isinstance(obj, dict) and isinstance(obj.get("accounts"), list):
            arr = obj["accounts"]
        else:
            arr = []
        out = []
        for a in arr:
            if not isinstance(a, dict):
                continue
            cred = a.get("credentials") or a.get("creds") or {}
            extra = a.get("extra") or {}
            email = a.get("name") or a.get("email") or extra.get("email") or ""
            access_token = cred.get("access_token") or a.get("access_token") or ""
            refresh_token = cred.get("refresh_token") or a.get("refresh_token") or ""
            if not email and not access_token and not refresh_token:
                continue
            out.append({
                "email": str(email or "").strip(),
                "password": str(cred.get("password") or a.get("password") or ""),
                "accessToken": str(access_token or ""),
                "refreshToken": str(refresh_token or ""),
                "clientId": str(cred.get("client_id") or a.get("client_id") or ""),
                "chatgptAccountId": str(cred.get("chatgpt_account_id") or a.get("chatgpt_account_id") or ""),
                "planType": str(a.get("plan_type") or cred.get("plan_type") or ""),
            })
        return out
    # 2) 行格式（非 JSON）——逐行自动识别：
    #    含分隔符(---- / tab / |)且 >=4 段 → email----password----clientId----refreshToken；
    #    否则整行视为一个裸 access token（仅 accessToken，其余留空）。
    out = []
    seen = set()

    def _dedupe_key(email, at, rt):
        if email:
            return "email:" + email.lower()
        if at:
            return "at:" + at
        if rt:
            return "rt:" + rt
        return ""

    def _add(email, password, client_id, refresh_token, access_token):
        key = _dedupe_key(email, access_token, refresh_token)
        if not key or key in seen:
            return
        seen.add(key)
        out.append({
            "email": email,
            "password": password,
            "clientId": client_id,
            "refreshToken": refresh_token,
            "accessToken": access_token,
            "chatgptAccountId": "",
            "planType": "",
        })

    for raw_line in text.split("\n"):
        line = raw_line.replace("\r", "").strip()
        if not line:
            continue
        delim = "----" if "----" in line else ("\t" if "\t" in line else ("|" if "|" in line else None))
        if delim is not None:
            parts = [s.strip() for s in line.split(delim) if s.strip()]
            if len(parts) >= 4 and _EMAIL_RE.match(parts[0]):
                _add(parts[0], parts[1], parts[2], parts[3], "")
            # 分隔符行但字段不足/首列非邮箱 → 视为非法，跳过
            continue
        # 无分隔符：可能是空白分隔的 4 字段，或裸 access token
        ws = [s for s in re.split(r"\s+", line) if s]
        if len(ws) >= 4 and _EMAIL_RE.match(ws[0]):
            _add(ws[0], ws[1], ws[2], ws[3], "")
        else:
            # 裸 AT：JWT 不含空白，取整行作为 accessToken
            _add("", "", "", "", ws[0] if len(ws) == 1 else line)
    return out


# ---------- JWT / 账号派生 ----------
def decode_jwt_payload(token: str):
    try:
        parts = str(token or "").split(".")
        if len(parts) < 2:
            return None
        seg = parts[1].replace("-", "+").replace("_", "/")
        seg += "=" * ((4 - len(seg) % 4) % 4)
        data = json.loads(base64.b64decode(seg).decode("utf-8", "replace"))
        return data if isinstance(data, dict) else None
    except Exception:
        return None


def enrich_probe_account(acc: dict) -> dict:
    a = acc or {}
    payload = decode_jwt_payload(a.get("accessToken")) or {}
    auth = payload.get("https://api.openai.com/auth") or {}
    plan_raw = str(auth.get("chatgpt_plan_type") or "").strip()
    # 实时 accounts/check 检测得到的套餐(livePlanType / 存储的 planType)权威;
    # JWT 里的 chatgpt_plan_type 常年过期(PLUS 账号也可能显示 free),仅作兜底。
    effective_plan = str(a.get("livePlanType") or a.get("planType") or "").strip() or plan_raw
    exp = int(payload.get("exp") or 0) if payload else 0
    now = int(time.time())
    stored = a.get("status") if a.get("status") in ("valid", "invalid", "unknown") else "unknown"
    token_expired = (exp <= now) if exp else None
    remaining = (exp - now) if exp else None
    # 展示状态：ok / expiring / invalid / unknown（源于 JWT exp，尊重刷新失败标记的 invalid）
    if stored == "invalid":
        display = "invalid"
    elif exp:
        display = "ok" if remaining > PROBE_TOKEN_NEAR_EXP_SEC else "expiring"
    elif stored == "valid":
        display = "ok"
    else:
        display = "unknown"
    return {
        "id": a.get("id"),
        "email": a.get("email") or "",
        "password": a.get("password") or "",
        "twoFactorSecret": a.get("twoFactorSecret") or "",
        "accessToken": a.get("accessToken") or "",
        "refreshToken": a.get("refreshToken") or "",
        "clientId": a.get("clientId") or "",
        "chatgptAccountId": a.get("chatgptAccountId") or auth.get("chatgpt_account_id") or "",
        "planType": effective_plan or "unknown",
        "planLabel": effective_plan.upper() if effective_plan else "未知",
        "tokenExp": exp,
        "tokenExpired": token_expired,
        "tokenExpiresInSec": remaining,
        "status": display,
        "rawStatus": stored,
        "hasAccess": bool(a.get("accessToken")),
        "hasRefresh": bool(a.get("refreshToken")),
        # SUB / sub2api 第二阶段授权是否成功（用于账号列表的"SUB"列）
        "subOk": bool(a.get("subOk")),
        # 批量直开(card-flow)开通成功的标记（pool-mark-opened 写入）
        "opened": bool(a.get("opened")),
        "activatedAt": a.get("activatedAt"),
        "note": a.get("note") or "",
        "lastCheckedAt": a.get("lastCheckedAt") or 0,
        "createdAt": a.get("createdAt") or 0,
    }


# ---------- 代理：从池里取一个（round-robin），转成 httpx 代理 URL ----------
def _proxy_url_from(proxy: dict):
    if not proxy or not proxy.get("host") or not proxy.get("port"):
        return None
    user = proxy.get("username")
    if user:
        from urllib.parse import quote as _q
        auth = f"{_q(str(user))}:{_q(str(proxy.get('password') or ''))}@"
    else:
        auth = ""
    return f"http://{auth}{proxy['host']}:{proxy['port']}"


def _pick_proxy_url():
    proxies = load_proxies()
    ok = [p for p in proxies if p.get("status") == "ok"]
    pool = ok if ok else proxies
    if not pool:
        return None
    with _probe_lock:
        idx = _probe_rr["i"] % len(pool)
        _probe_rr["i"] += 1
    return _proxy_url_from(pool[idx])


# ---------- 核心：refresh_token 换 access_token（普通 HTTPS，忠实复刻 probe.js refreshOpenAiTokens）----------
def refresh_openai_tokens(refresh_token: str, proxy_url: str | None = None) -> dict:
    if not refresh_token:
        return {"ok": False, "accessToken": "", "refreshToken": "", "error": "missing_refresh_token", "httpStatus": 0}
    if httpx is None:
        return {"ok": False, "accessToken": "", "refreshToken": "", "error": "httpx_unavailable", "httpStatus": 0}
    data = {
        "grant_type": "refresh_token",
        "client_id": OPENAI_CLIENT_ID,
        "refresh_token": refresh_token,
        "scope": OPENAI_SCOPE,
    }
    headers = {"content-type": "application/x-www-form-urlencoded", "user-agent": CHROME_UA}
    try:
        client_kwargs = {"timeout": 30.0, "headers": headers}
        if proxy_url:
            client_kwargs["proxy"] = proxy_url
        with httpx.Client(**client_kwargs) as client:
            r = client.post(OPENAI_TOKEN_URL, data=data)
        try:
            body = r.json()
        except Exception:
            body = {}
        if r.status_code == 200 and body.get("access_token"):
            return {
                "ok": True,
                "accessToken": str(body.get("access_token") or ""),
                "refreshToken": str(body.get("refresh_token") or refresh_token or ""),
                "error": "",
                "httpStatus": r.status_code,
            }
        err = str(body.get("error") or body.get("error_description") or f"HTTP {r.status_code}")
        return {"ok": False, "accessToken": "", "refreshToken": "", "error": err, "httpStatus": r.status_code}
    except Exception as exc:  # noqa: BLE001
        return {"ok": False, "accessToken": "", "refreshToken": "", "error": str(exc), "httpStatus": 0}


def _refresh_with_fallback(refresh_token: str) -> dict:
    """先经代理池刷新；若因区域被 403(unsupported_country...) 拦截，则直连再试一次。
    auto 原实现是直连（无代理），这里保留“代理池优先 + 直连兜底”以兼顾区域限制。"""
    proxy_url = _pick_proxy_url()
    r = refresh_openai_tokens(refresh_token, proxy_url)
    if (not r.get("ok")) and proxy_url and r.get("httpStatus") == 403 \
            and re.search(r"unsupported_country|region|territory", r.get("error") or "", re.I):
        r2 = refresh_openai_tokens(refresh_token, None)  # 直连兜底
        if r2.get("ok") or r2.get("httpStatus") not in (0, 403):
            return r2
    return r


# ---------- 实时套餐校验：用 access_token 调 accounts/check（curl_cffi 子进程）----------
def _plan_check_once(access_token: str, account_id: str, proxy_url: str | None) -> dict:
    payload = {"access_token": access_token, "account_id": account_id or "", "proxy": proxy_url or "DIRECT"}
    try:
        proc = subprocess.run(
            [PY_BIN, PLAN_CHECK_SCRIPT],
            input=json.dumps(payload),
            capture_output=True,
            text=True,
            encoding="utf-8",
            cwd=str(ROOT),
            timeout=90,
        )
    except FileNotFoundError:
        return {"ok": False, "httpStatus": 0, "error": f"未找到 Python 解释器：{PY_BIN}"}
    except subprocess.TimeoutExpired:
        return {"ok": False, "httpStatus": 0, "error": "套餐校验超时"}
    out = (proc.stdout or "").strip()
    if not out:
        return {"ok": False, "httpStatus": 0, "error": (proc.stderr or "no output")[:300]}
    try:
        return json.loads(out.splitlines()[-1])
    except Exception:
        return {"ok": False, "httpStatus": 0, "error": out[:300]}


def _live_plan_check(access_token: str, account_id: str) -> dict:
    """先经代理池校验；若区域 403 被拦，直连兜底再试一次。"""
    proxy_url = _pick_proxy_url()
    r = _plan_check_once(access_token, account_id, proxy_url)
    if (not r.get("ok")) and proxy_url and (
        r.get("httpStatus") in (403, 0)
        or re.search(r"unsupported_country|region|territory", str(r.get("error") or ""), re.I)
    ):
        r2 = _plan_check_once(access_token, account_id, None)  # 直连兜底
        if r2.get("ok"):
            return r2
    return r


def _refresh_probe_by_id(acc_id: str) -> dict:
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == str(acc_id)), None)
        if not acc:
            return {"ok": False, "notFound": True, "error": "账号不存在"}
        if not acc.get("refreshToken"):
            acc["status"] = "invalid"
            acc["lastCheckedAt"] = int(time.time() * 1000)
            save_probe(items)
            return {"ok": False, "error": "缺少 refreshToken", "account": enrich_probe_account(acc)}
        rt = acc["refreshToken"]
    r = _refresh_with_fallback(rt)
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == str(acc_id)), None)
        if not acc:
            return {"ok": False, "notFound": True, "error": "账号不存在"}
        acc["lastCheckedAt"] = int(time.time() * 1000)
        if r.get("ok") and r.get("accessToken"):
            acc["accessToken"] = r["accessToken"]
            if r.get("refreshToken"):
                acc["refreshToken"] = r["refreshToken"]
            acc["status"] = "valid"
            save_probe(items)
            return {"ok": True, "account": enrich_probe_account(acc)}
        invalid = r.get("httpStatus") == 401 or re.search(r"invalid_grant|invalid_token|unauthorized", r.get("error") or "", re.I)
        acc["status"] = "invalid" if invalid else (acc.get("status") or "unknown")
        save_probe(items)
        return {"ok": False, "error": r.get("error") or "refresh_failed",
                "httpStatus": r.get("httpStatus"), "account": enrich_probe_account(acc)}


def _run_probe_auto_refresh() -> dict:
    with _probe_auto_lock:
        if _probe_auto["running"]:
            return _probe_auto["lastResult"]
        _probe_auto["running"] = True
    summary = {"scanned": 0, "refreshed": 0, "skipped": 0, "failed": 0, "invalid": 0}
    try:
        snapshot = load_probe()
        now = int(time.time())
        summary["scanned"] = len(snapshot)
        updates: dict = {}  # id -> 待写回字段（仅按 id 合并，避免覆盖并发删除/编辑）
        for acc in snapshot:
            try:
                if not acc.get("refreshToken"):
                    summary["skipped"] += 1
                    continue
                payload = decode_jwt_payload(acc.get("accessToken"))
                exp = int(payload.get("exp") or 0) if payload else 0
                status = str(acc.get("status") or "unknown")
                need = status == "unknown" or not exp or exp <= now + PROBE_TOKEN_NEAR_EXP_SEC
                if not need:
                    summary["skipped"] += 1
                    continue
                r = _refresh_with_fallback(acc["refreshToken"])
                upd = {"lastCheckedAt": int(time.time() * 1000)}
                if r.get("ok") and r.get("accessToken"):
                    upd["accessToken"] = r["accessToken"]
                    if r.get("refreshToken"):
                        upd["refreshToken"] = r["refreshToken"]
                    upd["status"] = "valid"
                    summary["refreshed"] += 1
                else:
                    invalid = r.get("httpStatus") == 401 or re.search(r"invalid_grant|invalid_token|unauthorized", r.get("error") or "", re.I)
                    if invalid:
                        upd["status"] = "invalid"
                        summary["invalid"] += 1
                    else:
                        summary["failed"] += 1
                updates[str(acc.get("id"))] = upd
            except Exception:
                summary["failed"] += 1
        # 按 id 合并写回当前存储（重新加载，跳过期间已被删除的账号）
        with _probe_lock:
            items = load_probe()
            by_id = {str(a.get("id")): a for a in items}
            for acc_id, upd in updates.items():
                target = by_id.get(acc_id)
                if target is not None:
                    target.update(upd)
            save_probe(items)
        with _probe_auto_lock:
            _probe_auto["lastRunAt"] = int(time.time() * 1000)
            _probe_auto["lastResult"] = summary
        return summary
    finally:
        with _probe_auto_lock:
            _probe_auto["running"] = False


def _auto_refresh_state() -> dict:
    s = load_settings()
    with _probe_auto_lock:
        return {
            "enabled": s.get("probeTokenAutoRefresh", True) is not False,
            "intervalMin": _clamp_int(s.get("probeTokenAutoRefreshMin"), 5, 1440, 15),
            "lastRunAt": _probe_auto["lastRunAt"],
            "lastResult": _probe_auto["lastResult"],
            "running": _probe_auto["running"],
        }


def _auto_refresh_loop():
    time.sleep(8)  # 启动后稍晚跑一轮，避免拖慢 listen（对齐 auto）
    while True:
        try:
            state = _auto_refresh_state()
            if state["enabled"]:
                _run_probe_auto_refresh()
            interval = _auto_refresh_state()["intervalMin"]
        except Exception:
            interval = 15
        _probe_auto_wake.wait(timeout=interval * 60)
        _probe_auto_wake.clear()


# ---------- GET /api/probe/accounts ----------
@bp.get("/api/probe/accounts")
def api_probe_list():
    items = load_probe()
    return jsonify({
        "accounts": [enrich_probe_account(a) for a in items],
        "autoRefresh": _auto_refresh_state(),
    })


# ---------- POST /api/probe/accounts/import ----------
@bp.post("/api/probe/accounts/import")
def api_probe_import():
    body = request.get_json(silent=True) or {}
    parsed = parse_sub2api(body.get("text") or "")
    with _probe_lock:
        items = load_probe()
        by_email = {str(a.get("email") or "").lower(): a for a in items if a.get("email")}
        by_at = {str(a.get("accessToken")): a for a in items if a.get("accessToken")}
        by_rt = {str(a.get("refreshToken")): a for a in items if a.get("refreshToken")}
        added = 0
        updated = 0
        for item in parsed:
            key = str(item.get("email") or "").lower()
            # 有邮箱按邮箱去重；无邮箱(裸AT/仅RT)按 accessToken / refreshToken 去重
            existing = by_email.get(key) if key else None
            if existing is None and not key:
                if item.get("accessToken"):
                    existing = by_at.get(str(item.get("accessToken")))
                if existing is None and item.get("refreshToken"):
                    existing = by_rt.get(str(item.get("refreshToken")))
            if existing:
                existing["accessToken"] = item.get("accessToken") or existing.get("accessToken") or ""
                existing["refreshToken"] = item.get("refreshToken") or existing.get("refreshToken") or ""
                if item.get("password"):
                    existing["password"] = item["password"]
                if item.get("clientId"):
                    existing["clientId"] = item["clientId"]
                existing["chatgptAccountId"] = item.get("chatgptAccountId") or existing.get("chatgptAccountId") or ""
                existing["planType"] = item.get("planType") or existing.get("planType") or ""
                existing["status"] = "unknown"
                existing["lastCheckedAt"] = 0
                updated += 1
            else:
                rec = {
                    "id": str(uuid.uuid4()),
                    "email": item.get("email") or "",
                    "password": item.get("password") or "",
                    "clientId": item.get("clientId") or "",
                    "refreshToken": item.get("refreshToken") or "",
                    "accessToken": item.get("accessToken") or "",
                    "chatgptAccountId": item.get("chatgptAccountId") or "",
                    "planType": item.get("planType") or "",
                    "note": "",
                    "status": "unknown",
                    "lastCheckedAt": 0,
                    "createdAt": int(time.time() * 1000),
                }
                items.append(rec)
                if key:
                    by_email[key] = rec
                if rec.get("accessToken"):
                    by_at[str(rec["accessToken"])] = rec
                if rec.get("refreshToken"):
                    by_rt[str(rec["refreshToken"])] = rec
                added += 1
        save_probe(items)
        total = len(items)
    # 导入后触发未知状态账号的自动刷新（若开启）
    if (added + updated) > 0 and _auto_refresh_state()["enabled"]:
        threading.Thread(target=_run_probe_auto_refresh, name="probe-import-refresh", daemon=True).start()
    return jsonify({"added": added, "updated": updated, "parsed": len(parsed), "total": total})


# ---------- PUT /api/probe/accounts（编辑）----------
@bp.put("/api/probe/accounts")
def api_probe_edit():
    body = request.get_json(silent=True) or {}
    acc_id = str(body.get("id") or "")
    if not acc_id:
        return jsonify({"error": "缺少 id"}), 400
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == acc_id), None)
        if not acc:
            return jsonify({"error": "账号不存在"}), 404
        if body.get("email") is not None:
            acc["email"] = str(body.get("email") or "").strip()
        if body.get("accessToken") is not None:
            acc["accessToken"] = str(body.get("accessToken") or "").strip()
        if body.get("refreshToken") is not None:
            acc["refreshToken"] = str(body.get("refreshToken") or "").strip()
        if body.get("chatgptAccountId") is not None:
            acc["chatgptAccountId"] = str(body.get("chatgptAccountId") or "").strip()
        if body.get("password") is not None:
            acc["password"] = str(body.get("password") or "")
        if body.get("twoFactorSecret") is not None:
            acc["twoFactorSecret"] = str(body.get("twoFactorSecret") or "").strip()
        if body.get("note") is not None:
            acc["note"] = str(body.get("note") or "")
        # 编辑后：可解 JWT 且原为 invalid 则回到 unknown 等待下次校验
        payload = decode_jwt_payload(acc.get("accessToken"))
        if payload and payload.get("exp"):
            acc["status"] = "unknown" if acc.get("status") == "invalid" else (acc.get("status") or "unknown")
        save_probe(items)
        enriched = enrich_probe_account(acc)
    return jsonify({"account": enriched})


# ---------- POST /api/probe/accounts/refresh（刷新一个）----------
@bp.post("/api/probe/accounts/refresh")
def api_probe_refresh():
    body = request.get_json(silent=True) or {}
    acc_id = str(body.get("id") or "")
    if not acc_id:
        return jsonify({"error": "缺少 id"}), 400
    result = _refresh_probe_by_id(acc_id)
    if not result.get("ok") and result.get("notFound"):
        return jsonify({"error": "账号不存在"}), 404
    return jsonify(result)


# ---------- POST /api/probe/accounts/detect（用 access_token 实时查真实套餐 FREE/PLUS/PRO）----------
# 优先实时调用 chatgpt.com/backend-api/accounts/check（curl_cffi 子进程，读 plan_type +
# has_active_subscription）——这是账号“当前真实级别”，而非 AT 内 JWT 的历史标记。
# 若 AT 已过期且有 refreshToken，先刷新拿到最新 AT 再校验；实时校验失败(区域/被拦/无网络)时
# 回退用 AT 内 JWT 字段，并在返回中标注 source=jwt 与失败原因，绝不谎报为实时结果。
@bp.post("/api/probe/accounts/detect")
def api_probe_detect():
    body = request.get_json(silent=True) or {}
    acc_id = str(body.get("id") or "")
    if not acc_id:
        return jsonify({"error": "缺少 id"}), 400
    with _probe_lock:
        acc = next((a for a in load_probe() if str(a.get("id")) == acc_id), None)
        if acc is None:
            return jsonify({"error": "账号不存在"}), 404
        has_rt = bool(acc.get("refreshToken"))
        payload = decode_jwt_payload(acc.get("accessToken"))
        exp = int(payload.get("exp") or 0) if payload else 0
    # AT 过期且有 refreshToken：先刷新，拿到可用于实时校验的最新 AT
    refreshed = False
    if has_rt and (not exp or exp <= int(time.time())):
        refreshed = bool(_refresh_probe_by_id(acc_id).get("ok"))

    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == acc_id), None)
        if acc is None:
            return jsonify({"error": "账号不存在"}), 404
        access_token = str(acc.get("accessToken") or "")
        account_id = str(acc.get("chatgptAccountId") or "")

    if not access_token:
        with _probe_lock:
            items = load_probe()
            acc = next((a for a in items if str(a.get("id")) == acc_id), None)
            pub = enrich_probe_account(acc) if acc else {}
        return jsonify({"ok": False, "error": "缺少 Access Token，无法检测套餐", "account": pub})

    # 实时 accounts/check
    live = _live_plan_check(access_token, account_id)
    if live.get("ok") and (live.get("plan") or live.get("active")):
        plan = str(live.get("plan") or ("plus" if live.get("active") else "")).strip().lower()
        with _probe_lock:
            items = load_probe()
            acc = next((a for a in items if str(a.get("id")) == acc_id), None)
            if acc is None:
                return jsonify({"error": "账号不存在"}), 404
            if plan:
                acc["planType"] = plan
                acc["livePlanType"] = plan  # 实时检测权威值，enrich 优先使用，避免被 JWT/再导入覆盖
            if live.get("accountId") and not acc.get("chatgptAccountId"):
                acc["chatgptAccountId"] = live.get("accountId")
            acc["lastCheckedAt"] = int(time.time() * 1000)
            pub = enrich_probe_account(acc)
            save_probe(items)
        return jsonify({
            "ok": True,
            "source": "live",
            "refreshed": refreshed,
            "active": bool(live.get("active")),
            "planType": pub.get("planType"),
            "planLabel": pub.get("planLabel"),
            "account": pub,
        })

    # 实时失败 → 回退 JWT，如实标注
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == acc_id), None)
        if acc is None:
            return jsonify({"error": "账号不存在"}), 404
        pub = enrich_probe_account(acc)
        acc["planType"] = pub.get("planType")
        acc["lastCheckedAt"] = int(time.time() * 1000)
        save_probe(items)
    reason = str(live.get("error") or "").strip()
    if live.get("httpStatus"):
        reason = f"HTTP {live.get('httpStatus')} {reason}".strip()
    return jsonify({
        "ok": True,
        "source": "jwt",
        "refreshed": refreshed,
        "liveError": reason or "实时校验失败",
        "planType": pub.get("planType"),
        "planLabel": pub.get("planLabel"),
        "account": pub,
    })


# ---------- 批量检测：≤5 线程并发跑实时套餐校验 ----------
def _probe_detect_once(acc_id: str) -> bool:
    """对单个账号跑实时 accounts/check（代理→直连兜底），写回 planType/livePlanType。
    per-account 异常不抛出（由 _safe_detect_one 兜底），返回是否成功检测到套餐。"""
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == str(acc_id)), None)
        if not acc:
            return False
        access_token = str(acc.get("accessToken") or "")
        account_id = str(acc.get("chatgptAccountId") or "")
    if not access_token:
        return False
    live = _live_plan_check(access_token, account_id)  # 不持锁跑子进程，允许并发
    with _probe_lock:
        items = load_probe()
        acc = next((a for a in items if str(a.get("id")) == str(acc_id)), None)
        if not acc:
            return False
        acc["lastCheckedAt"] = int(time.time() * 1000)
        if live.get("ok") and (live.get("plan") or live.get("active")):
            plan = str(live.get("plan") or ("plus" if live.get("active") else "")).strip().lower()
            if plan:
                acc["planType"] = plan
                acc["livePlanType"] = plan
            if live.get("accountId") and not acc.get("chatgptAccountId"):
                acc["chatgptAccountId"] = live.get("accountId")
            save_probe(items)
            return True
        save_probe(items)
        return False


def _safe_detect_one(acc_id: str) -> bool:
    try:
        return _probe_detect_once(acc_id)
    except Exception:
        return False


def _run_probe_detect_batch(ids: list) -> None:
    from concurrent.futures import ThreadPoolExecutor, as_completed
    with _probe_detect_lock:
        _probe_detect.update({"running": True, "total": len(ids), "done": 0, "ok": 0, "fail": 0,
                              "startedAt": int(time.time() * 1000), "finishedAt": 0})
    try:
        with ThreadPoolExecutor(max_workers=5) as ex:
            futs = [ex.submit(_safe_detect_one, i) for i in ids]
            for fut in as_completed(futs):
                ok = False
                try:
                    ok = bool(fut.result())
                except Exception:
                    ok = False
                with _probe_detect_lock:
                    _probe_detect["done"] += 1
                    if ok:
                        _probe_detect["ok"] += 1
                    else:
                        _probe_detect["fail"] += 1
    finally:
        with _probe_detect_lock:
            _probe_detect["running"] = False
            _probe_detect["finishedAt"] = int(time.time() * 1000)


# ---------- POST /api/probe/accounts/detect-batch（选中或全部，≤5 线程）----------
@bp.post("/api/probe/accounts/detect-batch")
def api_probe_detect_batch():
    body = request.get_json(silent=True) or {}
    ids = body.get("ids")
    with _probe_lock:
        items = load_probe()
        if ids:
            idset = {str(x) for x in ids}
            targets = [str(a.get("id")) for a in items if str(a.get("id")) in idset and a.get("accessToken")]
        else:
            targets = [str(a.get("id")) for a in items if a.get("accessToken")]
    with _probe_detect_lock:
        if _probe_detect["running"]:
            return jsonify({"ok": False, "error": "批量检测正在进行中", "status": dict(_probe_detect)}), 409
    if not targets:
        return jsonify({"ok": False, "error": "没有可检测的账号（需有 Access Token）"}), 400
    threading.Thread(target=_run_probe_detect_batch, args=(targets,), name="probe-detect-batch", daemon=True).start()
    return jsonify({"ok": True, "total": len(targets)})


# ---------- GET /api/probe/accounts/detect-batch/status（进度轮询）----------
@bp.get("/api/probe/accounts/detect-batch/status")
def api_probe_detect_batch_status():
    with _probe_detect_lock:
        return jsonify(dict(_probe_detect))


# ---------- GET/POST /api/probe/accounts/auto-refresh（开关 + 间隔）----------
@bp.get("/api/probe/accounts/auto-refresh")
def api_probe_auto_get():
    return jsonify(_auto_refresh_state())


@bp.post("/api/probe/accounts/auto-refresh")
def api_probe_auto_post():
    body = request.get_json(silent=True) or {}
    s = load_settings()
    enabled = body.get("enabled")
    s["probeTokenAutoRefresh"] = enabled is not False and enabled != "false"
    if body.get("intervalMin") is not None:
        s["probeTokenAutoRefreshMin"] = _clamp_int(body.get("intervalMin"), 5, 1440, 15)
    save_settings(s)
    _probe_auto_wake.set()  # 唤醒调度线程，使新配置立即生效
    if body.get("runNow"):
        threading.Thread(target=_run_probe_auto_refresh, name="probe-run-now", daemon=True).start()
    return jsonify(_auto_refresh_state())


# ---------- DELETE /api/probe/accounts（ids / all）----------
@bp.delete("/api/probe/accounts")
def api_probe_delete():
    body = request.get_json(silent=True) or {}
    with _probe_lock:
        items = load_probe()
        before = len(items)
        if body.get("all"):
            items = []
        else:
            ids = {str(i) for i in (body.get("ids") or [])}
            items = [a for a in items if str(a.get("id")) not in ids]
        save_probe(items)
        total = len(items)
    return jsonify({"removed": before - total, "total": total})


# ---------- POST /api/probe/accounts/export-at（批量导出 AT，一行一个）----------
@bp.post("/api/probe/accounts/export-at")
def api_probe_export_at():
    body = request.get_json(silent=True) or {}
    ids = body.get("ids")
    items = load_probe()
    base = [a for a in items if str(a.get("id")) in {str(i) for i in ids}] if ids else items
    tokens = [str(a.get("accessToken") or "").strip() for a in base]
    tokens = [t for t in tokens if t]
    ts = time.strftime("%Y-%m-%dT%H-%M-%S", time.gmtime())
    return Response(
        "\n".join(tokens) + ("\n" if tokens else ""),
        mimetype="text/plain",
        headers={"Content-Disposition": f'attachment; filename="probe_at_export_{ts}.txt"',
                 "X-Export-Count": str(len(tokens))},
    )


# ---------- POST /api/probe/accounts/export-sub（批量导出 SUB2API JSON）----------
@bp.post("/api/probe/accounts/export-sub")
def api_probe_export_sub():
    body = request.get_json(silent=True) or {}
    ids = body.get("ids")
    items = load_probe()
    base = [a for a in items if str(a.get("id")) in {str(i) for i in ids}] if ids else items
    # 有第二阶段 SUB 令牌的用 SUB 令牌导出；否则回退第一阶段 refreshToken（clientId 用 sub2api 默认常量）。
    with_rt = [a for a in base if str(a.get("subRefreshToken") or a.get("refreshToken") or "").strip()]
    accounts = []
    for a in with_rt:
        email = a.get("email") or ""
        sub_rt = str(a.get("subRefreshToken") or "").strip()
        if sub_rt:
            credentials = {"refresh_token": sub_rt, "client_id": a.get("subClientId") or SUB2API_DEFAULT_CLIENT_ID, "email": email}
            if a.get("subAccessToken"):
                credentials["access_token"] = a.get("subAccessToken")
        else:
            credentials = {"refresh_token": a.get("refreshToken"), "client_id": SUB2API_DEFAULT_CLIENT_ID, "email": email}
            if a.get("accessToken"):
                credentials["access_token"] = a.get("accessToken")
        if a.get("chatgptAccountId"):
            credentials["chatgpt_account_id"] = a.get("chatgptAccountId")
        accounts.append({
            "name": email, "platform": "openai", "type": "oauth",
            "credentials": credentials, "extra": {"email": email},
            "concurrency": 1, "priority": 1, "rate_multiplier": 1, "auto_pause_on_expired": True,
        })
    payload = {
        "type": "sub2api-data", "version": 1,
        "exported_at": time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime()),
        "proxies": [], "accounts": accounts,
    }
    ts = time.strftime("%Y-%m-%dT%H-%M-%S", time.gmtime())
    return Response(
        json.dumps(payload, ensure_ascii=False, indent=2),
        mimetype="application/json",
        headers={"Content-Disposition": f'attachment; filename="sub2api_export_{ts}.json"',
                 "X-Export-Count": str(len(accounts))},
    )


# ---------- POST /api/probe/accounts/export-pw（批量导出账密，一行一个 email----password）----------
@bp.post("/api/probe/accounts/export-pw")
def api_probe_export_pw():
    body = request.get_json(silent=True) or {}
    ids = body.get("ids")
    items = load_probe()
    base = [a for a in items if str(a.get("id")) in {str(i) for i in ids}] if ids else items
    # 首行表头 + 每行 email----password----twoFactorSecret（字段缺失留空但保留分隔符）。
    lines = ["账号----密码----2FA"]
    for a in base:
        email = str(a.get("email") or "").strip()
        if not email:
            continue
        pw = str(a.get("password") or "").strip()
        tfa = str(a.get("twoFactorSecret") or "").strip()
        lines.append(f"{email}----{pw}----{tfa}")
    ts = time.strftime("%Y-%m-%dT%H-%M-%S", time.gmtime())
    return Response(
        "\n".join(lines) + "\n",
        mimetype="text/plain",
        headers={"Content-Disposition": f'attachment; filename="probe_pw_export_{ts}.txt"',
                 "X-Export-Count": str(max(0, len(lines) - 1))},  # 数据行数（不含表头）
    )


# ==========================================================================
# 设置：代理池 + 接码/SMS 配置的读写（供页面「设置」弹窗使用）
# ==========================================================================
def _proxy_to_line(p: dict) -> str:
    if p.get("raw"):
        return str(p["raw"])
    host = p.get("host") or ""
    port = p.get("port") or ""
    user = p.get("username") or ""
    pw = p.get("password") or ""
    if user:
        return f"{host}:{port}:{user}:{pw}"
    return f"{host}:{port}"


def _parse_proxy_line(line: str):
    line = line.strip()
    if not line:
        return None
    # 支持 scheme://user:pass@host:port
    m = re.match(r"^(?:(\w+)://)?(?:([^:@/]+):([^@/]*)@)?([^:/@]+):(\d+)$", line)
    if m:
        _scheme, u1, p1, host, port = m.groups()
        rec = {"raw": line, "host": host, "port": int(port)}
        if u1:
            rec["username"] = u1
            rec["password"] = p1 or ""
        return rec
    # 支持 host:port:user:pass
    parts = line.split(":")
    if len(parts) == 2:
        return {"raw": line, "host": parts[0], "port": int(parts[1])} if parts[1].isdigit() else None
    if len(parts) >= 4 and parts[1].isdigit():
        return {"raw": line, "host": parts[0], "port": int(parts[1]), "username": parts[2], "password": ":".join(parts[3:])}
    return None


@bp.get("/api/account-config")
def api_account_config_get():
    proxies = load_proxies()
    settings = load_settings()
    sms = settings.get("sms") or {}
    provider = sms.get("provider") or "smscode"
    prov_cfg = sms.get(provider) or {}
    mb = load_mailbox()

    def _sms_view(cfg: dict) -> dict:
        cfg = cfg or {}
        country = cfg.get("country")
        if country in (None, ""):
            country = cfg.get("countryId")
        return {
            "apiKey": cfg.get("apiKey") or "",
            "baseUrl": cfg.get("baseUrl") or "",
            "country": "" if country in (None, "") else country,
            "maxPrice": cfg.get("maxPrice") or "",
            "service": cfg.get("service") or "",
        }

    return jsonify({
        "proxies": [_proxy_to_line(p) for p in proxies],
        "proxyCount": len(proxies),
        "sms": {
            "provider": provider,
            "pollTimeout": sms.get("pollTimeout") or 180000,
            **_sms_view(prov_cfg),
        },
        "smsAll": {p: _sms_view(sms.get(p) or {}) for p in ("smscode", "smsbower", "herosms")},
        "providers": ["smscode", "smsbower", "herosms"],
        "mailbox": {
            "entries": [_mailbox_public(e) for e in mb.get("entries", [])],
            "count": len(mb.get("entries", [])),
            "unused": sum(1 for e in mb.get("entries", []) if not e.get("used")),
            "split": bool(mb.get("split")),
        },
        # 浏览器注册（CloakBrowser）设置：license key + 固定注册密码（与 proxy/sms/mailbox 同一套 settings.json 持久化）。
        "cloak": {
            "licenseKey": settings.get("cloakLicenseKey") or "",
            "regPassword": settings.get("regPassword") or "",
        },
    })


@bp.post("/api/account-config")
def api_account_config_post():
    body = request.get_json(silent=True) or {}
    result = {"proxySaved": False, "smsSaved": False}

    # 代理池：支持传字符串（一行一个）或已解析数组
    if "proxies" in body:
        raw = body.get("proxies")
        lines = raw.split("\n") if isinstance(raw, str) else [str(x) for x in (raw or [])]
        parsed = []
        bad = []
        for ln in lines:
            ln = ln.strip()
            if not ln:
                continue
            rec = _parse_proxy_line(ln)
            if rec:
                parsed.append(rec)
            else:
                bad.append(ln)
        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
        PROXY_FILE.write_text(json.dumps(parsed, ensure_ascii=False, indent=2), encoding="utf-8")
        result["proxySaved"] = True
        result["proxyCount"] = len(parsed)
        result["proxyBad"] = bad

    # 接码/SMS 配置
    if "sms" in body and isinstance(body["sms"], dict):
        sms_in = body["sms"]
        settings = load_settings()
        sms = settings.get("sms") or {}
        provider = sms_in.get("provider") if sms_in.get("provider") in ("smscode", "smsbower", "herosms") else (sms.get("provider") or "smscode")
        sms["provider"] = provider
        if sms_in.get("pollTimeout") is not None:
            try:
                sms["pollTimeout"] = int(sms_in["pollTimeout"])
            except (TypeError, ValueError):
                pass
        prov_cfg = dict(sms.get(provider) or {})
        if sms_in.get("apiKey") is not None:
            prov_cfg["apiKey"] = str(sms_in.get("apiKey") or "")
        if sms_in.get("baseUrl"):
            prov_cfg["baseUrl"] = str(sms_in.get("baseUrl"))
        if sms_in.get("country") is not None:
            raw_country = str(sms_in.get("country") or "").strip()
            country_val: object = ""
            if raw_country:
                country_val = int(raw_country) if raw_country.isdigit() else raw_country
            # smscode 用 countryId，其余(smsbower/herosms)用 country
            if provider == "smscode":
                prov_cfg["countryId"] = country_val
            else:
                prov_cfg["country"] = country_val
        if sms_in.get("maxPrice") is not None:
            prov_cfg["maxPrice"] = str(sms_in.get("maxPrice") or "").strip()
        sms[provider] = prov_cfg
        settings["sms"] = sms
        save_settings(settings)
        result["smsSaved"] = True

    # 邮箱池：这里只更新 split 开关，条目增改删走 /api/mailbox/* 独立接口（避免清掉 used 状态）
    if "mailbox" in body and isinstance(body["mailbox"], dict):
        mb = load_mailbox()
        mb["split"] = bool(body["mailbox"].get("split"))
        save_mailbox(mb)
        result["mailboxSaved"] = True

    # 浏览器注册（CloakBrowser）license key：存到 settings.json 的 cloakLicenseKey，
    # 供 cloak_reg_runner.mjs 启动隐身 Chromium 时使用（Pro 用最新二进制）。
    if "cloak" in body and isinstance(body["cloak"], dict):
        settings = load_settings()
        if body["cloak"].get("licenseKey") is not None:
            settings["cloakLicenseKey"] = str(body["cloak"].get("licenseKey") or "").strip()
        # 固定注册密码：两种注册模式共用（reg_password.mjs 优先读 settings.regPassword）；
        # 留空则清空，运行时回退到内置默认强口令。
        if body["cloak"].get("regPassword") is not None:
            settings["regPassword"] = str(body["cloak"].get("regPassword") or "").strip()
        save_settings(settings)
        result["cloakSaved"] = True

    return jsonify(result)


# ---------- 邮箱池条目管理 ----------
@bp.post("/api/mailbox/import")
def api_mailbox_import():
    body = request.get_json(silent=True) or {}
    parsed = parse_mailbox_lines(body.get("text") or "")
    with _plus_lock:
        mb = load_mailbox()
        entries, added = merge_mailbox_entries(mb.get("entries", []), parsed)
        mb["entries"] = entries
        save_mailbox(mb)
    return jsonify({
        "added": added,
        "parsed": len(parsed),
        "count": len(entries),
        "unused": sum(1 for e in entries if not e.get("used")),
        "entries": [_mailbox_public(e) for e in entries],
    })


@bp.post("/api/mailbox/update")
def api_mailbox_update():
    body = request.get_json(silent=True) or {}
    email = str(body.get("email") or "").strip().lower()
    if not email:
        return jsonify({"ok": False, "error": "缺少邮箱"}), 400
    with _plus_lock:
        mb = load_mailbox()
        e = next((x for x in mb.get("entries", []) if x.get("email", "").lower() == email), None)
        if not e:
            return jsonify({"ok": False, "error": "邮箱不存在"}), 404
        if body.get("credential") is not None:
            cred = str(body.get("credential") or "").strip()
            if cred:
                e["credential"] = cred
                e["type"] = "api" if re.match(r"^https?://", cred, re.I) else "imap"
        if body.get("used") is not None:
            e["used"] = bool(body.get("used"))
        save_mailbox(mb)
    return jsonify({"ok": True, "entry": _mailbox_public(e)})


@bp.post("/api/mailbox/split-generate")
def api_mailbox_split_generate():
    """为每个主邮箱(local 不含 +)生成 count 个 local+XXXX 别名，复用主邮箱凭证，并入列表。"""
    body = request.get_json(silent=True) or {}
    try:
        count = max(1, min(200, int(body.get("count") or 10)))
    except (TypeError, ValueError):
        count = 10
    with _plus_lock:
        mb = load_mailbox()
        entries = mb.get("entries", [])
        existing = {e.get("email", "").lower() for e in entries}
        added = 0
        for e in list(entries):
            email = e.get("email", "")
            if "@" not in email:
                continue
            local, _, domain = email.partition("@")
            if "+" in local:
                continue  # 已是别名不再分裂
            for _ in range(count):
                alias = ""
                for _try in range(50):
                    cand = f"{local}+{uuid.uuid4().hex[:4]}@{domain}"
                    if cand.lower() not in existing:
                        alias = cand
                        break
                if not alias:
                    continue
                existing.add(alias.lower())
                entries.append({
                    "email": alias,
                    "credential": e.get("credential", ""),
                    "type": e.get("type", "imap"),
                    "used": False,
                    "alias_of": email,
                })
                added += 1
        mb["entries"] = entries
        save_mailbox(mb)
    return jsonify({
        "added": added,
        "count": len(entries),
        "unused": sum(1 for e in entries if not e.get("used")),
        "entries": [_mailbox_public(e) for e in entries],
    })


@bp.post("/api/mailbox/delete")
def api_mailbox_delete():
    body = request.get_json(silent=True) or {}
    targets = {str(x).strip().lower() for x in (body.get("emails") or [])}
    one = str(body.get("email") or "").strip().lower()
    if one:
        targets.add(one)
    if not targets:
        return jsonify({"ok": False, "error": "缺少邮箱"}), 400
    with _plus_lock:
        mb = load_mailbox()
        before = len(mb.get("entries", []))
        mb["entries"] = [e for e in mb.get("entries", []) if e.get("email", "").lower() not in targets]
        save_mailbox(mb)
        entries = mb["entries"]
    return jsonify({
        "ok": True,
        "removed": before - len(entries),
        "count": len(entries),
        "unused": sum(1 for e in entries if not e.get("used")),
        "entries": [_mailbox_public(e) for e in entries],
    })


@bp.post("/api/mailbox/clear")
def api_mailbox_clear():
    """清空邮箱池全部条目（前端已做主题化二次确认）。"""
    with _plus_lock:
        mb = load_mailbox()
        removed = len(mb.get("entries", []))
        mb["entries"] = []
        save_mailbox(mb)
    return jsonify({"ok": True, "removed": removed, "count": 0, "unused": 0, "entries": []})


@bp.post("/api/sms/balance")
def api_sms_balance():
    """查询接码平台余额（smsbower / herosms 走 handler_api.php 的 getBalance）。"""
    body = request.get_json(silent=True) or {}
    settings = load_settings()
    sms = settings.get("sms") or {}
    provider = str(body.get("provider") or sms.get("provider") or "smsbower").strip()
    prov_cfg = sms.get(provider) or {}
    api_key = str(body.get("apiKey") or prov_cfg.get("apiKey") or "").strip()
    base_url = str(body.get("baseUrl") or prov_cfg.get("baseUrl") or "").strip()
    if not api_key:
        return jsonify({"ok": False, "error": "未配置 API Key"})
    if not base_url:
        return jsonify({"ok": False, "error": "未配置 Base URL"})
    if httpx is None:
        return jsonify({"ok": False, "error": "httpx 不可用"})
    try:
        r = httpx.get(base_url, params={"api_key": api_key, "action": "getBalance"}, timeout=20)
        text = (r.text or "").strip()
        if text.startswith("ACCESS_BALANCE"):
            bal = text.split(":", 1)[1].strip() if ":" in text else ""
            return jsonify({"ok": True, "provider": provider, "balance": bal, "raw": text})
        errmap = {
            "BAD_KEY": "API 密钥不正确",
            "BAD_ACTION": "动作错误",
            "ERROR_SQL": "服务端错误，请稍后再试",
        }
        return jsonify({"ok": False, "error": errmap.get(text, text or f"HTTP {r.status_code}")})
    except Exception as exc:
        return jsonify({"ok": False, "error": f"{type(exc).__name__}: {exc}"})


@bp.post("/api/mailbox/test")
def api_mailbox_test():
    body = request.get_json(silent=True) or {}
    email = str(body.get("email") or "").strip()
    credential = str(body.get("credential") or "").strip()
    if not credential:
        for e in load_mailbox().get("entries", []):
            if e.get("email", "").lower() == email.lower():
                credential = e.get("credential", "")
                break
    if not _EMAIL_RE.match(email) or not credential:
        return jsonify({"ok": False, "error": "缺少邮箱或凭证"}), 400
    try:
        if re.match(r"^https?://", credential, re.I):
            return jsonify(_mailbox_test_api(email, credential))
        return jsonify(_mailbox_test_imap(email, credential))
    except Exception as exc:
        return jsonify({"ok": False, "error": f"{type(exc).__name__}: {exc}"})


# 启动 TOKEN 自动刷新后台调度线程（daemon）
_probe_auto_thread = threading.Thread(target=_auto_refresh_loop, name="probe-auto-refresh", daemon=True)
_probe_auto_thread.start()