video_monitor/app/views/ControlView.py

"""Monitor · 布控管理 Web 层

页面：
- /control/index            布控管理（按摄像头绘制多边形区域）

API：
- /control/openIndex/openAdd/openEdit/openDel/openPageData/openRecentAlarms
"""
from app.views.ViewsBase import *
from django.shortcuts import render

from app.models import StreamModel, ZoneModel, AlarmModel, BizAlgorithmModel
import json as _json
import time as _time

LINE_POSTS = (BizAlgorithmModel.POST_LINE_CROSS, BizAlgorithmModel.POST_LINE_COUNT)
REGION_POSTS = (
    BizAlgorithmModel.POST_AREA,
    BizAlgorithmModel.POST_DWELL,
    BizAlgorithmModel.POST_DENSITY,
    BizAlgorithmModel.POST_DIRECTION,
)


def _parse_zone_algo_ids(raw):
    if isinstance(raw, list):
        return [int(x) for x in raw if str(x).strip()]
    if isinstance(raw, str):
        try:
            arr = _json.loads(raw)
            if isinstance(arr, list):
                return [int(x) for x in arr if str(x).strip()]
        except Exception:
            pass
        return [int(s) for s in raw.split(",") if s.strip()]
    return []


def _validate_zone_geometry(params, algo_ids=None):
    """校验布控绘制与所选业务算法是否匹配。"""
    is_required = int(params.get("is_required", 1) or 0)
    coords_raw = params.get("coordinates", "[]")
    try:
        coords = _json.loads(coords_raw) if isinstance(coords_raw, str) else (coords_raw or [])
    except Exception:
        coords = []
    if not isinstance(coords, list):
        coords = []

    line_a = (params.get("line_a") or "").strip()
    line_b = (params.get("line_b") or "").strip()

    ids = algo_ids if algo_ids is not None else _parse_zone_algo_ids(params.get("algorithm_ids"))
    posts = set()
    if ids:
        posts = set(
            BizAlgorithmModel.objects.filter(id__in=ids, state=1).values_list("post_process", flat=True)
        )

    needs_line = bool(posts & set(LINE_POSTS))
    needs_region = bool(is_required and (not posts or posts & set(REGION_POSTS) or needs_line))

    if needs_line and (not line_a or not line_b):
        raise ValueError("所选越线类算法需绘制方向线 A→B")

    if needs_region and len(coords) < 3:
        raise ValueError("必需区域已开启，请绘制布控区域（至少 3 个点）")

    if not is_required and posts & set(REGION_POSTS):
        raise ValueError("区域类后处理（区域入侵/滞留/密度/方向）需开启「必需区域」并绘制区域")

    return True

CONTROL_ALARM_EVENT_TYPES = ('entered_zone', 'loiter')

# ---------- 状态接口内存缓存 ----------
# 布控页/控制面板高频轮询 openStatus，原始实现每次都遍历所有运行实例 +
# 查 DB，布控执行时叠加 SQLite 锁会导致页面卡顿。
# 这里加一个带 TTL 的进程内缓存，多个请求共享同一份快照。
_STATUS_CACHE = {"lite": {"t": 0, "data": None}, "full": {"t": 0, "data": None}}
_STATUS_CACHE_TTL = 2.0  # 秒：缓存有效期，2s 内重复请求直接返回缓存


def _get_cached_status(lite=False):
    key = "lite" if lite else "full"
    entry = _STATUS_CACHE.get(key)
    now = _time.time()
    if entry and entry["data"] is not None and (now - entry["t"]) < _STATUS_CACHE_TTL:
        return entry["data"]
    return None


def _set_cached_status(data, lite=False):
    key = "lite" if lite else "full"
    _STATUS_CACHE[key] = {"t": _time.time(), "data": data}


def _parse_control_detect_rate(params):
    try:
        interval = float(params.get("detect_interval_sec", 1) or 1)
    except (TypeError, ValueError):
        interval = 1.0
    try:
        frames = int(params.get("detect_frames", 1) or 1)
    except (TypeError, ValueError):
        frames = 1
    interval = max(0.1, min(86400.0, interval))
    frames = max(1, min(999, frames))
    return interval, frames


def _parse_alarm_repeat(params, default=30.0):
    try:
        value = float(params.get("alarm_repeat_sec", default))
    except (TypeError, ValueError):
        value = default
    return max(0.0, min(86400.0, value))


