档案库房消毒净化时序控制：兼顾空气质量与温湿度稳定的工程实践

┌─────────────────────────────────────────────────────────────────────┐
│ 消毒净化与温湿度稳定的"不可能三角"                                 │
│                                                                     │
│         消毒效果充分                                                │
│        ╱            ╲                                              │
│       ╱              ╲                                             │
│      ╱     三者难以   ╲                                            │
│     ╱      同时兼顾    ╲                                           │
│    ╱                    ╲                                          │
│   ╱                      ╲                                         │
│ 温湿度稳定 ────────────── 运行安全（人员/档案）                     │
│                                                                     │
│ 工程实践的目标：通过"时序控制"将三者解耦                            │
│ → 消毒时允许短暂偏离 → 净化与温湿度调节错峰运行 → 安全边界全程守护 │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│ 消毒净化五阶段时序模型                                             │
│                                                                     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────┐│
│  │ 准备阶段 │→│ 预处理   │→│ 核心消毒 │→│ 后处理   │→│ 恢复 ││
│  │(T-24~   │  │ 阶段     │  │ 阶段     │  │ 阶段     │  │阶段  ││
│  │ T-2h)   │  │(T-2~T-0)│  │(T0~T1)  │  │(T1~T2)  │  │(T2~ ││
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘  │T3)  ││
│        │              │              │              │      └──────┘│
│   环境评估       温湿度预调节   消毒设备全功率  分解/排残   逐步恢复│
│   设备自检       风量预调整    密闭维持       通风/净化   正常调控 │
│   人员清场       安全确认      浓度监测       中和/吸附   系统自检 │
│                                                                     │
│  关键设计原则：                                                     │
│  · 准备阶段：不打扰正常调控，仅做评估和准备                        │
│  · 预处理阶段：主动偏离温湿度设定值，为消毒扰动预留缓冲            │
│  · 核心消毒阶段：温湿度允许短暂超标，但设"硬上限"防失控            │
│  · 后处理阶段：优先排残/分解，温湿度调控让位于安全                 │
│  · 恢复阶段：逐步收紧控制阈值，确认环境回归正常后移交日常调控      │
└─────────────────────────────────────────────────────────────────────┘

# disinfection_scheduler.py
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Callable
from enum import Enum
import time
import threading

class DisinfectionMethod(Enum):
    OZONE = "ozone"                     # 臭氧消毒
    UV_C = "uv_c"                       # 紫外线照射
    PCO = "pco"                         # 光催化净化
    PLASMA = "plasma"                   # 等离子
    ACTIVATED_CARBON = "activated_carbon" # 活性炭吸附
    CHEMICAL_FUMIGATION = "chemical"     # 化学熏蒸
    COMBINED = "combined"                # 组合方式

class Phase(Enum):
    PREPARATION = "preparation"         # 准备
    PRE_CONDITIONING = "pre_conditioning" # 预处理
    CORE_DISINFECTION = "core"          # 核心消毒
    POST_PROCESSING = "post_processing" # 后处理
    RECOVERY = "recovery"               # 恢复
    COMPLETED = "completed"             # 完成
    ABORTED = "aborted"                 # 中止

@dataclass
class PhaseConfig:
    """阶段配置"""
    phase: Phase
    duration: float                     # 预计持续时间（秒）
    temp_setpoint_offset: float = 0.0   # 温度设定偏移（℃）
    humi_setpoint_offset: float = 0.0   # 湿度设定偏移（%RH）
    temp_hard_limit_upper: float = 26.0 # 温度硬上限
    temp_hard_limit_lower: float = 12.0 # 温度硬下限
    humi_hard_limit_upper: float = 65.0 # 湿度硬上限
    humi_hard_limit_lower: float = 40.0 # 湿度硬下限
    fresh_air_mode: str = "normal"      # 新风模式：normal/closed/forced
    purifier_mode: str = "normal"       # 净化模式
    ac_mode: str = "normal"             # 空调模式
    devices_to_start: List[str] = field(default_factory=list)
    devices_to_stop: List[str] = field(default_factory=list)
    monitoring_params: List[str] = field(default_factory=list)
    safety_thresholds: Dict[str, float] = field(default_factory=dict)

