"""serve.py — 用 transformers 直接加载 safetensors 版 Spark-X2.5-1.7B 的本地推理服务

接口：
  - OpenAI 兼容:  GET  /v1/models
                  POST /v1/chat/completions   (支持 stream=true, 额外字段 enable_thinking / ablate_refusal)
  - Ollama 兼容:  GET  /api/tags
                  POST /api/chat              (支持 stream, options.think / options.temperature 等)
  - GET  /health

单卡小模型的串行服务：请求排队逐个生成（无 continuous batching）。
启动:  .venv/bin/python serve.py --host 0.0.0.0 --port 8000

拒绝方向消融（可解释性研究功能）：
  --ablate on 启动后默认对所有请求做全层方向消融；
  请求级字段 ablate_refusal（bool）可单次覆盖服务端默认值。
  消融方向来自 --directions（默认 results/directions.pt）的 --ablate-layer（默认 11）。
  也可直接服务权重正交化派生模型：--model /home/dong/models/Spark-X2.5-1.7B-orth-r11（无需消融开关）。
"""
import argparse
import json
import re
import sys
import threading
import time
import uuid
from datetime import datetime, timezone
from pathlib import Path

import torch
import uvicorn
from fastapi import FastAPI
from fastapi.responses import JSONResponse, StreamingResponse
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer

sys.path.insert(0, str(Path(__file__).parent / "src"))

MODEL_PATH_DEFAULT = "/home/dong/models/Spark-X2.5-1.7B"
MODEL_ID = "Spark-X2.5-1.7B"   # 启动时按 --model 目录名自动更新

app = FastAPI(title="Spark-X2.5-1.7B (safetensors) server")
model = None
tok = None
gen_lock = threading.Lock()   # 单 GPU：生成串行化
DEFAULT_THINKING = True       # --thinking 启动参数控制
DEFAULT_ABLATE = False        # --ablate 启动参数控制
DIRECTION = None              # r̂（k=1 用）
SUBSPACE_BASIS = None         # SVD 右奇异向量 Vt（k>1 子空间用，启动时按需算到 32 维）
ABLATE_K = 1                  # --ablate-k 服务端默认；请求级 ablate_k 可覆盖
MAX_CONTEXT = 16384           # --max-context：输入 token 上限（0=不限制）；6GB 卡建议 ≤16K


class ContextTooLongError(ValueError):
    """输入超过 MAX_CONTEXT；映射为 400 而非在后台线程 OOM"""


# ---------- 请求模型 ----------
class ChatMessage(BaseModel):
    role: str
    content: str | None = ""
    tool_calls: list[dict] | None = None   # 历史里 assistant 的工具调用（模板会重建 <function> XML）


class ChatCompletionRequest(BaseModel):
    model: str | None = None
    messages: list[ChatMessage]
    temperature: float | None = None
    top_p: float | None = None
    top_k: int | None = None
    max_tokens: int = 512
    stream: bool = False
    enable_thinking: bool | None = None   # None 时用服务端默认值
    ablate_refusal: bool | None = None    # None 时用服务端默认值；True 时本次生成做方向消融
    ablate_k: int | None = None           # None 时用服务端 --ablate-k；本次生成的子空间维度
    tools: list[dict] | None = None       # OpenAI 格式的 function 定义
    stop: list[str] | str | None = None


class OllamaChatRequest(BaseModel):
    model: str | None = None
    messages: list[ChatMessage]
    stream: bool = True
    think: bool | None = None             # None 时用服务端默认值
    tools: list[dict] | None = None       # function 定义（同 OpenAI 格式）
    options: dict | None = None       # temperature/top_p/top_k/num_predict


# ---------- 生成核心 ----------
def _ablate_active(flag):
    return flag if flag is not None else DEFAULT_ABLATE


def _ablate_handles(active, k=None):
    """生成串行（gen_lock），按请求注册/移除消融 hook 是安全的。
    k：None 用服务端 ABLATE_K；1=单方向；>1=SVD 子空间。"""
    if not active or DIRECTION is None:
        return []
    from model_utils import make_hooks, make_subspace_hooks
    k = k or ABLATE_K
    if k > 1 and SUBSPACE_BASIS is not None:
        return make_subspace_hooks(model, SUBSPACE_BASIS[:k].contiguous())
    return make_hooks(model, DIRECTION, "ablate")


