# -*- coding: utf-8 -*-
"""国安盾面板授权 SDK（Python 版，二期 A 轨 · 第177轮）

给自研应用用的三行接入：

    import gad_sdk
    if not gad_sdk.require("wechat-multi"):
        sys.exit(1)

它做的事，按顺序：
  1. 每次启动都先尝试实时握手：连本机命名管道，连不上就用注册表里登记的安装路径
     把面板以 --agent 方式静默拉起（不弹面板窗口，只在托盘留个图标），然后向面板
     要一张票据；面板去服务器校验（有网实时校验，没网用它自己的缓存），通过后发回；
  2. 只有握手「彻底连不上面板」（面板被卸载或起不来）且本地有「24 小时内」缓存时，
     才离线兜底放行——保证面板在时每启动都过授权，杜绝「面板没开却离线放行」。

为什么不让应用自己去找服务器校验？那样每个应用都要处理登录态、令牌、离线窗口，
而且会把账号凭据扩散到上百个应用里。现在统一由面板代理：应用只认本机面板。

安全边界（如实说明）：这是「提高门槛」不是「防破解」。面板会校验调用方进程是否在
该应用允许目录内（挡住随手写的冒名程序），但本机管理员总有办法绕过。要真正防住
需要三期 B 轨（加密启动壳）。

调试：直接运行本文件可自测
    python gad_sdk.py wechat-multi
"""

import ctypes
import json
import os
import subprocess
import sys
import threading
import time

# SDK 自身版本（与应用版本无关）。面板会据此判断「应用内置的 SDK 是否过旧」。
# 一旦发布安全/兼容性修复，就把这个数字升一档，并在面板的「最低 SDK 版本」里同步抬高，
# 低于该值的已上架应用会被面板提示「SDK 过旧，建议更新」。
# 第179轮：1.1.1 修了授权弹窗的空白 tk 窗口；
# 第180轮：1.1.2 收紧授权——改为「每次启动优先实时握手，缓存只在面板彻底
#          连不上时兜底」，堵住「面板没运行却能凭缓存离线放行」的口子。
# 第185轮：1.1.3 新增 heartbeat() 运行期心跳——账号在别的电脑登录会把本机会话
#          顶下线，只在启动时校验一次的话应用会一直跑到用户手动关闭；
#          接上心跳后，被顶下线的一方最迟一个心跳周期内自动结束。
SDK_VERSION = "1.1.3"

__all__ = ["require", "handshake", "status", "heartbeat", "clear_cache",
           "panel_exe", "cache_path"]

# ---------------------------------------------------------------- 常量

PIPE_PREFIX = "GuoAnDunPanel_"          # 与面板 AgentServer::channelName() 保持一致
PANEL_EXE_NAME = "GuoAnDunPanel.exe"
CACHE_DIR_NAME = ("GuoAnDun", "grants")
DEFAULT_OFFLINE_HOURS = 24              # 票据最长离线宽限（与服务端 offline_hours 一致）
CONNECT_TIMEOUT_MS = 2000               # 单次等待管道出现的超时
LAUNCH_WAIT_SEC = 12                    # 拉起面板后最多等这么久（含面板启动 + 联网校验）
IO_TIMEOUT_SEC = 20                     # 单次读写的总超时

GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000
OPEN_EXISTING = 3
INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value


# ---------------------------------------------------------------- 小工具

def _log(message):
    """写一行到 stderr（不污染 stdout，方便命令行脚本解析输出）。"""
    try:
        sys.stderr.write("[gad] %s\n" % message)
        sys.stderr.flush()
    except Exception:
        pass


def _local_app_data():
    return os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")


def cache_path(app_id):
    """票据缓存文件路径（每个应用一份）。"""
    return os.path.join(_local_app_data(), *CACHE_DIR_NAME, "%s.json" % app_id)


def _read_cache(app_id):
    try:
        with open(cache_path(app_id), "r", encoding="utf-8") as stream:
            data = json.load(stream)
        if isinstance(data, dict) and data.get("issued"):
            return data
    except (OSError, ValueError):
        pass
    return None