@dataclass
class DisinfectionTask:
    """消毒净化任务"""
    task_id: str
    method: DisinfectionMethod
    zone_id: str
    start_time: float
    phases: List[PhaseConfig]
    current_phase_index: int = 0
    phase_start_time: float = 0
    status: str = "pending"
    abort_reason: Optional[str] = None

class DisinfectionScheduler:
    """消毒净化任务调度器"""

    def __init__(self, zone_controller, alert_callback: Optional[Callable] = None):
        self.zone_controller = zone_controller
        self.alert_callback = alert_callback
        self.active_tasks: Dict[str, DisinfectionTask] = {}
        self.task_history: List[DisinfectionTask] = []
        self.lock = threading.RLock()
        self._running = False
        self._thread = None

    def create_task(self, task_id: str, method: DisinfectionMethod,
                   zone_id: str, start_time: float,
                   custom_phases: Optional[List[PhaseConfig]] = None) -> DisinfectionTask:
        """创建消毒净化任务"""
        if custom_phases:
            phases = custom_phases
        else:
            phases = self._generate_default_phases(method)

        task = DisinfectionTask(
            task_id=task_id,
            method=method,
            zone_id=zone_id,
            start_time=start_time,
            phases=phases
        )

        with self.lock:
            self.active_tasks[task_id] = task

        return task

    def _generate_default_phases(self, method: DisinfectionMethod) -> List[PhaseConfig]:
        """根据消毒方式生成默认阶段配置"""
        phases = []

        # 通用准备阶段
        phases.append(PhaseConfig(
            phase=Phase.PREPARATION,
            duration=7200,  # 2小时
            temp_setpoint_offset=0,
            humi_setpoint_offset=0,
            fresh_air_mode="normal",
            purifier_mode="normal",
            ac_mode="normal",
            monitoring_params=["temperature", "humidity", "ozone", "pm25"],
            safety_thresholds={"ozone": 0.05}  # mg/m³
        ))

        # 预处理阶段
        if method == DisinfectionMethod.OZONE:
            phases.append(PhaseConfig(
                phase=Phase.PRE_CONDITIONING,
                duration=1800,  # 30分钟
                temp_setpoint_offset=-0.5,       # 预冷0.5℃
                humi_setpoint_offset=-3.0,       # 预除湿3%RH
                temp_hard_limit_upper=25.0,
                humi_hard_limit_upper=62.0,
                fresh_air_mode="closed",         # 关闭新风
                purifier_mode="recirculation",   # 内循环
                ac_mode="precool",
                devices_to_stop=["fresh_air_unit", "exhaust_fan"],
                devices_to_start=["recirculation_fan"],
                monitoring_params=["temperature", "humidity", "ozone"],
                safety_thresholds={"ozone": 0.05}
            ))
        elif method == DisinfectionMethod.UV_C:
            phases.append(PhaseConfig(
                phase=Phase.PRE_CONDITIONING,
                duration=900,  # 15分钟
                temp_setpoint_offset=-0.3,
                humi_setpoint_offset=0,
                fresh_air_mode="closed",
                purifier_mode="off",
                ac_mode="precool",
                devices_to_stop=["fresh_air_unit"],
                monitoring_params=["temperature", "humidity"],
                safety_thresholds={}
            ))
        elif method == DisinfectionMethod.PCO:
            phases.append(PhaseConfig(
                phase=Phase.PRE_CONDITIONING,
                duration=1200,  # 20分钟
                temp_setpoint_offset=-0.5,
                humi_setpoint_offset=0,
                fresh_air_mode="closed",
                purifier_mode="low",
                ac_mode="precool",
                devices_to_stop=["fresh_air_unit"],
                monitoring_params=["temperature", "humidity", "voc"],
                safety_thresholds={"voc": 0.6}
            ))
        else:
            # 默认预处理
            phases.append(PhaseConfig(
                phase=Phase.PRE_CONDITIONING,
                duration=1800,
                temp_setpoint_offset=-0.3,
                humi_setpoint_offset=-2.0,
                fresh_air_mode="closed",
                purifier_mode="recirculation",
                ac_mode="normal",
                monitoring_params=["temperature", "humidity"],
                safety_thresholds={}
            ))

        # 核心消毒阶段
        if method == DisinfectionMethod.OZONE:
            phases.append(PhaseConfig(
                phase=Phase.CORE_DISINFECTION,
                duration=7200,  # 2小时
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=26.0,  # 允许放宽
                temp_hard_limit_lower=14.0,
                humi_hard_limit_upper=65.0,
                humi_hard_limit_lower=42.0,
                fresh_air_mode="closed",
                purifier_mode="off",          # 臭氧期间净化停机
                ac_mode="maintain",           # 维持模式
                devices_to_start=["ozone_generator"],
                devices_to_stop=["purifier", "fresh_air_unit"],
                monitoring_params=["ozone", "temperature", "humidity"],
                safety_thresholds={"ozone": 0.05}  # 泄漏监测
            ))
        elif method == DisinfectionMethod.UV_C:
            phases.append(PhaseConfig(
                phase=Phase.CORE_DISINFECTION,
                duration=3600,  # 1小时
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=26.0,
                humi_hard_limit_upper=63.0,
                fresh_air_mode="closed",
                purifier_mode="off",
                ac_mode="maintain",
                devices_to_start=["uv_c_lamps"],
                monitoring_params=["temperature", "humidity", "uv_intensity"],
                safety_thresholds={"uv_intensity": 70}  # μW/cm²
            ))
        elif method == DisinfectionMethod.PCO:
            phases.append(PhaseConfig(
                phase=Phase.CORE_DISINFECTION,
                duration=5400,  # 1.5小时
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=26.0,
                humi_hard_limit_upper=63.0,
                fresh_air_mode="closed",
                purifier_mode="pco_high",
                ac_mode="maintain",
                devices_to_start=["pco_units", "uv_lamps"],
                monitoring_params=["temperature", "humidity", "voc", "formaldehyde"],
                safety_thresholds={"voc": 0.6, "formaldehyde": 0.08}
            ))
        elif method == DisinfectionMethod.CHEMICAL_FUMIGATION:
            phases.append(PhaseConfig(
                phase=Phase.CORE_DISINFECTION,
                duration=14400,  # 4小时
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=28.0,  # 熏蒸期间允许更大偏离
                temp_hard_limit_lower=12.0,
                humi_hard_limit_upper=70.0,
                humi_hard_limit_lower=40.0,
                fresh_air_mode="closed",
                purifier_mode="off",
                ac_mode="off",               # 熏蒸期间空调停机
                devices_to_start=["fumigation_generator"],
                devices_to_stop=["ac", "fresh_air_unit", "purifier", "exhaust_fan"],
                monitoring_params=["chemical_concentration", "temperature", "humidity"],
                safety_thresholds={"chemical_concentration": 0.1}
            ))
        else:
            # 默认核心阶段
            phases.append(PhaseConfig(
                phase=Phase.CORE_DISINFECTION,
                duration=3600,
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=26.0,
                humi_hard_limit_upper=63.0,
                fresh_air_mode="closed",
                purifier_mode="high",
                ac_mode="maintain",
                monitoring_params=["temperature", "humidity", "pm25", "voc"],
                safety_thresholds={}
            ))

        # 后处理阶段
        if method == DisinfectionMethod.OZONE:
            phases.append(PhaseConfig(
                phase=Phase.POST_PROCESSING,
                duration=3600,  # 1小时（臭氧分解+通风）
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=25.0,
                humi_hard_limit_upper=60.0,
                fresh_air_mode="forced",        # 强制通风
                purifier_mode="high_with_carbon", # 活性炭吸附残留
                ac_mode="normal",
                devices_to_stop=["ozone_generator"],
                devices_to_start=["fresh_air_unit", "exhaust_fan", "purifier", "activated_carbon_filter"],
                monitoring_params=["ozone", "temperature", "humidity", "pm25"],
                safety_thresholds={"ozone": 0.05}  # 必须降至安全值以下
            ))
        elif method == DisinfectionMethod.CHEMICAL_FUMIGATION:
            phases.append(PhaseConfig(
                phase=Phase.POST_PROCESSING,
                duration=7200,  # 2小时
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=25.0,
                humi_hard_limit_upper=60.0,
                fresh_air_mode="forced",
                purifier_mode="high_with_carbon",
                ac_mode="normal",
                devices_to_stop=["fumigation_generator"],
                devices_to_start=["fresh_air_unit", "exhaust_fan", "purifier", "activated_carbon_filter"],
                monitoring_params=["chemical_residue", "temperature", "humidity"],
                safety_thresholds={"chemical_residue": 0.01}
            ))
        else:
            phases.append(PhaseConfig(
                phase=Phase.POST_PROCESSING,
                duration=1800,  # 30分钟
                temp_setpoint_offset=0,
                humi_setpoint_offset=0,
                temp_hard_limit_upper=25.0,
                humi_hard_limit_upper=60.0,
                fresh_air_mode="normal",
                purifier_mode="high",
                ac_mode="normal",
                devices_to_stop=["uv_c_lamps", "pco_units", "ozone_generator"],
                devices_to_start=["fresh_air_unit", "purifier"],
                monitoring_params=["temperature", "humidity", "pm25", "voc"],
                safety_thresholds={}
            ))

        # 恢复阶段
        phases.append(PhaseConfig(
            phase=Phase.RECOVERY,
            duration=1800,  # 30分钟
            temp_setpoint_offset=0,
            humi_setpoint_offset=0,
            temp_hard_limit_upper=24.5,
            humi_hard_limit_upper=61.0,
            fresh_air_mode="normal",
            purifier_mode="normal",
            ac_mode="normal",
            devices_to_start=[],
            devices_to_stop=[],
            monitoring_params=["temperature", "humidity", "pm25", "voc", "ozone"],
            safety_thresholds={"ozone": 0.05, "voc": 0.6}
        ))

        return phases

    def start_scheduler(self):
        """启动调度器主循环"""
        if self._running:
            return

        self._running = True
        self._thread = threading.Thread(target=self._scheduler_loop, daemon=True)
        self._thread.start()

    def stop_scheduler(self):
        """停止调度器"""
        self._running = False
        if self._thread:
            self._thread.join(timeout=5)

    def _scheduler_loop(self):
        """调度器主循环"""
        while self._running:
            current_time = time.time()

            with self.lock:
                for task_id, task in list(self.active_tasks.items()):
                    if task.status == "completed" or task.status == "aborted":
                        continue

                    self._process_task(task, current_time)

            time.sleep(10)  # 每10秒检查一次

    def _process_task(self, task: DisinfectionTask, current_time: float):
        """处理单个任务"""
        if task.status == "pending":
            # 检查是否到达开始时间
            if current_time >= task.start_time:
                task.status = "running"
                task.current_phase_index = 0
                task.phase_start_time = current_time
                self._execute_phase_entry(task, task.phases[0])
            return

        if task.status == "running":
            current_phase = task.phases[task.current_phase_index]
            phase_elapsed = current_time - task.phase_start_time

            # 检查安全阈值
            safety_violation = self._check_safety_thresholds(task)
            if safety_violation:
                self._abort_task(task, f"安全阈值突破: {safety_violation}")
                return

            # 检查硬限制
            hard_limit_violation = self._check_hard_limits(task, current_phase)
            if hard_limit_violation:
                self._abort_task(task, f"硬限制突破: {hard_limit_violation}")
                return

            # 检查阶段是否完成
            if phase_elapsed >= current_phase.duration:
                self._execute_phase_exit(task, current_phase)

                task.current_phase_index += 1

                if task.current_phase_index >= len(task.phases):
                    # 所有阶段完成
                    task.status = "completed"
                    self.task_history.append(task)
                    del self.active_tasks[task.task_id]
                    if self.alert_callback:
                        self.alert_callback(f"消毒任务 {task.task_id} 已完成")
                else:
                    # 进入下一阶段
                    next_phase = task.phases[task.current_phase_index]
                    task.phase_start_time = current_time
                    self._execute_phase_entry(task, next_phase)

    def _execute_phase_entry(self, task: DisinfectionTask, phase: PhaseConfig):
        """执行阶段进入动作"""
        # 启动设备
        for device in phase.devices_to_start:
            self.zone_controller.start_device(task.zone_id, device)

        # 停止设备
        for device in phase.devices_to_stop:
            self.zone_controller.stop_device(task.zone_id, device)

        # 调整设定值
        if phase.temp_setpoint_offset != 0:
            self.zone_controller.adjust_temp_setpoint(
                task.zone_id, phase.temp_setpoint_offset
            )
        if phase.humi_setpoint_offset != 0:
            self.zone_controller.adjust_humi_setpoint(
                task.zone_id, phase.humi_setpoint_offset
            )

        # 设置新风模式
        if phase.fresh_air_mode != "normal":
            self.zone_controller.set_fresh_air_mode(task.zone_id, phase.fresh_air_mode)

        if self.alert_callback:
            self.alert_callback(
                f"任务 {task.task_id} 进入阶段: {phase.phase.value}, "
                f"预计持续 {phase.duration/60:.0f} 分钟"
            )

    def _execute_phase_exit(self, task: DisinfectionTask, phase: PhaseConfig):
        """执行阶段退出动作"""
        # 恢复设定值
        if phase.temp_setpoint_offset != 0:
            self.zone_controller.adjust_temp_setpoint(task.zone_id, -phase.temp_setpoint_offset)
        if phase.humi_setpoint_offset != 0:
            self.zone_controller.adjust_humi_setpoint(task.zone_id, -phase.humi_setpoint_offset)

    def _check_safety_thresholds(self, task: DisinfectionTask) -> Optional[str]:
        """检查安全阈值"""
        current_phase = task.phases[task.current_phase_index]
        readings = self.zone_controller.get_current_readings(task.zone_id)

        for param, threshold in current_phase.safety_thresholds.items():
            value = readings.get(param, 0)
            if value > threshold:
                return f"{param}: {value} > {threshold}"

        return None

    def _check_hard_limits(self, task: DisinfectionTask, phase: PhaseConfig) -> Optional[str]:
        """检查硬限制"""
        readings = self.zone_controller.get_current_readings(task.zone_id)

        temp = readings.get('temperature', 22)
        humi = readings.get('humidity', 50)

        if temp > phase.temp_hard_limit_upper:
            return f"温度 {temp}℃ > 硬上限 {phase.temp_hard_limit_upper}℃"
        if temp < phase.temp_hard_limit_lower:
            return f"温度 {temp}℃ < 硬下限 {phase.temp_hard_limit_lower}℃"
        if humi > phase.humi_hard_limit_upper:
            return f"湿度 {humi}%RH > 硬上限 {phase.humi_hard_limit_upper}%RH"
        if humi < phase.humi_hard_limit_lower:
            return f"湿度 {humi}%RH < 硬下限 {phase.humi_hard_limit_lower}%RH"

        return None

    def _abort_task(self, task: DisinfectionTask, reason: str):
        """中止任务"""
        task.status = "aborted"
        task.abort_reason = reason

        # 紧急恢复：停止所有消毒设备，恢复通风
        current_phase = task.phases[task.current_phase_index]
        for device in current_phase.devices_to_start:
            self.zone_controller.stop_device(task.zone_id, device)

        # 恢复新风
        self.zone_controller.set_fresh_air_mode(task.zone_id, "forced")

        # 启动净化
        self.zone_controller.start_device(task.zone_id, "purifier")

        self.task_history.append(task)
        del self.active_tasks[task.task_id]

        if self.alert_callback:
            self.alert_callback(f"⚠️ 任务 {task.task_id} 已中止: {reason}")

    def get_task_status(self, task_id: str) -> Optional[dict]:
        """获取任务状态"""
        if task_id in self.active_tasks:
            task = self.active_tasks[task_id]
            return {
                'task_id': task.task_id,
                'status': task.status,
                'current_phase': task.phases[task.current_phase_index].phase.value if task.current_phase_index < len(task.phases) else 'completed',
                'phase_progress': min(1.0, (time.time() - task.phase_start_time) / task.phases[task.current_phase_index].duration) if task.current_phase_index < len(task.phases) else 1.0,
                'elapsed_total': time.time() - task.start_time
            }
        return None