def _norm_tools(tools):
    """OpenAI 格式 {"type":"function","function":{...}} → MiniCPM5 模板约定的裸函数签名"""
    if not tools:
        return None
    out = []
    for t in tools:
        out.append(t.get("function", t) if isinstance(t, dict) else t)
    return out


def build_inputs(messages, enable_thinking, tools=None):
    if enable_thinking is None:
        enable_thinking = DEFAULT_THINKING
    msgs = [m.model_dump() for m in messages]
    for m in msgs:   # OpenAI 回传的 arguments 是 JSON 字符串，模板需要 dict
        for tc in (m.get("tool_calls") or []):
            fn = tc.get("function", {})
            if isinstance(fn.get("arguments"), str):
                try:
                    fn["arguments"] = json.loads(fn["arguments"])
                except ValueError:
                    pass
    kw = {}
    t = _norm_tools(tools)
    if t:
        kw["tools"] = t
    text = tok.apply_chat_template(
        msgs, add_generation_prompt=True, enable_thinking=enable_thinking, tokenize=False, **kw
    )
    enc = tok(text, return_tensors="pt")
    n_in = enc["input_ids"].shape[1]
    if MAX_CONTEXT and n_in > MAX_CONTEXT:
        raise ContextTooLongError(
            f"输入 {n_in} token 超过服务端上限 MAX_CONTEXT={MAX_CONTEXT}"
            f"（6GB 显存限制；长上下文请用 --dtype float16 启动以启用 O(n) 高效注意力内核，"
            f"或缩短历史，或 --max-context 0 自担 OOM 风险）")
    enc.pop("token_type_ids", None)   # MiniCPM5 的 tokenizer 会返回 token_type_ids，Llama forward 不接受
    enc = enc.to(model.device)
    return enc


def gen_kwargs(temperature, top_p, top_k, max_new_tokens):
    kw = dict(max_new_tokens=max_new_tokens, pad_token_id=tok.pad_token_id or tok.eos_token_id)
    if temperature is not None and temperature > 0:
        kw.update(do_sample=True, temperature=temperature)
        if top_p is not None:
            kw["top_p"] = top_p
        if top_k is not None:
            kw["top_k"] = top_k
    else:
        kw.update(do_sample=False)
    return kw


def split_thinking(text: str):
    """思维链模型：拆出 <think> 段与正式回答。返回 (reasoning, answer)"""
    body = text
    if body.startswith("<think>"):
        body = body[len("<think>"):]
    if "</think>" in body:
        reasoning, answer = body.split("</think>", 1)
        return reasoning.strip(), answer.strip()
    return "", body.strip()


_FUNC_RE = re.compile(r'<function\s+name="([^"]+)"\s*>(.*?)</function>', re.S)
_PARAM_RE = re.compile(r'<param\s+name="([^"]+)"\s*>(.*?)</param>', re.S)
_CDATA_RE = re.compile(r'^\s*<!\[CDATA\[(.*)\]\]>\s*$', re.S)


def parse_tool_calls(text: str):
    """把 MiniCPM5 的 <function name=...><param .../> 输出解析成 OpenAI tool_calls。
    返回 (tool_calls, 剩余正文)；无调用时 tool_calls 为空列表。"""
    calls = []
    for m in _FUNC_RE.finditer(text):
        params = {}
        for pm in _PARAM_RE.finditer(m.group(2)):
            val = pm.group(2).strip()
            cd = _CDATA_RE.match(val)
            if cd:
                val = cd.group(1)
            try:
                val = json.loads(val)   # 尽量恢复数字/布尔/结构
            except (ValueError, json.JSONDecodeError):
                pass
            params[pm.group(1)] = val
        calls.append({"id": "call_" + uuid.uuid4().hex[:24], "type": "function",
                      "function": {"name": m.group(1),
                                   "arguments": json.dumps(params, ensure_ascii=False)}})
    rest = _FUNC_RE.sub("", text).replace("<tool_sep>", "").strip()
    return calls, rest


