video_monitor/app/analysis/manager.py

"""全局分析管理器（单例）

阶段2：每路摄像头在独立子进程中运行 CameraPipeline；YOLO 推理可选走
主进程 InferenceProcessPool（共享 GPU/模型内存）。事件经 Queue → EventBridge 写库。
"""
import json
import logging
import multiprocessing as mp
import threading
import time
import uuid

from app.analysis.pipeline import CameraPipeline
from app.analysis.motion import MotionDetector
from app.analysis.worker_pool import DetectorWorkerPool
from app.analysis.process_worker import pipeline_process_main, PipelineProcessHandle
from app.analysis.event_bridge import get_event_bridge

logger = logging.getLogger("analysis.manager")


def _snapshot_storage_paths():
    """主进程解析报警快照目录，注入子进程（子进程不可 import GlobalUtils）。"""
    import os
    from framework.settings import BASE_DIR
    from app.utils.GlobalUtils import g_config
    static_dir = os.path.join(str(BASE_DIR), "static")
    alarm_dir = getattr(g_config, "storageAlarmDir", "") or os.path.join(static_dir, "storage", "alarm")
    return alarm_dir, static_dir


def _algorithm_to_spec(a, target_labels=None):
    labels = a.labels
    if isinstance(labels, str):
        try:
            labels = json.loads(labels)
        except Exception:
            labels = []
    return {
        "id": a.id,
        "name": a.name,
        "inference_engine": a.inference_engine,
        "model_file": a.model_file,
        "labels": labels,
        "input_width": a.input_width,
        "input_height": a.input_height,
        "conf_threshold": a.conf_threshold,
        "iou_threshold": a.iou_threshold,
        "algorithm_type": a.algorithm_type,
        "task_type": getattr(a, "task_type", "detect"),
        "device": getattr(a, "device", "cpu"),
        "target_labels": sorted(set(target_labels or [])),
    }


def _biz_algo_to_zone_dict(ba):
    from app.utils.Credentials import decrypt_credential
    labels = ba.target_labels or '[]'
    try:
        labels_list = json.loads(labels) if isinstance(labels, str) else labels
    except Exception:
        labels_list = []
    llm_cfg = None
    if ba.llm_id and ba.llm:
        llm_cfg = {
            "id": ba.llm_id,
            "api_url": ba.llm.api_url,
            "api_key": decrypt_credential(ba.llm.api_key),
            "model_name": ba.llm.model_name,
            "timeout": ba.llm.timeout,
            "inference_tool": ba.llm.inference_tool or "OpenAI",
        }
    return {
        "id": ba.id,
        "name": ba.name or "",
        "flow_type": ba.flow_type,
        "small_model_id": ba.small_model_id,
        "detector_model_id": ba.detector_model_id,
        "target_labels": labels_list,
        "llm_id": ba.llm_id,
        "llm_prompt": ba.llm_prompt or "",
        "llm_validate": ba.llm_validate or "",
        "post_process": ba.post_process or "AREA",
        "ref_angle": float(getattr(ba, "ref_angle", 90.0) or 90.0),
        "angle_tolerance": float(getattr(ba, "angle_tolerance", 45.0) or 45.0),
        "forward_count_threshold": int(getattr(ba, "forward_count_threshold", 0) or 0),
        "reverse_count_threshold": int(getattr(ba, "reverse_count_threshold", 0) or 0),
        "llm": llm_cfg,
    }