def _write_cache(app_id, ticket, issued, expire, user):
    path = cache_path(app_id)
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
        data = {"ticket": ticket, "issued": int(issued), "expire": expire or "",
                "user": user or ""}
        temp = path + ".tmp"
        with open(temp, "w", encoding="utf-8") as stream:
            json.dump(data, stream, ensure_ascii=False)
        os.replace(temp, path)
        return True
    except OSError as exc:
        _log("写缓存失败：%s" % exc)
        return False


def clear_cache(app_id):
    """删除本地票据缓存（下次启动必须重新握手）。"""
    try:
        os.remove(cache_path(app_id))
        return True
    except OSError:
        return False


# ---------------------------------------------------------------- 定位面板

def panel_exe():
    """按 注册表 → 常见安装目录 的顺序找面板主程序；找不到返回 None。"""
    try:
        import winreg
    except ImportError:
        return None
    candidates = []
    for hive, flag in (
        (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_64KEY),
        (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_32KEY),
        (winreg.HKEY_CURRENT_USER, 0),
    ):
        try:
            with winreg.OpenKey(hive, r"SOFTWARE\GuoAnDunPanel", 0, winreg.KEY_READ | flag) as key:
                value, _ = winreg.QueryValueEx(key, "InstallPath")
                if value:
                    candidates.append(os.path.join(value, PANEL_EXE_NAME))
        except OSError:
            continue
    for base in (os.environ.get("ProgramFiles"), os.environ.get("ProgramFiles(x86)"),
                 os.environ.get("LOCALAPPDATA")):
        if base:
            candidates.append(os.path.join(base, "国安盾面板", PANEL_EXE_NAME))
    for path in candidates:
        if os.path.isfile(path):
            return path
    return None


def _user_sid():
    """当前用户 SID（S-1-5-21-...-1001），与面板端同一算法；失败返回 None。"""
    try:
        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
        advapi32 = ctypes.WinDLL("advapi32", use_last_error=True)
        # 关键：ctypes 默认把返回值当 32 位 int，而句柄在 64 位进程里是 8 字节，
        # 不显式声明 restype 会被截断成无效句柄——表现就是 SID 取不到、退回用户名，
        # 于是通道名和面板端对不上（面板用 SID，这里用用户名）。逐个声明类型：
        kernel32.GetCurrentProcess.restype = ctypes.c_void_p
        kernel32.GetCurrentProcess.argtypes = []
        advapi32.OpenProcessToken.argtypes = [ctypes.c_void_p, ctypes.c_uint32,
                                              ctypes.POINTER(ctypes.c_void_p)]
        advapi32.OpenProcessToken.restype = ctypes.c_int
        advapi32.GetTokenInformation.argtypes = [ctypes.c_void_p, ctypes.c_uint32,
                                                 ctypes.c_void_p, ctypes.c_uint32,
                                                 ctypes.POINTER(ctypes.c_uint32)]
        advapi32.GetTokenInformation.restype = ctypes.c_int
        advapi32.ConvertSidToStringSidW.argtypes = [ctypes.c_void_p,
                                                     ctypes.POINTER(ctypes.c_wchar_p)]
        advapi32.ConvertSidToStringSidW.restype = ctypes.c_int

        token = ctypes.c_void_p()
        proc = kernel32.GetCurrentProcess()
        if not advapi32.OpenProcessToken(proc, 0x0008, ctypes.byref(token)):
            return None
        try:
            length = ctypes.c_uint32(0)
            advapi32.GetTokenInformation(token, 1, None, 0, ctypes.byref(length))
            if length.value == 0:
                return None
            buf = ctypes.create_string_buffer(length.value)
            if not advapi32.GetTokenInformation(token, 1, buf, length.value,
                                                ctypes.byref(length)):
                return None
            # TOKEN_USER = { SID_AND_ATTRIBUTES { PSID Sid; DWORD Attributes } }
            # 结构体首字段就是 SID 指针（32/64 位分别占 4/8 字节，c_void_p 自动匹配）
            sid = ctypes.cast(buf, ctypes.POINTER(ctypes.c_void_p)).contents
            text = ctypes.c_wchar_p()
            if advapi32.ConvertSidToStringSidW(sid, ctypes.byref(text)) and text.value:
                value = text.value
                kernel32.LocalFree(text)
                return value
        finally:
            kernel32.CloseHandle(token)
    except Exception:
        pass
    return None