# method_templates.py
"""各消毒方式的专属时序模板与参数"""

OZONE_DISINFECTION_TEMPLATE = {
    "description": "臭氧消毒标准时序",
    "total_duration": "约4.5小时",
    "critical_notes": [
        "消毒期间人员严禁进入（臭氧浓度≥10ppm）",
        "后处理阶段必须确认臭氧浓度<0.05mg/m³方可允许人员进入",
        "密闭性要求：库房泄漏率<5%/h"
    ],
    "phase_summary": {
        "preparation": "确认人员清场、密闭性检查、传感器校准",
        "pre_conditioning": "预冷0.5℃+预除湿3%RH+关闭新风+内循环",
        "core": "臭氧发生器全功率运行2h，空调维持模式",
        "post_processing": "关闭臭氧→强制通风+活性炭净化1h→臭氧浓度监测",
        "recovery": "逐步恢复日常设定，确认环境达标"
    }
}

UV_C_DISINFECTION_TEMPLATE = {
    "description": "UV-C紫外线消毒标准时序",
    "total_duration": "约2.5小时",
    "critical_notes": [
        "UV-C对人员眼睛和皮肤有伤害，必须确认人员清场",
        "UV灯发热量需纳入温升补偿计算",
        "UV-C对阴影区域无效，需配合气流组织"
    ],
    "phase_summary": {
        "preparation": "人员清场、UV灯自检",
        "pre_conditioning": "预冷0.3℃+关闭新风15min",
        "core": "UV-C灯全功率运行1h，空调维持",
        "post_processing": "关闭UV灯→恢复新风→净化30min",
        "recovery": "逐步恢复正常调控"
    }
}