def _control_to_dict(z):
    algos = []
    try:
        algos = [{"id": a.id, "name": a.name} for a in z.algorithms.all().order_by('id')]
    except Exception:
        pass
    stream = getattr(z, "stream", None)
    interval = max(0.1, float(getattr(z, "detect_interval_sec", 1) or 1))
    frames = max(1, int(getattr(z, "detect_frames", 1) or 1))
    return {
        "id": z.id,
        "stream_id": z.stream_id,
        "stream_name": (stream.nickname if stream else ""),
        "name": z.name,
        "coordinates": z.coordinates,
        "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,
        "line_a": getattr(z, "line_a", "") or "",
        "line_b": getattr(z, "line_b", "") or "",
        "density_threshold": int(getattr(z, "density_threshold", 0) or 0),
        "algorithms": algos,
        "algorithm_ids": [a["id"] for a in algos],
        "state": int(getattr(z, "state", 1) or 0),
        "create_time": str(z.create_time),
    }


def _control_queryset(stream_id=None):
    qs = ZoneModel.objects.select_related("stream").prefetch_related("algorithms").order_by("-id")
    if stream_id:
        qs = qs.filter(stream_id=int(stream_id))
    return qs


def build_analysis_status_data(lite=False):
    """汇总分析运行状态；lite 模式跳过引擎探测等重操作，供布控页轮询。"""
    # 命中缓存则直接返回，避免每次都遍历运行实例 + 查 DB
    cached = _get_cached_status(lite=lite)
    if cached is not None:
        return cached
    from app.analysis.manager import AnalysisManager
    m = AnalysisManager()
    shared_inference = m._use_shared_inference() and m._use_multiprocess()
    multi_process = m._use_multiprocess()
    running = []
    for sid in m.list_running():
        info = m.get_pipeline_info(sid)
        if info:
            running.append(info)
    # 收集运行中 pipeline 的 stream_name 映射，供引擎实例详情使用
    stream_name_map = {}
    for r in running:
        sid = r.get("stream_id")
        if sid:
            stream_name_map[sid] = r.get("stream_name") or r.get("algorithm_name") or ("#%s" % sid)
    algo_usage = {}
    for r in running:
        sid = r.get("stream_id")
        sname = stream_name_map.get(sid, "")
        for d in (r.get("detectors") or []):
            aid = d.get("algorithm_id")
            if aid is None:
                continue
            u = algo_usage.setdefault(
                aid,
                {
                    "algorithm_id": aid,
                    "algorithm_name": d.get("algorithm_name", ""),
                    "engine": d.get("engine", ""),
                    "stream_count": 0,
                    "stream_names": [],
                },
            )
            u["stream_count"] += 1
            if sname and sname not in u["stream_names"]:
                u["stream_names"].append(sname)
    # 补充小模型详情 + 反查业务算法
    if algo_usage:
        try:
            from app.models import AlgorithmModel, BizAlgorithmModel
            sm_qs = AlgorithmModel.objects.filter(id__in=list(algo_usage.keys()))
            sm_map = {sm.id: sm for sm in sm_qs}
            # 反查业务算法（通过 small_model 外键）
            biz_qs = BizAlgorithmModel.objects.filter(
                small_model_id__in=list(algo_usage.keys()), state=1
            ).select_related("small_model")
            biz_by_sm = {}
            for ba in biz_qs:
                biz_by_sm.setdefault(ba.small_model_id, []).append({
                    "id": ba.id, "name": ba.name, "flow_type": ba.flow_type,
                })
            for aid, u in algo_usage.items():
                sm = sm_map.get(aid)
                if sm:
                    u["model_file"] = sm.model_file
                    u["task_type"] = sm.task_type
                    u["device"] = sm.device
                    u["input_size"] = [sm.input_width, sm.input_height]
                    u["conf_threshold"] = sm.conf_threshold
                    u["iou_threshold"] = sm.iou_threshold
                    u["algorithm_type"] = sm.algorithm_type
                    u["small_model_state"] = sm.state
                u["biz_algorithms"] = biz_by_sm.get(aid, [])
                u["instance_enabled"] = m.is_algo_instance_enabled(aid)
        except Exception as e:
            import logging
            logging.getLogger("app").warning("build_analysis_status_data 补充详情失败: %s" % str(e))
    local_instances = m._worker_pool.instance_info()
    inference_workers_alive = 0
    inference_workers_config = 0
    inference_degraded = False
    inference_timeout_count = 0
    if shared_inference:
        try:
            from app.analysis.inference_pool import get_inference_pool
            pool = get_inference_pool()
            inference_workers_alive = pool.instance_count()
            inference_workers_config = pool.num_workers
            pool_st = pool.status()
            inference_degraded = bool(pool_st.get("inference_degraded"))
            inference_timeout_count = int(pool_st.get("timeout_count") or 0)
        except Exception:
            inference_workers_alive = 0
            inference_degraded = False
            inference_timeout_count = 0
    else:
        try:
            from app.utils.GlobalUtils import g_config
            inference_workers_config = int(getattr(g_config, "analysisInferenceWorkers", 2))
        except Exception:
            inference_workers_config = 2
    if shared_inference:
        engine_total = len(algo_usage) if algo_usage else inference_workers_alive
    else:
        engine_total = len(local_instances)
    # 所有业务算法的实例化开关状态
    algo_instance_states = []
    try:
        from app.models import BizAlgorithmModel
        disabled = m.get_disabled_algos()
        for ba in BizAlgorithmModel.objects.filter(state=1).order_by("id"):
            sm = ba.small_model
            algo_instance_states.append({
                "id": ba.id,
                "name": ba.name,
                "flow_type": ba.flow_type,
                "small_model_id": sm.id if sm else None,
                "small_model_name": sm.name if sm else "",
                "engine": sm.inference_engine if sm else "",
                "instance_enabled": (sm.id not in disabled) if sm else True,
            })
    except Exception:
        pass
    data = {
        "running_streams": running,
        "running_count": len(running),
        "total_streams": StreamModel.objects.count(),
        "engine_instances": list(algo_usage.values()),
        "engine_instance_total": engine_total,
        "engine_instances_local": len(local_instances),
        "inference_shared": shared_inference,
        "inference_workers_alive": inference_workers_alive,
        "inference_degraded": inference_degraded if shared_inference else False,
        "inference_timeout_count": inference_timeout_count if shared_inference else 0,
        "analysis_fps_avg": (
            round(sum(r.get("analysis_fps", 0) for r in running) / len(running), 1) if running else 0.0
        ),
        "inference_config": {
            "shared": bool(shared_inference),
            "multi_process": bool(multi_process),
            "workers": inference_workers_config,
            "workers_alive": inference_workers_alive,
        },
        "algo_instance_states": algo_instance_states,
    }
    if not lite:
        from app.analysis.engines.factory import EngineFactory
        from app.analysis.motion import MotionDetector
        data["engines"] = EngineFactory.list_engines()
        data["motion_available"] = MotionDetector.is_available()
    _set_cached_status(data, lite=lite)
    return data