def pipe_name():
    """管道名（不含 \\\\.\\pipe\\ 前缀）。"""
    sid = _user_sid()
    if sid:
        return PIPE_PREFIX + sid
    # 与面板端一致的回退：拿不到 SID 就用用户名
    return PIPE_PREFIX + (os.environ.get("USERNAME") or "default")


# ---------------------------------------------------------------- 管道通信

def _pipe_path():
    return r"\\.\pipe\%s" % pipe_name()


def _connect(timeout_ms=CONNECT_TIMEOUT_MS):
    """连接面板管道；返回句柄（int）或 None。"""
    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
    path = _pipe_path()
    if kernel32.WaitNamedPipeW(ctypes.c_wchar_p(path), ctypes.c_uint32(timeout_ms)) == 0:
        # 管道不存在（面板没运行）时也会走到这里，属正常情况，不打日志
        return None
    handle = kernel32.CreateFileW(
        ctypes.c_wchar_p(path),
        ctypes.c_uint32(GENERIC_READ | GENERIC_WRITE),
        ctypes.c_uint32(0), None,
        ctypes.c_uint32(OPEN_EXISTING),
        ctypes.c_uint32(0), None,
    )
    if handle == INVALID_HANDLE_VALUE:
        return None
    return handle


def _talk(payload, timeout_sec=IO_TIMEOUT_SEC):
    """连管道 → 发一行 JSON → 读回一行 JSON；失败返回 None。

    读写放在工作线程里：主线程 join 超时后直接关句柄，把阻塞的 ReadFile 打断，
    避免面板异常（不回包）时应用被卡死在启动阶段。
    """
    handle = _connect()
    if handle is None:
        return None
    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
    result = {}

    def worker():
        try:
            data = payload.encode("utf-8")
            written = ctypes.c_uint32(0)
            ok = kernel32.WriteFile(ctypes.c_void_p(handle), data, len(data),
                                    ctypes.byref(written), None)
            if not ok:
                return
            chunks = []
            buffer = ctypes.create_string_buffer(65536)
            while True:
                read = ctypes.c_uint32(0)
                ok = kernel32.ReadFile(ctypes.c_void_p(handle), buffer, 65536,
                                       ctypes.byref(read), None)
                if not ok or read.value == 0:
                    break
                chunks.append(buffer.raw[: read.value])
                text = b"".join(chunks)
                if b"\n" in text:      # 面板写完一行就断开，收到换行即可收工
                    result["raw"] = text
                    return
            if chunks:
                result["raw"] = b"".join(chunks)
        except Exception as exc:
            result["error"] = str(exc)

    thread = threading.Thread(target=worker, daemon=True)
    thread.start()
    thread.join(timeout_sec)
    if thread.is_alive():
        _log("等待面板响应超时（%d 秒），已放弃" % timeout_sec)
        kernel32.CloseHandle(ctypes.c_void_p(handle))
        thread.join(2)
        return None
    kernel32.CloseHandle(ctypes.c_void_p(handle))
    raw = result.get("raw")
    if not raw:
        _log("面板无响应：%s" % result.get("error", "空应答"))
        return None
    line = raw.split(b"\n", 1)[0].strip()
    try:
        return json.loads(line.decode("utf-8", errors="replace"))
    except ValueError:
        _log("面板应答不是 JSON：%r" % line[:120])
        return None


def _launch_panel():
    """把面板以 --agent 方式静默拉起；成功返回 True。"""
    exe = panel_exe()
    if not exe:
        return False
    flags = 0
    for name in ("DETACHED_PROCESS", "CREATE_NEW_PROCESS_GROUP", "CREATE_NO_WINDOW"):
        flags |= getattr(subprocess, name, 0)
    try:
        subprocess.Popen([exe, "--agent"], creationflags=flags, close_fds=True)
        _log("已静默拉起面板：%s --agent" % exe)
        return True
    except OSError as exc:
        _log("拉起面板失败：%s" % exc)
        return False