def apply_stop(text: str, stop):
    if not stop:
        return text
    stops = [stop] if isinstance(stop, str) else stop
    cut = len(text)
    for s in stops:
        i = text.find(s)
        if i >= 0:
            cut = min(cut, i)
    return text[:cut]


# 工具调用的 <function / <param 等是 MiniCPM5 的特殊 token，不能随 skip_special_tokens 丢掉
_KEEP_SPECIAL = {"<function", "</function>", "<param", "</param>", "<tool_sep>"}


def decode_generated(ids):
    """解码生成段：保留工具调用结构 token，剔除其余控制 token"""
    text = tok.decode(ids, skip_special_tokens=False)
    for atok in tok.added_tokens_decoder.values():
        if atok.special and atok.content not in _KEEP_SPECIAL:
            text = text.replace(atok.content, "")
    return text


def generate_full(req: ChatCompletionRequest):
    """非流式：返回 (全文, prompt_tokens, completion_tokens, 秒)"""
    enc = build_inputs(req.messages, req.enable_thinking, req.tools)
    kw = gen_kwargs(req.temperature, req.top_p, req.top_k, req.max_tokens)
    handles = _ablate_handles(_ablate_active(req.ablate_refusal), req.ablate_k)
    try:
        with gen_lock:
            t0 = time.time()
            out = model.generate(**enc, **kw)
            dt = time.time() - t0
    finally:
        for h in handles:
            h.remove()
    gen = out[0, enc["input_ids"].shape[1]:]
    text = decode_generated(gen)
    text = apply_stop(text, req.stop)
    return text, enc["input_ids"].shape[1], gen.shape[0], dt


def stream_tokens(enc, req: ChatCompletionRequest):
    """流式：生成 token 文本块迭代器（注意：流式不解析工具调用，客户端会收到原始 XML）
    enc 由端点预先构建（长度校验等异常要在 SSE 响应开始前抛出）"""
    kw = gen_kwargs(req.temperature, req.top_p, req.top_k, req.max_tokens)
    streamer = TextIteratorStreamer(tok, skip_prompt=True, skip_special_tokens=True)
    handles = _ablate_handles(_ablate_active(req.ablate_refusal), req.ablate_k)
    def _run():
        try:
            with gen_lock:
                model.generate(**enc, streamer=streamer, **kw)
        except Exception as e:
            import traceback
            traceback.print_exc()
            try:   # TextIteratorStreamer.put 只接受 token 张量
                ids = tok(f"\n\n[服务端生成错误: {type(e).__name__}]",
                          return_tensors="pt", add_special_tokens=False).input_ids
                streamer.put(ids.to(model.device))
            except Exception:
                pass
        finally:
            for h in handles:
                h.remove()
            streamer.end()   # 兜底结束流，避免客户端挂起
    threading.Thread(target=_run, daemon=True).start()
    yield from streamer


# ---------- OpenAI 兼容端点 ----------
@app.get("/health")
def health():
    return {"status": "ok", "model": MODEL_ID, "device": str(model.device),
            "ablate_default": DEFAULT_ABLATE, "ablate_available": DIRECTION is not None}


@app.get("/v1/models")
def list_models():
    return {"object": "list", "data": [
        {"id": MODEL_ID, "object": "model", "created": 0, "owned_by": "local-safetensors"}]}