PCO_PURIFICATION_TEMPLATE = {
    "description": "光催化(PCO)持续净化时序",
    "total_duration": "约3小时（单次循环）",
    "critical_notes": [
        "PCO效率受湿度影响大：相对湿度>70%时催化效率下降>50%",
        "UV灯发热需补偿",
        "适合日常定期净化，不适合紧急消毒"
    ],
    "phase_summary": {
        "preparation": "检查催化剂状态、UV灯强度",
        "pre_conditioning": "预冷0.5℃+关闭新风20min",
        "core": "PCO单元+UV全功率1.5h，空调维持",
        "post_processing": "关闭PCO→恢复新风→净化30min",
        "recovery": "切换为日常净化模式"
    }
}

CHEMICAL_FUMIGATION_TEMPLATE = {
    "description": "化学熏蒸消毒时序（环氧乙烷/甲醛）",
    "total_duration": "约24~30小时",
    "critical_notes": [
        "最高风险方式，需专业团队操作",
        "熏蒸期间所有设备停机（包括空调）",
        "后处理需长时间通风（24h+）",
        "残留检测合格前严禁人员进入和档案取阅"
    ],
    "phase_summary": {
        "preparation": "人员清场、档案密封/覆盖、密闭性检测（泄漏率<1%/h）",
        "pre_conditioning": "关闭所有设备、确认密闭",
        "core": "熏蒸发生器运行4h+密闭维持12~24h",
        "post_processing": "强制通风+活性炭净化2h+残留检测",
        "recovery": "逐步恢复环境调控，确认残留达标"
    }
}