def invalidate_analysis_status_cache():
    """供启停分析、热更新后主动失效缓存，确保下次请求拿到最新状态。"""
    _STATUS_CACHE["lite"]["data"] = None
    _STATUS_CACHE["full"]["data"] = None


def control_index(request):
    return render(request, 'app/control/index.html', {})


def control_openIndex(request):
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    data = []
    if request.method == 'GET':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            stream_id = request.GET.get('stream_id')
            qs = _control_queryset(stream_id) if stream_id else _control_queryset()
            data = [_control_to_dict(z) for z in qs]
            ret = True
            msg = LANG_VIEWS_T(request, "msg_success")
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg, "data": data})


def control_openPageData(request):
    """布控页一次性加载：区域列表 + 摄像头下拉 + 分析概览"""
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    data = {}
    if request.method == 'GET':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            try:
                stream_id = request.GET.get('stream_id')
                zones = [_control_to_dict(z) for z in _control_queryset(stream_id)]
                streams = list(
                    StreamModel.objects.order_by("-id").values("id", "app", "name", "code", "nickname")
                )
                analysis = build_analysis_status_data(lite=True)
                alarm_qs = AlarmModel.objects.filter(event_type__in=CONTROL_ALARM_EVENT_TYPES)
                if stream_id:
                    alarm_qs = alarm_qs.filter(stream_id=int(stream_id))
                data = {
                    "zones": zones,
                    "streams": streams,
                    "analysis": analysis,
                    "recent_alarm_count": alarm_qs.count(),
                }
                ret = True
                msg = LANG_VIEWS_T(request, "msg_success")
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg, "data": data})