# ---------------------------------------------------------------- 对外接口

def handshake(app_id):
    """向面板要一张票据。

    返回 dict：{"ok": bool, "code": str, "msg": str, "ticket": str, ...}
    code 可能是 NOT_LOGIN / NO_LICENSE / EXPIRED / DISABLED / NETWORK /
    IMPOSTOR / PANEL_NOT_FOUND（找不到面板）/ NO_RESPONSE
    """
    payload = json.dumps({"v": 1, "cmd": "handshake", "app": app_id}, ensure_ascii=False)
    reply = _talk(payload + "\n")
    if reply is None:
        # 面板可能没运行 → 拉起后重试（最多等到 LAUNCH_WAIT_SEC）
        if not _launch_panel():
            return {"ok": False, "code": "PANEL_NOT_FOUND",
                    "msg": "未找到国安盾面板，请先安装并登录面板。"}
        deadline = time.time() + LAUNCH_WAIT_SEC
        while time.time() < deadline:
            time.sleep(0.6)
            reply = _talk(payload + "\n")
            if reply is not None:
                break
    if reply is None:
        return {"ok": False, "code": "NO_RESPONSE",
                "msg": "无法连接国安盾面板，请确认面板已安装并运行。"}
    return reply


def status(app_id, offline_hours=DEFAULT_OFFLINE_HOURS):
    """返回当前授权状态（不弹窗、不改缓存之外的任何东西）。

    判定顺序（第180轮收紧）：
      1. 先尝试实时握手——面板在就每启动都重新校验，并据此把面板以 --agent
         方式静默拉起。这是默认路径，确保「面板没开就不能用」；
      2. 只有握手彻底连不上面板（PANEL_NOT_FOUND / NO_RESPONSE，即面板被卸载
         或起不来）且本地有 24 小时内的缓存时，才离线放行作为兜底。
      这样平时每次启动都要过面板，杜绝了「面板没运行却凭缓存离线放行」的漏洞；
      真正的离线（面板完全不可用）仍给 24 小时宽限，避免误伤。

    返回 dict 里 valid=True 表示可用，source 说明判定来源：
      handshake —— 刚跟面板握过手
      cache     —— 面板连不上，用 24 小时内的缓存兜底
    """
    reply = handshake(app_id)
    now = int(time.time())
    if reply.get("ok"):
        _write_cache(app_id, reply.get("ticket", ""), now,
                     reply.get("expire", ""), reply.get("user", ""))
        return {"valid": True, "source": "handshake", "user": reply.get("user", ""),
                "expire": reply.get("expire", ""), "code": "OK",
                "msg": reply.get("msg", ""), "from_cache": reply.get("from_cache", False)}
    # 握手失败：仅当面板彻底连不上（不是未登录/被禁用，那些是明确的拒绝）且
    # 本地有 24 小时内的缓存时，才离线兜底放行。
    if reply.get("code") in ("PANEL_NOT_FOUND", "NO_RESPONSE"):
        cached = _read_cache(app_id)
        if cached and now - int(cached["issued"]) <= offline_hours * 3600:
            age = int((now - int(cached["issued"])) / 60)
            _log("离线兜底放行：%d 分钟前已握手（面板连不上，< %d 小时）" % (age, offline_hours))
            return {"valid": True, "source": "cache", "user": cached.get("user", ""),
                    "expire": cached.get("expire", ""), "code": "OK", "msg": ""}
    return {"valid": False, "source": "handshake",
            "code": reply.get("code", "UNKNOWN"),
            "msg": reply.get("msg", "授权校验失败")}


# 面板明确判定「本机授权已失效」的返回码——出现这些必须立刻停用应用。
# 注意 PANEL_NOT_FOUND / NO_RESPONSE / NETWORK 不在其中：那只是面板暂时连不上
# 或断网，用户可能只是关了面板，不该把正在用的程序踢掉。
REVOKE_CODES = ("NOT_LOGIN", "NO_LICENSE", "EXPIRED", "DISABLED", "IMPOSTOR")