# emergency_abort.py
from dataclasses import dataclass
from typing import Dict, List, Callable
import time

@dataclass
class EmergencyEvent:
    """紧急事件"""
    event_id: str
    task_id: str
    zone_id: str
    trigger_type: str       # temp_exceed / humi_exceed / gas_leak / sensor_failure
    trigger_value: float
    threshold: float
    timestamp: float
    handled: bool = False

class EmergencyAbortHandler:
    """应急中止处理器"""

    def __init__(self, scheduler: DisinfectionScheduler,
                 notification_callbacks: List[Callable] = None):
        self.scheduler = scheduler
        self.notification_callbacks = notification_callbacks or []
        self.emergency_log: List[EmergencyEvent] = []
        self.lock = threading.RLock()

    def trigger_emergency(self, task_id: str, zone_id: str,
                         trigger_type: str, trigger_value: float,
                         threshold: float) -> bool:
        """触发紧急中止"""
        event = EmergencyEvent(
            event_id=f"EMG_{int(time.time()*1000)}",
            task_id=task_id,
            zone_id=zone_id,
            trigger_type=trigger_type,
            trigger_value=trigger_value,
            threshold=threshold,
            timestamp=time.time()
        )

        with self.lock:
            self.emergency_log.append(event)

        # 1. 中止调度器中的任务
        self.scheduler._abort_task(
            self.scheduler.active_tasks.get(task_id),
            f"紧急中止: {trigger_type}, 值={trigger_value}, 阈值={threshold}"
        )

        # 2. 执行紧急恢复动作
        self._execute_emergency_recovery(zone_id, trigger_type)

        # 3. 发送通知
        for callback in self.notification_callbacks:
            try:
                callback(event)
            except Exception:
                pass

        return True

    def _execute_emergency_recovery(self, zone_id: str, trigger_type: str):
        """执行紧急恢复"""
        zone_controller = self.scheduler.zone_controller

        # 通用紧急动作
        # 1. 停止所有消毒设备
        disinfection_devices = [
            "ozone_generator", "uv_c_lamps", "pco_units",
            "plasma_generator", "fumigation_generator"
        ]
        for device in disinfection_devices:
            zone_controller.stop_device(zone_id, device)

        # 2. 强制通风
        zone_controller.set_fresh_air_mode(zone_id, "forced")

        # 3. 启动净化
        zone_controller.start_device(zone_id, "purifier")

        # 4. 恢复空调
        zone_controller.set_ac_mode(zone_id, "normal")

        # 针对特定触发类型的额外动作
        if trigger_type == "gas_leak":
            # 气体泄漏：额外启动排风
            zone_controller.start_device(zone_id, "exhaust_fan")
            zone_controller.start_device(zone_id, "activated_carbon_filter")
        elif trigger_type == "temp_exceed":
            # 温度超标：全力制冷
            zone_controller.set_ac_mode(zone_id, "max_cool")
        elif trigger_type == "humi_exceed":
            # 湿度超标：全力除湿
            zone_controller.start_device(zone_id, "dehumidifier")
        elif trigger_type == "sensor_failure":
            # 传感器失效：切换到备用传感器
            zone_controller.switch_to_backup_sensors(zone_id)

    def get_emergency_history(self, zone_id: str = None) -> List[EmergencyEvent]:
        """获取紧急事件历史"""
        with self.lock:
            if zone_id:
                return [e for e in self.emergency_log if e.zone_id == zone_id]
            return list(self.emergency_log)