def control_openAdd(request):
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    if request.method == 'POST':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            params = f_parsePostParams(request)
            try:
                stream_id = int(params.get("stream_id", 0))
                if stream_id <= 0:
                    app = (params.get("stream_app") or params.get("app") or "").strip()
                    name = (params.get("stream_name") or params.get("name") or "").strip()
                    if app and name:
                        stream = StreamModel.objects.get(app=app, name=name)
                        stream_id = stream.id
                    else:
                        raise ValueError(LANG_VIEWS_T(request, "zone_form_incomplete"))
                else:
                    stream = StreamModel.objects.get(id=stream_id)
                algo_ids_req = params.get("algorithm_ids") or []
                if isinstance(algo_ids_req, str):
                    try:
                        import json as _json2
                        algo_ids_req = _json2.loads(algo_ids_req)
                    except Exception:
                        algo_ids_req = [s for s in algo_ids_req.split(",") if s]
                if not algo_ids_req:
                    raise ValueError(LANG_VIEWS_T(request, "zone_algo_required"))
                algo_ids_int = [int(x) for x in algo_ids_req]
                _validate_zone_geometry(params, algo_ids_int)
                detect_interval_sec, detect_frames = _parse_control_detect_rate(params)
                zone = ZoneModel(
                    stream=stream,
                    name=params.get("name", "").strip(),
                    coordinates=params.get("coordinates", "[]"),
                    is_required=int(params.get("is_required", 1)),
                    loiter_threshold=int(params.get("loiter_threshold", 0)),
                    detect_interval_sec=detect_interval_sec,
                    detect_frames=detect_frames,
                    alarm_repeat_sec=_parse_alarm_repeat(params),
                    color=params.get("color", "#169F85"),
                    line_a=params.get("line_a", ""),
                    line_b=params.get("line_b", ""),
                    density_threshold=int(params.get("density_threshold", 0) or 0),
                    state=0,
                )
                zone.save()
                algo_ids = params.get("algorithm_ids") or []
                if isinstance(algo_ids, str):
                    try:
                        import json as _json
                        algo_ids = _json.loads(algo_ids)
                    except Exception:
                        algo_ids = [s for s in algo_ids.split(",") if s]
                if algo_ids:
                    from app.models import BizAlgorithmModel
                    qs = BizAlgorithmModel.objects.filter(id__in=[int(x) for x in algo_ids], state=1)
                    zone.algorithms.set(qs)
                try:
                    from app.analysis.manager import AnalysisManager
                    m = AnalysisManager()
                    if stream_id in m.list_running():
                        m.reload_zones(stream_id)
                except Exception:
                    pass
                ret = True
                msg = LANG_VIEWS_T(request, "msg_success")
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg})


def control_openEdit(request):
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    if request.method == 'POST':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            params = f_parsePostParams(request)
            try:
                zid = int(params.get("id", 0))
                z = ZoneModel.objects.get(id=zid)
                if "name" in params:
                    z.name = params["name"].strip()
                if "coordinates" in params:
                    z.coordinates = params["coordinates"]
                if "is_required" in params:
                    z.is_required = int(params["is_required"])
                if "loiter_threshold" in params:
                    z.loiter_threshold = int(params["loiter_threshold"])
                if "detect_interval_sec" in params or "detect_frames" in params:
                    interval, frames = _parse_control_detect_rate(params)
                    z.detect_interval_sec = interval
                    z.detect_frames = frames
                if "alarm_repeat_sec" in params:
                    z.alarm_repeat_sec = _parse_alarm_repeat(params)
                if "color" in params:
                    z.color = params["color"]
                if "line_a" in params:
                    z.line_a = params.get("line_a", "")
                if "line_b" in params:
                    z.line_b = params.get("line_b", "")
                if "density_threshold" in params:
                    z.density_threshold = int(params.get("density_threshold", 0) or 0)
                z.save()
                if "algorithm_ids" in params:
                    algo_ids = params.get("algorithm_ids") or []
                    if isinstance(algo_ids, str):
                        try:
                            import json as _json
                            algo_ids = _json.loads(algo_ids)
                        except Exception:
                            algo_ids = [s for s in algo_ids.split(",") if s]
                    if not algo_ids:
                        raise ValueError(LANG_VIEWS_T(request, "zone_algo_required"))
                    algo_ids_int = [int(x) for x in algo_ids]
                    _validate_zone_geometry(params, algo_ids_int)
                    from app.models import BizAlgorithmModel
                    qs = BizAlgorithmModel.objects.filter(id__in=algo_ids_int, state=1)
                    z.algorithms.set(qs)
                elif any(k in params for k in ("coordinates", "line_a", "line_b", "is_required")):
                    algo_ids_int = list(z.algorithms.filter(state=1).values_list("id", flat=True))
                    _validate_zone_geometry(params, algo_ids_int)
                try:
                    from app.analysis.manager import AnalysisManager
                    m = AnalysisManager()
                    if z.stream_id in m.list_running():
                        m.reload_zones(z.stream_id)
                except Exception:
                    pass
                ret = True
                msg = LANG_VIEWS_T(request, "msg_success")
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg})