def heartbeat(app_id, launch=False):
    """运行期心跳（第185轮）：复查一次授权，供运行中的应用定时调用。

    与 status() 的区别：
      * 不做 24 小时缓存兜底 —— 心跳要的是「现在还有效吗」，缓存会让被顶下线
        的机器继续跑；
      * 默认不拉起面板（launch=False）——每 60 秒拉起一次面板不合适。

    返回 dict：
      {"ok": True,  "revoked": False, "code": "OK"}          授权仍有效
      {"ok": False, "revoked": True,  "code": "NOT_LOGIN"}   明确失效，应立即退出
      {"ok": False, "revoked": False, "code": "NO_RESPONSE"} 暂时连不上，继续等下次
    """
    payload = json.dumps({"v": 1, "cmd": "handshake", "app": app_id}, ensure_ascii=False)
    reply = _talk(payload + "\n")
    if reply is None and launch:
        reply = handshake(app_id)      # 只在调用方显式要求时才拉起面板
    if reply is None:
        return {"ok": False, "revoked": False, "code": "NO_RESPONSE",
                "msg": "无法连接国安盾面板"}
    if reply.get("ok"):
        return {"ok": True, "revoked": False, "code": "OK", "msg": ""}
    code = reply.get("code", "UNKNOWN")
    return {"ok": False, "revoked": code in REVOKE_CODES, "code": code,
            "msg": reply.get("msg", "授权校验失败")}


def require(app_id, app_name=None, offline_hours=DEFAULT_OFFLINE_HOURS, quiet=False):
    """应用启动时调用：有权限返回 True，否则弹出提示并返回 False。

    app_name  —— 弹窗里显示的应用名（不传就用 app_id）
    quiet     —— True 时不弹窗（命令行/无人值守场景用）
    """
    info = status(app_id, offline_hours)
    if info["valid"]:
        return True

    title = app_name or app_id
    code = info.get("code", "")
    message = info.get("msg") or "授权校验失败（%s）" % code
    hints = {
        "NOT_LOGIN": "请打开国安盾面板并登录账号后，再启动本程序。",
        "NO_LICENSE": "该应用为会员专享，请联系客服开通后再使用。",
        "EXPIRED": "授权已到期，请续费后再使用。",
        "DISABLED": "该应用已被管理员停用，请联系客服。",
        "NETWORK": "网络不可用且本地没有可用票据，请联网后重试。",
        "PANEL_NOT_FOUND": "未找到国安盾面板，请先安装面板并登录。",
        "NO_RESPONSE": "无法连接国安盾面板，请确认面板已安装并运行。",
        "IMPOSTOR": "程序位置不被面板认可，请从面板应用市场安装本程序。",
    }
    text = message
    if code in hints:
        text = "%s\n\n%s" % (message, hints[code])
    _log("授权未通过：%s / %s" % (code, message))
    if not quiet:
        _notify(title, text)
    return False


def _notify(title, text):
    """优先用 Tk 弹窗（GUI 程序），失败则打印到控制台。

    第179轮修复：之前判断 "tkinter" in sys.modules 就直接调 messagebox.showerror，
    但主程序只是 import 了 tkinter、还没创建 Tk 窗口时，messagebox 会自动
    创建一个默认 root 窗口 —— 就是用户看到的那个空白 "tk" 窗口。
    现在统一：没有现成 root 就先建一个 withdraw（隐藏）的 root，用完销毁。
    """
    try:
        import tkinter
        from tkinter import messagebox
        root = None
        try:
            root = tkinter._get_default_root()   # 已有主窗口则复用
        except Exception:
            root = None
        own = False
        if root is None:                          # 没有主窗口：造一个隐藏的
            root = tkinter.Tk()
            root.withdraw()
            own = True
        messagebox.showerror("无法启动 %s" % title, text, parent=root)
        if own:
            root.destroy()
        return
    except Exception:
        pass
    sys.stderr.write("%s\n" % text)


# ---------------------------------------------------------------- 命令行自测

if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "wechat-multi"
    print("管道名 : %s" % pipe_name())
    print("面板   : %s" % (panel_exe() or "(未找到)"))
    print("缓存   : %s" % cache_path(target))
    print("状态   : %s" % json.dumps(status(target), ensure_ascii=False))