class AnalysisManager(object):
    _instance = None
    _instance_lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._instance_lock:
                if cls._instance is None:
                    cls._instance = super(AnalysisManager, cls).__new__(cls)
                    cls._instance._initialized = False
        return cls._instance

    def __init__(self):
        if getattr(self, "_initialized", False):
            return
        self._initialized = True
        self._pipelines = {}      # stream_id -> handle dict
        self._lock = threading.RLock()
        self._worker_pool = DetectorWorkerPool()
        self._mp_ctx = mp.get_context("spawn")
        self._status_manager = self._mp_ctx.Manager()
        self._status_dict = self._status_manager.dict()
        self._infer_req_q = self._mp_ctx.Queue(maxsize=128)
        # Never reuse a consumer queue after terminating a camera process:
        # multiprocessing.Queue's read lock can remain acquired on Windows.
        self._infer_routes = {}
        self._infer_routes_lock = threading.Lock()
        self._disabled_algos = set()
        self._infer_forwarder_running = True
        self._infer_forwarder = threading.Thread(
            target=self._inference_forwarder_loop, name="infer-forwarder", daemon=True)
        self._infer_forwarder.start()
        get_event_bridge()
        self._configure_from_settings()

    def _use_multiprocess(self):
        try:
            from app.utils.GlobalUtils import g_config
            mode = int(getattr(g_config, "analysisProcessMode", 1))
            return mode >= 1
        except Exception:
            return True

    def _use_shared_inference(self):
        try:
            from app.utils.GlobalUtils import g_config
            return bool(getattr(g_config, "analysisSharedInference", True))
        except Exception:
            return True

    def set_inference_config(self, shared=None, workers=None):
        """热更新推理配置（不持久化）。
        - shared: 切换共享推理开关；切换后需重启所有运行中的 pipeline
        - workers: 调整共享推理 worker 数；调整后重启 inference_pool
        返回 (ok, msg)
        """
        from app.utils.GlobalUtils import g_config
        old_shared = self._use_shared_inference()
        old_workers = int(getattr(g_config, "analysisInferenceWorkers", 2))
        shared_changed = False
        workers_changed = False
        if shared is not None:
            try:
                new_shared = bool(int(shared))
            except Exception:
                new_shared = old_shared
            if new_shared != old_shared:
                g_config.analysisSharedInference = new_shared
                shared_changed = True
        if workers is not None:
            try:
                new_workers = max(1, min(32, int(workers)))
            except Exception:
                new_workers = old_workers
            if new_workers != old_workers:
                g_config.analysisInferenceWorkers = new_workers
                workers_changed = True
        # 重启推理池（worker 数变了，或从非共享切到共享）
        if workers_changed or (shared_changed and self._use_shared_inference()):
            try:
                from app.analysis.inference_pool import shutdown_inference_pool, get_inference_pool
                shutdown_inference_pool()
                if self._use_shared_inference():
                    get_inference_pool()  # 会按新 worker 数重建
            except Exception as e:
                logger.warning("重启推理池失败: %s" % str(e))
        # shared 切换后重启所有运行中的 pipeline，让新模式生效
        if shared_changed:
            with self._lock:
                sids = list(self._pipelines.keys())
            for sid in sids:
                try:
                    from app.models import StreamModel as _SM
                    s = _SM.objects.get(id=sid)
                    self.stop(sid)
                    self.start(s)
                except Exception as e:
                    logger.warning("shared 切换重启 pipeline sid=%s 失败: %s" % (sid, str(e)))
        if not shared_changed and not workers_changed:
            return True, "配置未变化"
        return True, "配置已热生效"

    def set_algo_instance_enabled(self, algo_id, enabled):
        """设置业务算法的实例化开关（内存，重启丢失）。立即生效，无需重启 pipeline。"""
        try:
            aid = int(algo_id)
        except Exception:
            return False, "invalid algorithm_id"
        with self._lock:
            if enabled:
                self._disabled_algos.discard(aid)
            else:
                self._disabled_algos.add(aid)
        return True, "ok"

    def is_algo_instance_enabled(self, algo_id):
        try:
            aid = int(algo_id)
        except Exception:
            return True
        return aid not in self._disabled_algos

    def get_disabled_algos(self):
        with self._lock:
            return set(self._disabled_algos)

    def restart_algo_instance(self, algo_id):
        """重启使用指定算法的所有 pipeline（重新加载引擎）。
        algo_id 是小模型 AlgorithmModel.id。
        """
        try:
            aid = int(algo_id)
        except Exception:
            return False, "invalid algorithm_id"
        with self._lock:
            sids = []
            for sid, item in list(self._pipelines.items()):
                algo_ids = item.get("algorithm_ids") or []
                if aid in algo_ids:
                    sids.append(sid)
        if not sids:
            return True, "没有运行中的 pipeline 使用该算法"
        restarted = 0
        for sid in sids:
            try:
                from app.models import StreamModel as _SM
                s = _SM.objects.get(id=sid)
                self.stop(sid)
                self.start(s)
                restarted += 1
            except Exception as e:
                logger.warning("restart_algo_instance sid=%s 失败: %s" % (sid, str(e)))
        return True, "已重启 %d 路 pipeline" % restarted

    def restart_inference_pool(self):
        """重启整个推理池（清除所有 worker 子进程内的引擎缓存）。"""
        try:
            from app.analysis.inference_pool import shutdown_inference_pool, get_inference_pool
            shutdown_inference_pool()
            if self._use_shared_inference():
                get_inference_pool()
            return True, "推理池已重启，所有引擎缓存已清除"
        except Exception as e:
            return False, str(e)

    def _inference_forwarder_loop(self):
        from app.analysis.inference_pool import get_inference_pool
        import queue as _q
        while self._infer_forwarder_running:
            try:
                msg = self._infer_req_q.get(timeout=0.5)
            except _q.Empty:
                continue
            if msg is None:
                break
            req_id = msg.get("req_id")
            channel = msg.get("response_channel")
            with self._infer_routes_lock:
                if channel not in self._infer_routes:
                    continue  # The originating pipeline has already stopped.
            try:
                jpeg = msg.get("jpeg")
                algo = msg.get("algorithm") or {}
                # 禁用实例化的算法直接返回空结果，跳过推理
                algo_id = algo.get("id", 0)
                try:
                    if algo_id and int(algo_id) in self._disabled_algos:
                        self._send_inference_response(channel, {"req_id": req_id, "ok": True, "detections": []})
                        continue
                except Exception:
                    pass
                # 直接透传 JPEG bytes 给推理池，避免主进程 imdecode + imencode 双重编解码，
                # 消除主进程 GIL 占用（解码在 worker 子进程内完成）。
                pool = get_inference_pool()  # Config changes may replace the pool.
                dets = pool.detect_jpeg(jpeg, algo, timeout=30.0, raise_errors=True)
                self._send_inference_response(channel, {"req_id": req_id, "ok": True, "detections": dets})
            except Exception as e:
                logger.warning("推理转发失败: %s", e)
                try:
                    self._send_inference_response(channel, {"req_id": req_id, "ok": False, "error": str(e)})
                except Exception:
                    pass

    def _send_inference_response(self, channel, response):
        with self._infer_routes_lock:
            response_queue = self._infer_routes.get(channel)
            if response_queue is not None:
                response_queue.put(response, timeout=1.0)

    def _close_inference_channel(self, item):
        with self._infer_routes_lock:
            response_queue = self._infer_routes.pop(item.get("response_channel"), None)
        if response_queue is not None:
            response_queue.cancel_join_thread()
            response_queue.close()

    def _configure_from_settings(self):
        try:
            from app.models import AlgorithmModel
            default = AlgorithmModel.objects.filter(is_default=1, state=1).first()
            if default:
                self._default_algorithm = default
                self._target_fps = 5
                return
        except Exception as e:
            logger.warning("AnalysisManager 读取默认 AlgorithmModel 失败: %s" % str(e))
        try:
            from app.utils.GlobalUtils import g_config
            self._target_fps = int(getattr(g_config, "analysisTargetFps", 5))
        except Exception:
            self._target_fps = 5
        self._default_algorithm = None

    @staticmethod
    def build_rtsp_url(stream):
        try:
            from app.utils.GlobalUtils import g_config
            ip = getattr(g_config, "externalHost", "127.0.0.1") or "127.0.0.1"
            if ip == "0.0.0.0":
                ip = "127.0.0.1"
            port = getattr(g_config, "mediaRtspPort", 10554)
            app = getattr(stream, "app", "live") or "live"
            name = getattr(stream, "name", getattr(stream, "code", "stream")) or "stream"
            return "rtsp://%s:%s/%s/%s" % (ip, int(port), app, name)
        except Exception as e:
            logger.warning("build_rtsp_url 失败: %s" % str(e))
            return ""

    @staticmethod
    def _zone_analyze_fps(interval_sec, detect_frames):
        interval = max(0.1, float(interval_sec or 1))
        frames = max(1, int(detect_frames or 1))
        return float(frames) / interval

    @staticmethod
    def _compute_analyze_fps(stream_id, fallback=None):
        """取该摄像头所有启用布控中最高的算法分析频率（帧/秒）"""
        try:
            from app.models import ZoneModel
            qs = ZoneModel.objects.filter(stream_id=stream_id, state=1)
            max_fps = 0.0
            for z in qs:
                max_fps = max(max_fps, AnalysisManager._zone_analyze_fps(
                    getattr(z, "detect_interval_sec", 1),
                    getattr(z, "detect_frames", 1),
                ))
            if max_fps > 0:
                return max_fps
        except Exception as e:
            logger.warning("_compute_analyze_fps err stream=%s: %s" % (stream_id, str(e)))
        if fallback is not None and fallback > 0:
            return float(fallback)
        return 1.0

    @staticmethod
    def _load_zones(stream_id, active_only=True, zone_id=None):
        try:
            from app.models import ZoneModel
            qs = ZoneModel.objects.filter(stream_id=stream_id)
            if active_only:
                qs = qs.filter(state=1)
            if zone_id is not None:
                qs = qs.filter(id=int(zone_id))
            qs = qs.prefetch_related(
                'algorithms', 'algorithms__small_model', 'algorithms__detector_model', 'algorithms__llm')
            zones = []
            for z in qs:
                try:
                    coords = json.loads(z.coordinates)
                except Exception:
                    coords = []
                # LINE_CROSS 警戒线端点（归一化坐标 JSON）
                line_a = None
                line_b = None
                try:
                    la = getattr(z, "line_a", "") or ""
                    if la:
                        line_a = json.loads(la)
                    lb = getattr(z, "line_b", "") or ""
                    if lb:
                        line_b = json.loads(lb)
                except Exception:
                    line_a = line_b = None
                biz_list = []
                biz_ids = []
                small_ids = set()
                for ba in z.algorithms.filter(state=1):
                    biz_ids.append(ba.id)
                    biz_list.append(_biz_algo_to_zone_dict(ba))
                    if int(ba.flow_type or 0) == 4:
                        if ba.detector_model_id:
                            small_ids.add(ba.detector_model_id)
                    elif ba.small_model_id:
                        small_ids.add(ba.small_model_id)
                interval = max(0.1, float(getattr(z, "detect_interval_sec", 1) or 1))
                frames = max(1, int(getattr(z, "detect_frames", 1) or 1))
                zones.append({
                    "id": z.id,
                    "name": z.name,
                    "coords": coords,
                    "is_required": z.is_required,
                    "loiter_threshold": z.loiter_threshold,
                    "detect_interval_sec": interval,
                    "detect_frames": frames,
                    "alarm_repeat_sec": max(0.0, float(getattr(z, "alarm_repeat_sec", 30) or 0)),
                    "color": z.color or "#169F85",
                    "line_a": line_a,
                    "line_b": line_b,
                    "density_threshold": int(getattr(z, "density_threshold", 0) or 0),
                    "algorithm_ids": biz_ids,
                    "biz_algorithms": biz_list,
                    "small_model_ids": sorted(small_ids),
                })
            return zones
        except Exception as e:
            logger.warning("加载 Zone 失败 stream=%s: %s" % (stream_id, str(e)))
            return []

    def _resolve_algorithms_for_stream(self, stream):
        try:
            from app.models import ZoneModel, AlgorithmModel
            algos = []
            seen = set()
            for z in ZoneModel.objects.filter(stream_id=stream.id, state=1).prefetch_related(
                    'algorithms__small_model', 'algorithms__detector_model'):
                for ba in z.algorithms.filter(state=1):
                    if int(ba.flow_type or 0) == 4:
                        det = ba.detector_model
                        if det and det.state == 1 and det.id not in seen:
                            seen.add(det.id)
                            algos.append(det)
                        continue
                    sm = ba.small_model
                    if sm and sm.state == 1 and sm.id not in seen:
                        seen.add(sm.id)
                        algos.append(sm)
            sa = getattr(stream, "algorithm", None)
            if sa is not None and sa.state == 1 and sa.id not in seen:
                seen.add(sa.id)
                algos.append(sa)
            if not algos:
                d = AlgorithmModel.objects.filter(is_default=1, state=1).first()
                if d:
                    algos.append(d)
            return algos
        except Exception as e:
            logger.warning("_resolve_algorithms_for_stream err: %s" % str(e))
            return []

    def _fallback_engine_from_config(self):
        try:
            from app.utils.GlobalUtils import g_config
            model_path = getattr(g_config, "analysisDetectorModel", "") or ""
            if not model_path:
                return None
            labels = getattr(g_config, "analysisDetectorLabels", [])
            if isinstance(labels, str):
                labels = [x.strip() for x in labels.split(",") if x.strip()]
            conf = float(getattr(g_config, "analysisConfThreshold", 0.4))
            from app.analysis.engines.onnx_engine import OnnxEngine
            eng = OnnxEngine(model_path=model_path, labels=labels, conf_threshold=conf)
            if eng.load():
                return eng
        except Exception as e:
            logger.warning("config fallback engine err: %s" % str(e))
        return None

    def _start_process(self, stream, url, zones, algos, detectors_legacy=None,
                       preview_only=False, analyze_fps_override=None):
        sid = stream.id
        self._status_dict.pop(str(sid), None)
        event_queue = self._mp_ctx.Queue(maxsize=256)
        cmd_queue = self._mp_ctx.Queue(maxsize=16)
        bridge = get_event_bridge()
        bridge.register_queue(event_queue)

        target_by_model = {}
        for zone in zones:
            for rule in zone.get("biz_algorithms") or []:
                model_id = rule.get("detector_model_id") if int(rule.get("flow_type") or 0) == 4 else rule.get("small_model_id")
                if model_id:
                    target_by_model.setdefault(int(model_id), set()).update(rule.get("target_labels") or [])
        algo_specs = [_algorithm_to_spec(a, target_by_model.get(int(a.id), set())) for a in algos]
        analyze_fps = (float(analyze_fps_override) if analyze_fps_override is not None
                       else self._compute_analyze_fps(sid, fallback=self._target_fps))
        storage_alarm_dir, static_dir = _snapshot_storage_paths()
        response_channel = uuid.uuid4().hex
        infer_resp_q = self._mp_ctx.Queue(maxsize=128)
        with self._infer_routes_lock:
            self._infer_routes[response_channel] = infer_resp_q
        config = {
            "stream_id": sid,
            "stream_code": getattr(stream, "code", str(sid)),
            "rtsp_url": url,
            "target_fps": self._target_fps,
            "analyze_fps": analyze_fps,
            "zones": zones,
            "algorithms": algo_specs,
            "use_shared_inference": self._use_shared_inference(),
            "storage_alarm_dir": storage_alarm_dir,
            "static_dir": static_dir,
            "response_channel": response_channel,
            "preview_only": bool(preview_only),
        }
        proc = self._mp_ctx.Process(
            target=pipeline_process_main,
            args=(config, event_queue, cmd_queue, self._status_dict,
                  self._infer_req_q, infer_resp_q),
            name="pipeline-%s" % sid,
            daemon=True,
        )
        try:
            proc.start()
        except Exception:
            self._close_inference_channel({"response_channel": response_channel})
            bridge.unregister_queue(event_queue)
            raise
        handle = PipelineProcessHandle(sid, proc, event_queue, cmd_queue, self._status_dict)
        self._pipelines[sid] = {
            "handle": handle,
            "process": proc,
            "event_queue": event_queue,
            "mode": "process",
            "running": True,
            "pipeline": None,
            "thread": None,
            "algorithm_ids": sorted([a.id for a in algos]),
            "preview_only": bool(preview_only),
            "response_channel": response_channel,
            "analyze_fps": analyze_fps,
        }
        return True, "started (process)"

    def _start_thread(self, stream, url, zones, algos, preview_only=False,
                      analyze_fps_override=None):
        sid = stream.id
        detectors = []
        algo_names = []
        for a in algos:
            labels = set()
            for z in zones:
                for rule in z.get("biz_algorithms") or []:
                    model_id = (rule.get("detector_model_id") if int(rule.get("flow_type") or 0) == 4
                                else rule.get("small_model_id"))
                    if int(model_id or 0) == int(a.id):
                        labels.update(rule.get("target_labels") or [])
            eng = self._worker_pool.get_detector(_algorithm_to_spec(a, labels))
            if eng:
                detectors.append({"algorithm_id": a.id, "algorithm_name": a.name,
                                  "engine": eng, "target_labels": sorted(labels)})
                algo_names.append(a.name)
        if not algos:
            eng = self._fallback_engine_from_config()
            if eng:
                detectors.append({"algorithm_id": 0, "algorithm_name": "config-fallback", "engine": eng})
                algo_names.append("config-fallback")

        motion = MotionDetector()
        analyze_fps = (float(analyze_fps_override) if analyze_fps_override is not None
                       else self._compute_analyze_fps(sid, fallback=self._target_fps))
        storage_alarm_dir, static_dir = _snapshot_storage_paths()
        pipeline = CameraPipeline(
            stream_id=sid,
            stream_code=getattr(stream, "code", str(sid)),
            rtsp_url=url,
            detectors=detectors,
            motion=motion,
            target_fps=self._target_fps,
            analyze_fps=analyze_fps,
            on_event=self._on_event,
            on_track_snapshot=self._on_track_snapshot,
            on_preview=lambda payload: get_event_bridge()._on_preview(payload),
            alarm_enabled=not bool(preview_only),
            zone_polygons=zones,
            storage_alarm_dir=storage_alarm_dir,
            static_dir=static_dir,
        )
        pipeline._algorithm_name = ", ".join(algo_names) if algo_names else "motion-only"
        t = threading.Thread(target=pipeline.run, name="pipeline-%s" % sid, daemon=True)
        self._pipelines[sid] = {
            "pipeline": pipeline,
            "thread": t,
            "running": True,
            "mode": "thread",
            "algorithm_ids": sorted([a.id for a in algos]),
            "preview_only": bool(preview_only),
            "analyze_fps": analyze_fps,
        }
        t.start()
        return True, "started (thread)"

    def start(self, stream):
        from monitor_runtime.licensing import require_license
        require_license()
        sid = stream.id
        with self._lock:
            item = self._pipelines.get(sid)
            if item and item.get("running"):
                alive = True
                if item.get("mode") == "process":
                    proc = item.get("process")
                    alive = proc is not None and proc.is_alive()
                else:
                    th = item.get("thread")
                    alive = th is not None and th.is_alive()
                if alive:
                    if not item.get("preview_only"):
                        return True, "already running"
                    # 正式启动接管由预览创建的临时管线。
                    self.stop(sid)
                    item = None
                # 僵尸条目：进程/线程已退出但未清理
                try:
                    if item.get("mode") == "process":
                        self._close_inference_channel(item)
                        eq = item.get("event_queue")
                        if eq:
                            get_event_bridge().unregister_queue(eq)
                    else:
                        pipe = item.get("pipeline")
                        if pipe:
                            pipe.stop()
                except Exception:
                    pass
                self._pipelines.pop(sid, None)
            url = self.build_rtsp_url(stream)
            if not url:
                return False, "no rtsp url"
            algos = self._resolve_algorithms_for_stream(stream)
            zones = self._load_zones(sid)
            if self._use_multiprocess():
                ok, msg = self._start_process(stream, url, zones, algos)
            else:
                ok, msg = self._start_thread(stream, url, zones, algos)
            if ok:
                time.sleep(0.35)
                if not self.is_running(sid):
                    self._purge_pipeline(sid)
                    return False, "analysis subprocess exited (check OpenCV / RTSP / log)"
            return ok, msg

    def start_preview(self, zone):
        """确保所选布控有检测管线；停用布控使用不写报警的临时管线。"""
        from monitor_runtime.licensing import require_license
        require_license()
        stream = zone.stream
        sid = stream.id
        with self._lock:
            item = self._pipelines.get(sid)
            if self._is_pipeline_alive(item):
                if not item.get("preview_only") and "preview_restore_fps" not in item:
                    base_fps = float(item.get("analyze_fps") or self._compute_analyze_fps(sid, 1))
                    item["preview_restore_fps"] = base_fps
                    boosted_fps = max(5.0, base_fps)
                    if item.get("mode") == "process" and item.get("handle"):
                        item["handle"].set_analyze_fps(boosted_fps)
                    elif item.get("pipeline"):
                        item["pipeline"].set_analyze_fps(boosted_fps)
                return True, "preview" if item.get("preview_only") else "formal"
            if item:
                self._purge_pipeline(sid)
            algos = []
            seen = set()
            for ba in zone.algorithms.filter(state=1).select_related("small_model", "detector_model"):
                model = ba.detector_model if int(ba.flow_type or 0) == 4 else ba.small_model
                if model and model.state == 1 and model.id not in seen:
                    seen.add(model.id)
                    algos.append(model)
            if not algos:
                return False, "布控未绑定可用的小模型"
            zones = self._load_zones(sid, active_only=False, zone_id=zone.id)
            url = self.build_rtsp_url(stream)
            if not url:
                return False, "no rtsp url"
            fps = max(5.0, self._zone_analyze_fps(zone.detect_interval_sec, zone.detect_frames))
            if self._use_multiprocess():
                ok, msg = self._start_process(stream, url, zones, algos,
                                              preview_only=True, analyze_fps_override=fps)
            else:
                ok, msg = self._start_thread(stream, url, zones, algos,
                                             preview_only=True, analyze_fps_override=fps)
            if ok:
                time.sleep(0.35)
                if not self.is_running(sid):
                    self._purge_pipeline(sid)
                    return False, "预览分析子进程启动失败，请检查视频流或模型日志"
            return ok, msg

    def stop_preview(self, stream_id):
        """只释放预览创建的管线，不影响正式布控。"""
        with self._lock:
            item = self._pipelines.get(int(stream_id))
            if not item:
                return False
            if not item.get("preview_only"):
                restore_fps = item.pop("preview_restore_fps", None)
                if restore_fps is not None:
                    if item.get("mode") == "process" and item.get("handle"):
                        item["handle"].set_analyze_fps(restore_fps)
                    elif item.get("pipeline"):
                        item["pipeline"].set_analyze_fps(restore_fps)
                return False
        self.stop(int(stream_id))
        get_event_bridge().clear_preview(int(stream_id))
        return True

    def preview_mode(self, stream_id):
        with self._lock:
            item = self._pipelines.get(int(stream_id))
            if not self._is_pipeline_alive(item):
                return "stopped"
            return "preview" if item.get("preview_only") else "formal"

    def stop(self, stream_id):
        with self._lock:
            item = self._pipelines.get(stream_id)
            if not item:
                return False, "not running"
            if item.get("mode") == "process":
                handle = item.get("handle")
                if handle:
                    handle.stop()
                self._close_inference_channel(item)
                eq = item.get("event_queue")
                if eq:
                    get_event_bridge().unregister_queue(eq)
            else:
                item["pipeline"].stop()
                item["thread"].join(timeout=3)
            item["running"] = False
            self._pipelines.pop(stream_id, None)
            return True, "stopped"

    def is_running(self, stream_id):
        with self._lock:
            item = self._pipelines.get(stream_id)
            return self._is_pipeline_alive(item)

    def _is_pipeline_alive(self, item):
        if not item or not item.get("running"):
            return False
        if item.get("mode") == "process":
            proc = item.get("process")
            return proc is not None and proc.is_alive()
        th = item.get("thread")
        if th is not None and not th.is_alive():
            return False
        pipe = item.get("pipeline")
        if pipe is not None and not getattr(pipe, "_running", False):
            return False
        return True

    def _purge_pipeline(self, stream_id):
        item = self._pipelines.pop(stream_id, None)
        if not item:
            return
        try:
            if item.get("mode") == "process":
                eq = item.get("event_queue")
                if eq:
                    get_event_bridge().unregister_queue(eq)
                handle = item.get("handle")
                if handle:
                    try:
                        handle.stop(timeout=1)
                    except Exception:
                        pass
                self._close_inference_channel(item)
            else:
                pipe = item.get("pipeline")
                if pipe:
                    try:
                        pipe.stop()
                    except Exception:
                        pass
        except Exception:
            pass

    def list_running(self):
        with self._lock:
            alive = []
            for sid, item in list(self._pipelines.items()):
                if self._is_pipeline_alive(item) and not item.get("preview_only"):
                    alive.append(sid)
                elif not self._is_pipeline_alive(item):
                    self._purge_pipeline(sid)
            return alive

    def _enrich_pipeline_status(self, stream_id, info):
        """补充流健康状态与摄像头名称（不自动启停分析）。"""
        if not info:
            return info
        try:
            from app.models import StreamModel
            s = StreamModel.objects.filter(id=stream_id).first()
            if s:
                info["stream_name"] = s.nickname or s.name or ("#%s" % stream_id)
        except Exception:
            pass
        health = info.get("stream_health") or "ok"
        stalled = float(info.get("stalled_sec") or 0)
        fps = float(info.get("analysis_fps") or 0)
        if health == "ok" and fps <= 0 and stalled >= 20:
            info["stream_health"] = "stalled"
            health = "stalled"
        info["healthy"] = health == "ok" and (
            info.get("analysis_health") == "running" if "analysis_health" in info else fps > 0.05)
        if not info.get("active_zone_ids") and self.is_running(stream_id):
            try:
                zones = self._load_zones(stream_id)
                info["active_zone_ids"] = sorted([int(z["id"]) for z in zones if z.get("id") is not None])
            except Exception:
                info["active_zone_ids"] = []
        return info

    def get_pipeline_info(self, stream_id):
        with self._lock:
            item = self._pipelines.get(stream_id)
            if not item:
                return None
            if item.get("mode") == "process":
                handle = item.get("handle")
                if handle:
                    st = handle.status()
                    if st:
                        return self._enrich_pipeline_status(stream_id, st)
                alive = self.is_running(stream_id)
                return self._enrich_pipeline_status(stream_id, {
                    "stream_id": stream_id,
                    "running": alive,
                    "stream_health": "connecting" if alive else "stopped",
                    "analysis_fps": 0.0,
                    "stalled_sec": 0,
                })
            pipe = item.get("pipeline")
            if not pipe:
                return None
            try:
                return self._enrich_pipeline_status(stream_id, pipe.status())
            except Exception as e:
                logger.warning("get_pipeline_info err: %s" % str(e))
                return self._enrich_pipeline_status(stream_id, {
                    "stream_id": stream_id,
                    "running": False,
                    "stream_health": "stalled",
                    "analysis_fps": 0.0,
                    "stalled_sec": 0,
                })

    def reload_zones(self, stream_id):
        with self._lock:
            item = self._pipelines.get(stream_id)
            if not item:
                return False
            zones = self._load_zones(stream_id)
            analyze_fps = self._compute_analyze_fps(stream_id, fallback=self._target_fps)
            new_small_ids = sorted({sid for z in zones for sid in z.get("small_model_ids", []) if sid})
            cur_algo_ids = sorted(item.get("algorithm_ids") or [])
            if item.get("mode") == "process":
                if new_small_ids != cur_algo_ids:
                    handle = item.get("handle")
                    if handle:
                        handle.stop()
                    eq = item.get("event_queue")
                    if eq:
                        get_event_bridge().unregister_queue(eq)
                    self._pipelines.pop(stream_id, None)
                    try:
                        from app.models import StreamModel as _SM
                        s = _SM.objects.get(id=stream_id)
                        self.start(s)
                    except Exception as e:
                        logger.warning("reload_zones 重启失败 stream=%s: %s" % (stream_id, str(e)))
                else:
                    handle = item.get("handle")
                    if handle:
                        handle.reload_zones(zones, analyze_fps=analyze_fps)
                return True
            pipe = item.get("pipeline")
            if not pipe:
                return False
            if hasattr(pipe, "set_zone_polygons"):
                pipe.set_zone_polygons(zones)
            else:
                pipe.zone_polygons = zones
            pipe.set_analyze_fps(analyze_fps)
            pipe.reset_zone_runtime_state()
            if new_small_ids != cur_algo_ids:
                pipe.stop()
                item["running"] = False
                try:
                    item["thread"].join(timeout=3)
                except Exception:
                    pass
                self._pipelines.pop(stream_id, None)
                try:
                    from app.models import StreamModel as _SM
                    s = _SM.objects.get(id=stream_id)
                    self.start(s)
                except Exception as e:
                    logger.warning("reload_zones 重启失败 stream=%s: %s" % (stream_id, str(e)))
            return True

    def _on_event(self, event):
        try:
            from app.services.alarm_service import write_alarm, ALARM_EVENT_TYPES
            etype = event.get("type", "")
            if etype in ALARM_EVENT_TYPES:
                write_alarm(event)
        except Exception as e:
            logger.exception("事件处理失败: %s ev=%s" % (str(e), str(event)[:200]))

    def _on_track_snapshot(self, stream_id, frame_index, active, has_motion):
        # 已停用：不再写追踪快照
        pass

    @staticmethod
    def _severity_for(event):
        t = event.get("type")
        if t in ("loiter", "cross_camera"):
            return 1
        if t in ("entered_zone", "left_zone", "object_start"):
            return 2
        return 3

def shutdown_analysis():
    """Stop existing resources without constructing a new pool."""
    instance = AnalysisManager._instance
    if instance and getattr(instance, '_initialized', False):
        for sid in list(instance._pipelines):
            instance.stop(sid)
        instance._infer_forwarder_running = False
        instance._infer_forwarder.join(timeout=3)
        from app.analysis.inference_pool import shutdown_inference_pool
        shutdown_inference_pool()
        instance._status_manager.shutdown()
        instance._initialized = False
        AnalysisManager._instance = None