┌─────────────────────────────────────────────────────────────────────┐
│ 优化后运行策略                                                     │
│                                                                     │
│  夏季（6~9月）：                                                    │
│  · 净化时段从"全天任意"改为"凌晨2:00~5:00"                        │
│    （理由：室外温度最低，空调负荷最小，净化发热影响最小）            │
│  · 预处理：凌晨1:30预冷至21.0℃（日常设定22℃）                     │
│  · 核心净化：2:00~4:00 PCO全功率运行                               │
│  · 后处理：4:00~4:30 关闭PCO，恢复新风                             │
│  · 恢复：4:30~5:00 逐步恢复设定温度                                │
│                                                                     │
│  冬季（12~2月）：                                                   │
│  · 净化时段改为"上午10:00~12:00"                                   │
│    （理由：室外温度较高，且可利用自然冷源辅助降温）                  │
│  · 预处理：9:30预冷至21.5℃                                         │
│  · 核心净化：10:00~11:30 PCO运行                                   │
│                                                                     │
│  过渡季（3~5月、10~11月）：                                         │
│  · 净化时段："下午14:00~16:00"                                     │
│  · 预处理：13:30预冷至21.5℃                                        │
│  · 核心净化：14:00~15:30 PCO运行                                   │
│                                                                     │
│  动态调整规则：                                                     │
│  · 若预处理阶段结束后温度>22.5℃，推迟净化30分钟                    │
│  · 若核心净化期间温度>24℃，暂停PCO 15分钟（间歇运行）              │
│  · 若室外湿度>75%RH，净化期间关闭新风                              │
└─────────────────────────────────────────────────────────────────────┘