class RuntimeSlot:
    """A loaded HB_HBMRuntime plus the metadata needed to build inputs."""

    def __init__(self, spec: ModelSpec):
        from hbm_runtime import HB_HBMRuntime

        self.rt = HB_HBMRuntime(spec.path)
        self.model_name = self.rt.model_names[0]
        self.input_names = list(self.rt.input_names[self.model_name])
        self.output_names = list(self.rt.output_names[self.model_name])

def bgr_to_nv12(img: np.ndarray) -> np.ndarray:
    """Convert a BGR image to packed NV12 (Y plane followed by interleaved UV)."""
    height, width = img.shape[:2]
    if height % 2 or width % 2:
        raise ValueError("NV12 requires even width/height")
    area = height * width
    yuv420p = cv2.cvtColor(img, cv2.COLOR_BGR2YUV_I420).reshape(area * 3 // 2)
    y = yuv420p[:area]
    u = yuv420p[area:area + area // 4].reshape(height // 2, width // 2)
    v = yuv420p[area + area // 4:].reshape(height // 2, width // 2)
    uv = np.stack((u, v), axis=-1).reshape(-1)     # U/V 交错
    return np.concatenate([y, uv]).astype(np.uint8)


def build_input_tensor(model_name: str, input_name: str, packed_nv12: np.ndarray) -> dict:
    """Wrap a packed NV12 buffer the way hbm_runtime.run() expects it."""
    return {model_name: {input_name: np.ascontiguousarray(packed_nv12, dtype=np.uint8)}}

def dequantize(tensor: np.ndarray, quant) -> np.ndarray:
    """Convert a quantized output tensor to float32 using its QuantParams."""
    if quant is None:
        return tensor.astype(np.float32, copy=False)
    qtype = str(getattr(quant, "quant_type", "")).split(".")[-1]
    if qtype not in ("SCALE", "1"):
        return tensor.astype(np.float32, copy=False)
    scale = np.asarray(getattr(quant, "scale", np.array([])), dtype=np.float32)
    zero_point = np.asarray(getattr(quant, "zero_point", np.array([])), dtype=np.float32)
    if scale.size == 0:
        return tensor.astype(np.float32, copy=False)
    t = tensor.astype(np.float32)
    if scale.size == 1:
        return (t - float(zero_point.reshape(-1)[0])) * float(scale.reshape(-1)[0])
    axis = int(getattr(quant, "axis", 0))
    shape = [1] * t.ndim
    shape[axis % t.ndim] = -1
    return (t - zero_point.reshape(shape)) * scale.reshape(shape)

if mode == "auto":
    total = float(values.sum())
    mode = "none" if values.min() >= -1e-3 and 0.9 <= total <= 1.1 else "softmax"

logits = cls_t.reshape(-1, num_classes)
# sigmoid 单调，所以 max-logit >= inv_sigmoid(thr) 等价于命中
raw_thr = _logit_threshold(score_thres)
cand = np.flatnonzero(logits.max(axis=1) >= raw_thr)
probs = sigmoid(logits[cand])
cls_ids = probs.argmax(axis=1)
scores = probs[np.arange(probs.shape[0]), cls_ids]
keep = cand[scores >= score_thres]
# DFL：对 16 个 bin 做 softmax 求期望，得到 left/top/right/bottom 距离
dist = box_t.reshape(-1, 4, DFL_BINS)[keep]
ltrb = np.sum(softmax(dist, axis=2) * np.arange(DFL_BINS), axis=2)
centers = gen_anchor(grid)[keep]
boxes = np.hstack([centers - ltrb[:, 0:2], centers + ltrb[:, 2:4]]) * stride

class ModelRunner:
    def ensure_loaded(self) -> None:
        if self.slot is not None:
            return
        with self._load_lock:
            if self.slot is None:
                self.slot = RuntimeSlot(self.spec)
                self._sem = threading.BoundedSemaphore(max(1, self.spec.workers))

    def infer(self, tensors, timeout: float = 20.0):
        self.ensure_loaded()
        if not self._sem.acquire(timeout=timeout):     # 限流，防止无限排队
            raise BusyError(f"{self.spec.name} saturated")
        try:
            outputs = self.slot.run(tensors)           # 多线程并发调 run() 是安全的
        finally:
            self._sem.release()

class RuntimeSlot:
    def __init__(self, spec: ModelSpec):
        from hbm_runtime import HB_HBMRuntime      # ← 唯一的入口，无路径 hack
        self.rt = HB_HBMRuntime(spec.path)

def runner(self, name: str, auto_register: bool = True) -> ModelRunner:
    with self._lock:
        runner = self._runners.get(name)
        if runner is not None:
            return runner
        spec = self.specs.get(name)
        if spec is None:
            if not auto_register:
                raise UnknownModelError(name)
            path = os.path.join(self.models_dir, f"{name}.bin")
            if not os.path.exists(path):
                raise UnknownModelError(name)
            spec = ModelSpec.from_config(name, {"path": path}, self.defaults)
            self.specs[name] = spec
        runner = ModelRunner(spec)
        self._runners[name] = runner
        return runner

def infer_image(self, name: str, image, opts: Optional[dict] = None) -> dict:
    """Inference on encoded image bytes or a BGR ndarray."""
    opts = dict(opts or {})
    runner = self.runner(name)
    runner.ensure_loaded()
    img = pre.decode_image(bytes(image)) if isinstance(image, (bytes, bytearray, memoryview)) else image
    input_h, input_w = int(runner.slot.input_shape[2]), int(runner.slot.input_shape[3])
    mode = opts.get("resize") or runner.spec.resize
    packed, meta = pre.preprocess(img, input_w, input_h, mode)        # BGR → packed NV12
    outputs, elapsed = runner.infer({runner.slot.input_names[0]: packed},
                                    timeout=float(opts.get("timeout", 20.0)))
    decoded = self._decode(runner, outputs, meta, img, opts)          # 反量化 → 解码 → NMS
    decoded.update({
        "model": name,
        "runtime_model": runner.model_name,
        "infer_ms": round(elapsed, 2),
        "image": {"width": meta.ori_w, "height": meta.ori_h, "resize": mode},
    })
    return decoded

def kind(self) -> str:
    """Resolve the decode task, inspecting tensor shapes when the config says 'auto'."""
    if self.spec.kind != "auto":
        return self.spec.kind
    self.ensure_loaded()
    shapes = self.slot.output_shapes
    if any(len(s) == 4 and s[0] == 1 and s[1] > 1 and s[-1] == 1 and s[-2] == 1 for s in shapes.values()):
        return "classification"
    if dec.is_yolov8_family(shapes):
        return "yolov8"
    # ... 再尝试 yolov5 / generic

if mode == "stretch":
    resized = cv2.resize(img, (input_w, input_h), interpolation=cv2.INTER_LINEAR)
    return resized, ResizeMeta(ori_w, ori_h, input_w, input_h, "stretch")

scale = min(input_w / ori_w, input_h / ori_h)
new_w, new_h = int(round(ori_w * scale)), int(round(ori_h * scale))
resized = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
pad_w = (input_w - new_w) / 2.0
pad_h = (input_h - new_h) / 2.0
top, left = int(round(pad_h - 0.1)), int(round(pad_w - 0.1))
bottom, right = input_h - new_h - top, input_w - new_w - left
out = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114,) * 3)

def scale_back(self, boxes: np.ndarray) -> np.ndarray:
    out = boxes.copy()
    if self.mode == "letterbox":
        out[:, [0, 2]] = (out[:, [0, 2]] - self.pad_w) / self.scale
        out[:, [1, 3]] = (out[:, [1, 3]] - self.pad_h) / self.scale
    else:
        out[:, [0, 2]] *= self.ori_w / self.input_w
        out[:, [1, 3]] *= self.ori_h / self.input_h
    return out

def do_POST(self) -> None:  # noqa: N802
    parsed = urllib.parse.urlparse(self.path)
    query = urllib.parse.parse_qs(parsed.query)
    path = parsed.path.rstrip("/")
    if not self._authorized(query):
        return self._send_json({"error": "unauthorized"}, 401)
    model = (query.get("model") or [""])[0]
    try:
        if path == "/v1/infer":
            return self._handle_infer(model, query)
        if path == "/v1/infer/nv12":
            return self._handle_infer_nv12(model, query)
        if path == "/v1/perf":
            return self._handle_perf(model, query)
    except UnknownModelError as exc:
        return self._send_json({"error": "unknown model", "model": str(exc)}, 404)
    except BusyError as exc:
        return self._send_json({"error": "busy", "detail": str(exc)}, 503)

def infer_nv12(self, name: str, buffer: bytes, width: int, height: int, opts=None) -> dict:
    """Inference straight from a packed NV12 frame (camera / video path)."""
    runner = self.runner(name)
    runner.ensure_loaded()
    exp_w, exp_h = pre.validate_nv12_size(tuple(runner.slot.input_shape), width, height)
    arr = np.frombuffer(buffer, dtype=np.uint8)
    need = exp_w * exp_h * 3 // 2
    if arr.size < need:
        raise ValueError(f"nv12 buffer too small: {arr.size} < {need}")
    meta = pre.ResizeMeta(exp_w, exp_h, exp_w, exp_h, "stretch")
    outputs, elapsed = runner.infer({runner.slot.input_names[0]: arr[:need]})
    ...