"""
ATC 警觉衰减检测的多模态融合框架

基于 Frontiers in Neuroergonomics 2026 系统综述
34 篇论文的关键发现

核心原则:
1. 单一模态不足以可靠检测警觉衰减
2. 不同衰减类型需要不同检测策略
3. 实时部署需要轻量级模型
"""

import numpy as np
from typing import Dict, List, Tuple
from dataclasses import dataclass

@dataclass
class VigilanceState:
    """警觉状态分类"""
    UNDERLOAD = "underload"        # 低负荷脱节
    OVERLOAD = "overload"          # 过载失分辨  
    AUTOMATION = "automation"      # 自动化被动性
    FATIGUE = "fatigue"            # 累积疲劳
    NORMAL = "normal"              # 正常警觉


class MultiModalVigilanceDetector:
    """
    多模态警觉检测器
    
    基于 ATC 综述的发现，适配到汽车 IMS 场景
    
    输入模态:
    1. 眼动指标（DMS 摄像头可获取）
    2. 面部表情（DMS 摄像头可获取）
    3. 转向行为（CAN 总线可获取）
    4. rPPG 心率（DMS 摄像头可获取）
    
    输出:
    - 警觉状态分类
    - 警觉水平评分 (0-100)
    - 衰减原因分析
    """
    
    def __init__(self):
        # 眼动指标权重（综述表明这是最重要的非侵入指标）
        self.eye_metrics = {
            'blink_rate': 0.25,       # 眨眼频率
            'pupil_dilation': 0.15,    # 瞳孔直径变化
            'gaze_entropy': 0.30,      # 视线熵（注意力分散度）
            'fixation_duration': 0.20, # 注视持续时间
            'saccade_velocity': 0.10,  # 扫视速度
        }
        
        # 行为指标权重
        self.behavior_metrics = {
            'steering_entropy': 0.40,  # 转向熵
            'lane_deviation': 0.30,    # 车道偏移方差
            'pedal_variability': 0.15, # 踏板操作方差
            'head_pose': 0.15,        # 头部姿态稳定性
        }
        
        # rPPG 指标权重
        self.rppg_metrics = {
            'hrv_lf_hf': 0.50,        # LF/HF 比值（自主神经平衡）
            'heart_rate': 0.30,       # 心率变化
            'pulse_variability': 0.20, # 脉搏变异性
        }
        
    def compute_vigilance_score(self, 
                                eye_features: Dict[str, float],
                                behavior_features: Dict[str, float],
                                rppg_features: Dict[str, float]) -> Tuple[float, str]:
        """
        计算综合警觉评分
        
        Args:
            eye_features: 眼动特征字典
            behavior_features: 行为特征字典
            rppg_features: rPPG 特征字典
        
        Returns:
            vigilance_score: 0-100 (100=完全警觉)
            state: 衰减类型分类
        """
        # 眼动评分
        eye_score = 0
        for metric, weight in self.eye_metrics.items():
            val = eye_features.get(metric, 0.5)
            eye_score += val * weight
        eye_score = eye_score / sum(self.eye_metrics.values()) * 100
        
        # 行为评分
        behavior_score = 0
        for metric, weight in self.behavior_metrics.items():
            val = behavior_features.get(metric, 0.5)
            behavior_score += val * weight
        behavior_score = behavior_score / sum(self.behavior_metrics.values()) * 100
        
        # rPPG 评分
        rppg_score = 0
        for metric, weight in self.rppg_metrics.items():
            val = rppg_features.get(metric, 0.5)
            rppg_score += val * weight
        rppg_score = rppg_score / sum(self.rppg_metrics.values()) * 100
        
        # 加权融合（综述建议眼动权重最高）
        total_score = (
            eye_score * 0.45 +
            behavior_score * 0.35 +
            rppg_score * 0.20
        )
        
        # 状态分类
        state = self._classify_state(eye_features, behavior_features, rppg_features)
        
        return total_score, state
    
    def _classify_state(self, eye: Dict, behavior: Dict, rppg: Dict) -> str:
        """根据特征模式分类警觉衰减类型"""
        
        # 低负荷脱节：视线熵高 + 转向熵低 + 心率低
        if (eye.get('gaze_entropy', 0) > 0.7 and 
            behavior.get('steering_entropy', 0) < 0.3 and
            rppg.get('heart_rate', 70) < 65):
            return VigilanceState.UNDERLOAD
        
        # 过载：瞳孔扩张 + 转向熵高 + 心率高
        if (eye.get('pupil_dilation', 0) > 0.7 and
            behavior.get('steering_entropy', 0) > 0.7 and
            rppg.get('heart_rate', 70) > 85):
            return VigilanceState.OVERLOAD
        
        # 自动化被动性：注视时间长 + 眨眼率低 + 转向修正少
        if (eye.get('fixation_duration', 0) > 0.8 and
            eye.get('blink_rate', 0) < 0.3 and
            behavior.get('steering_entropy', 0) < 0.2):
            return VigilanceState.AUTOMATION
        
        # 累积疲劳：眨眼率高 + PERCLOS高 + HRV降低
        if (eye.get('blink_rate', 0) > 0.7 and
            rppg.get('hrv_lf_hf', 1) < 0.5):
            return VigilanceState.FATIGUE
        
        return VigilanceState.NORMAL