def control_openDel(request):
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    if request.method == 'POST':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            params = f_parsePostParams(request)
            try:
                zid = int(params.get("id", 0))
                z = ZoneModel.objects.get(id=zid)
                sid = z.stream_id
                z.delete()
                try:
                    from app.analysis.manager import AnalysisManager
                    from app.models import ZoneModel as _ZM
                    m = AnalysisManager()
                    if m.is_running(sid):
                        if _ZM.objects.filter(stream_id=sid, state=1).exists():
                            m.reload_zones(sid)
                        else:
                            m.stop(sid)
                except Exception:
                    pass
                ret = True
                msg = LANG_VIEWS_T(request, "msg_success")
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg})


def control_openToggleZone(request):
    """单条布控手动启停：仅影响该布控，同摄像头其它布控互不干扰。"""
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    data = {}
    if request.method == 'POST':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            params = f_parsePostParams(request)
            try:
                zid = int(params.get("id", 0))
                if zid <= 0:
                    raise ValueError(LANG_VIEWS_T(request, "msg_invalid_parameter"))
                z = ZoneModel.objects.get(id=zid)
                if "enabled" in params or "state" in params:
                    enabled = int(params.get("enabled", params.get("state", 0)))
                else:
                    enabled = 0 if int(z.state or 0) == 1 else 1
                from app.analysis.manager import AnalysisManager
                from app.models import StreamModel
                m = AnalysisManager()
                sid = int(z.stream_id)
                stream = StreamModel.objects.get(id=sid)

                def _restart_stream_analysis():
                    """重启分析流水线，确保布控列表与运行时状态一致（避免热更新失败导致无报警）。"""
                    if m.is_running(sid):
                        m.stop(sid)
                    ok, info = m.start(stream)
                    if not ok:
                        raise ValueError(info or LANG_VIEWS_T(request, "msg_unknown_error"))
                    return ok, info

                if enabled:
                    z.state = 1
                    z.save()
                    if not m.is_running(sid):
                        ok, info = m.start(stream)
                        if not ok:
                            z.state = 0
                            z.save()
                            raise ValueError(info or LANG_VIEWS_T(request, "msg_unknown_error"))
                    else:
                        _restart_stream_analysis()
                else:
                    z.state = 0
                    z.save()
                    if m.is_running(sid):
                        if ZoneModel.objects.filter(stream_id=sid, state=1).exists():
                            _restart_stream_analysis()
                        else:
                            m.stop(sid)
                invalidate_analysis_status_cache()
                ret = True
                data = {"id": z.id, "state": z.state, "stream_id": z.stream_id}
                msg = LANG_VIEWS_T(
                    request,
                    "zone_started" if z.state == 1 else "zone_stopped",
                )
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg, "data": data})


def control_openRecentAlarms(request):
    """返回近期报警事件，供布控页展示"""
    from app.views.AnalysisView import _timeline_alarm_fields
    ret = False
    msg = LANG_VIEWS_T(request, "msg_unknown_error")
    data = []
    if request.method == 'GET':
        __check_ret, __check_msg = f_checkRequestSafe(request)
        if __check_ret:
            try:
                import json as _json
                stream_id = request.GET.get('stream_id')
                limit = int(request.GET.get('limit', 12))
                base_qs = AlarmModel.objects.all()
                if stream_id:
                    base_qs = base_qs.filter(stream_id=int(stream_id))
                zone_qs = base_qs.filter(event_type__in=CONTROL_ALARM_EVENT_TYPES).order_by('-timestamp')[:limit]
                items = list(zone_qs)
                out = []
                for t in items[:limit]:
                    try:
                        meta = _json.loads(t.metadata) if t.metadata else {}
                    except Exception:
                        meta = {}
                    out.append({
                        "id": t.id,
                        "stream_id": t.stream_id,
                        "stream_name": (t.stream.nickname if t.stream else ""),
                        "event_type": t.event_type,
                        "label": meta.get("label", ""),
                        "zone_id": meta.get("zone_id"),
                        "box": meta.get("box"),
                        "duration": meta.get("duration"),
                        "snapshot_path": meta.get("snapshot_path", ""),
                        "timestamp": str(t.timestamp),
                        **_timeline_alarm_fields(t, meta),
                    })
                data = out
                ret = True
                msg = LANG_VIEWS_T(request, "msg_success")
            except Exception as e:
                msg = str(e)
        else:
            msg = __check_msg
    else:
        msg = LANG_VIEWS_T(request, "msg_method_not_supported")
    return f_responseJson({"code": 1000 if ret else 0, "msg": msg, "data": data})