@app.post("/v1/chat/completions")
def chat_completions(req: ChatCompletionRequest):
    if req.stream:
        enc = build_inputs(req.messages, req.enable_thinking, req.tools)   # 先于 SSE 校验
        def sse():
            cid = "chatcmpl-" + uuid.uuid4().hex[:24]
            for chunk in stream_tokens(enc, req):
                if not chunk:
                    continue
                payload = {"id": cid, "object": "chat.completion.chunk", "created": int(time.time()),
                           "model": MODEL_ID,
                           "choices": [{"index": 0, "delta": {"content": chunk},
                                        "finish_reason": None}]}
                yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
            done = {"id": cid, "object": "chat.completion.chunk", "created": int(time.time()),
                    "model": MODEL_ID,
                    "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]}
            yield f"data: {json.dumps(done)}\n\ndata: [DONE]\n\n"
        return StreamingResponse(sse(), media_type="text/event-stream")

    text, n_prompt, n_gen, dt = generate_full(req)
    reasoning, answer = split_thinking(text)
    tool_calls, answer = parse_tool_calls(answer)
    msg = {"role": "assistant", "content": answer}
    if reasoning:
        msg["reasoning_content"] = reasoning    # DeepSeek-R1 风格字段
    if tool_calls:
        msg["tool_calls"] = tool_calls
    return {"id": "chatcmpl-" + uuid.uuid4().hex[:24], "object": "chat.completion",
            "created": int(time.time()), "model": MODEL_ID,
            "choices": [{"index": 0, "message": msg,
                         "finish_reason": "tool_calls" if tool_calls else "stop"}],
            "usage": {"prompt_tokens": n_prompt, "completion_tokens": n_gen,
                      "total_tokens": n_prompt + n_gen},
            "speed_tok_s": round(n_gen / max(dt, 1e-6), 1)}


# ---------- Ollama 兼容端点 ----------
@app.get("/api/tags")
def ollama_tags():
    return {"models": [{"name": MODEL_ID, "model": MODEL_ID,
                        "modified_at": datetime.now(timezone.utc).isoformat(),
                        "size": 0, "digest": "safetensors-local"}]}


@app.post("/api/chat")
def ollama_chat(req: OllamaChatRequest):
    opts = req.options or {}
    conv = ChatCompletionRequest(
        messages=req.messages, stream=req.stream, enable_thinking=req.think,
        temperature=opts.get("temperature"), top_p=opts.get("top_p"), top_k=opts.get("top_k"),
        max_tokens=opts.get("num_predict", 512),
        ablate_refusal=opts.get("ablate_refusal"), tools=req.tools,
        ablate_k=opts.get("ablate_k"),
    )
    if req.stream:
        enc = build_inputs(conv.messages, conv.enable_thinking, conv.tools)   # 先于流式响应校验
        def ndjson():
            for chunk in stream_tokens(enc, conv):
                if not chunk:
                    continue
                yield json.dumps({"model": MODEL_ID,
                                  "created_at": datetime.now(timezone.utc).isoformat(),
                                  "message": {"role": "assistant", "content": chunk},
                                  "done": False}, ensure_ascii=False) + "\n"
            yield json.dumps({"model": MODEL_ID,
                              "created_at": datetime.now(timezone.utc).isoformat(),
                              "message": {"role": "assistant", "content": ""},
                              "done": True}, ensure_ascii=False) + "\n"
        return StreamingResponse(ndjson(), media_type="application/x-ndjson")

    text, _, n_gen, dt = generate_full(conv)
    _, answer = split_thinking(text)
    tool_calls, answer = parse_tool_calls(answer)
    msg = {"role": "assistant", "content": answer}
    if tool_calls:   # Ollama 风格：arguments 为 dict
        msg["tool_calls"] = [{"function": {"name": c["function"]["name"],
                                           "arguments": json.loads(c["function"]["arguments"])}}
                             for c in tool_calls]
    return {"model": MODEL_ID, "created_at": datetime.now(timezone.utc).isoformat(),
            "message": msg,
            "done": True, "eval_count": n_gen,
            "eval_duration": int(dt * 1e9)}


@app.exception_handler(ContextTooLongError)
def on_context_too_long(_, exc):
    return JSONResponse(status_code=400, content={"error": str(exc)})


@app.exception_handler(Exception)
def on_error(_, exc):
    return JSONResponse(status_code=500, content={"error": str(exc)})


def main():
    global model, tok
    p = argparse.ArgumentParser()
    p.add_argument("--model", default=MODEL_PATH_DEFAULT)
    p.add_argument("--host", default="127.0.0.1")
    p.add_argument("--port", type=int, default=8000)
    p.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    p.add_argument("--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"])
    p.add_argument("--thinking", default="on", choices=["on", "off"],
                   help="思维链默认开关（请求未显式指定时生效）")
    p.add_argument("--ablate", default="off", choices=["on", "off"],
                   help="拒绝方向消融默认开关（请求未显式指定时生效）")
    p.add_argument("--directions", default="results/directions.pt",
                   help="方向文件（含 directions_unit 张量）")
    p.add_argument("--ablate-layer", type=int, default=11)
    p.add_argument("--ablate-k", type=int, default=1,
                   help="消融子空间维度：1=单方向；>1=该层 SVD 前 k 维（k=16 清除顽固残留，需方向文件含训练激活）")
    p.add_argument("--max-context", type=int, default=None,
                   help="输入 token 上限（0=不限制）；默认按硬件自适应：fp16/新卡 16384，"
                        "Pascal 等老卡跑 bf16（SDPA 只剩 O(n²) math 后端）自动降为 3072")
    args = p.parse_args()

    global DEFAULT_THINKING, DEFAULT_ABLATE, DIRECTION, SUBSPACE_BASIS, MODEL_ID, ABLATE_K, MAX_CONTEXT
    MODEL_ID = Path(args.model.rstrip("/")).name
    DEFAULT_THINKING = args.thinking == "on"
    DEFAULT_ABLATE = args.ablate == "on"
    ABLATE_K = max(1, args.ablate_k)
    MAX_CONTEXT = args.max_context
    if MAX_CONTEXT is None:
        cap = torch.cuda.get_device_capability()[0] if args.device == "cuda" else 99
        if args.dtype == "bfloat16" and cap < 8:
            MAX_CONTEXT = 3072    # bf16 在老卡上只剩 O(n²) math 注意力后端
            print("注意: Pascal 显卡不支持 bf16 高效注意力内核，prefill 为 O(n²) math 后端；"
                  f"已将输入上限设为 {MAX_CONTEXT}。需要长上下文请用 --dtype float16"
                  "（fp16 可走 memory-efficient 内核，注意力 O(n)；上限自动提到 8192，"
                  "受 KV cache 86KB/token 限制）")
        elif args.device == "cuda" and torch.cuda.get_device_properties(0).total_memory < 8 * 1024**3:
            MAX_CONTEXT = 8192    # fp16 高效内核可用，但 6GB 卡的 KV cache 是瓶颈
        else:
            MAX_CONTEXT = 16384
    dpath = Path(args.directions)
    if not dpath.is_absolute():
        dpath = Path(__file__).parent / dpath
    if dpath.exists():
        d = torch.load(dpath, weights_only=False)
        DIRECTION = d["directions_unit"][args.ablate_layer]
        print(f"消融方向: {dpath} layer {args.ablate_layer}（默认消融: {args.ablate}, 默认 k={ABLATE_K}）")
        if "harmful_train_acts" in d:
            X_h = d["harmful_train_acts"][:, args.ablate_layer]
            X_hl = d["harmless_train_acts"][:, args.ablate_layer]
            _, _, Vt = torch.linalg.svd((X_h - X_hl.mean(0)).float(), full_matrices=False)
            SUBSPACE_BASIS = Vt[:32].contiguous()   # 缓存到 32 维，供 --ablate-k / 请求级 ablate_k 切片
            print(f"子空间基已就绪: SVD 前 32 维（请求级 ablate_k 可取 1..32）")
        elif ABLATE_K > 1:
            raise SystemExit("--ablate-k>1 需要方向文件含 harmful_train_acts/harmless_train_acts")
    elif DEFAULT_ABLATE:
        raise SystemExit(f"--ablate on 但方向文件不存在: {dpath}")
    elif args.ablate == "off":
        print(f"注意: 方向文件 {dpath} 不存在，ablate_refusal 请求字段将无效")

    dtype = getattr(torch, args.dtype)
    print(f"加载模型: {args.model}  device={args.device} dtype={args.dtype}")
    tok = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        args.model, trust_remote_code=True, dtype=dtype, device_map=args.device)
    model.eval()
    if args.device == "cuda":
        print(f"显存占用: {torch.cuda.memory_allocated()/1e9:.1f} GB")
    print(f"服务启动: http://{args.host}:{args.port}  (OpenAI: /v1/chat/completions, Ollama: /api/chat, 思维链默认: {args.thinking})")
    uvicorn.run(app, host=args.host, port=args.port, log_level="warning")


if __name__ == "__main__":
    main()