# ==================== 测试代码 ====================
if __name__ == "__main__":
    import time
    
    detector = MultiModalVigilanceDetector()
    
    # 模拟正常驾驶
    normal_eye = {
        'blink_rate': 0.5, 'pupil_dilation': 0.5, 'gaze_entropy': 0.4,
        'fixation_duration': 0.6, 'saccade_velocity': 0.5
    }
    normal_behavior = {
        'steering_entropy': 0.5, 'lane_deviation': 0.3,
        'pedal_variability': 0.4, 'head_pose': 0.7
    }
    normal_rppg = {
        'hrv_lf_hf': 1.5, 'heart_rate': 72, 'pulse_variability': 0.5
    }
    
    score, state = detector.compute_vigilance_score(normal_eye, normal_behavior, normal_rppg)
    print(f"正常驾驶: 警觉分数={score:.1f}, 状态={state}")
    
    # 模拟高速公路定速巡航（低负荷脱节）
    cruise_eye = {
        'blink_rate': 0.3, 'pupil_dilation': 0.3, 'gaze_entropy': 0.8,
        'fixation_duration': 0.9, 'saccade_velocity': 0.2
    }
    cruise_behavior = {
        'steering_entropy': 0.1, 'lane_deviation': 0.2,
        'pedal_variability': 0.1, 'head_pose': 0.5
    }
    cruise_rppg = {
        'hrv_lf_hf': 2.0, 'heart_rate': 60, 'pulse_variability': 0.3
    }
    
    score, state = detector.compute_vigilance_score(cruise_eye, cruise_behavior, cruise_rppg)
    print(f"定速巡航: 警觉分数={score:.1f}, 状态={state}")
    
    # 模拟城市复杂路况（过载）
    urban_eye = {
        'blink_rate': 0.6, 'pupil_dilation': 0.85, 'gaze_entropy': 0.9,
        'fixation_duration': 0.2, 'saccade_velocity': 0.9
    }
    urban_behavior = {
        'steering_entropy': 0.8, 'lane_deviation': 0.6,
        'pedal_variability': 0.7, 'head_pose': 0.4
    }
    urban_rppg = {
        'hrv_lf_hf': 0.3, 'heart_rate': 95, 'pulse_variability': 0.8
    }
    
    score, state = detector.compute_vigilance_score(urban_eye, urban_behavior, urban_rppg)
    print(f"城市复杂路况: 警觉分数={score:.1f}, 状态={state}")
    
    # 模拟 ADAS 自动驾驶（自动化被动性）
    adas_eye = {
        'blink_rate': 0.2, 'pupil_dilation': 0.3, 'gaze_entropy': 0.5,
        'fixation_duration': 0.9, 'saccade_velocity': 0.1
    }
    adas_behavior = {
        'steering_entropy': 0.1, 'lane_deviation': 0.1,
        'pedal_variability': 0.05, 'head_pose': 0.8
    }
    adas_rppg = {
        'hrv_lf_hf': 1.8, 'heart_rate': 68, 'pulse_variability': 0.4
    }
    
    score, state = detector.compute_vigilance_score(adas_eye, adas_behavior, adas_rppg)
    print(f"ADAS 自动驾驶: 警觉分数={score:.1f}, 状态={state}")

"""
Phase 1: 基于现有 DMS 的认知分心检测

使用指标:
- 眼动: 眨眼率、注视时间、视线熵
- 行为: 转向熵、车道偏移方差

目标: L1 二分类（正常/异常），精度 90%+
"""
# 指标阈值（基于 ATC 综述推荐）
THRESHOLDS = {
    'blink_rate_high': 25,       # >25次/min → 异常
    'blink_rate_low': 10,        # <10次/min → 自动化被动
    'fixation_duration_long': 3.0,  # >3s → 走神
    'gaze_entropy_high': 0.7,    # >0.7 → 注意力分散
    'steering_entropy_low': 0.2, # <0.2 → 过于平顺
    'lane_deviation_high': 0.3,  # >0.3m → 控制退化
}