import numpy as np
from typing import List, Tuple

class VisualImpairmentDetector:
    """
    基于视觉的驾驶员损伤检测模型
    
    核心思路：
    1. 面部特征分析：酒精损伤导致面部微表情异常
    2. 眼动模式分析：酒驾者眼球运动轨迹异常（扫视减少、注视增加）
    3. 头部姿态稳定性：酒精损伤导致头部微抖动增加
    4. 行为时序分析：反应时间延长、动作迟缓
    
    输入：摄像头帧序列
    输出：损伤概率 + 损伤类型 + 置信度
    """
    
    def __init__(self, fps: int = 30, window_sec: int = 10):
        self.fps = fps
        self.window_frames = fps * window_sec
        self.history = []
        
        # 损伤指标权重（基于经验校准）
        self.weights = {
            'gaze_entropy': 0.25,       # 眼动熵（酒驾者降低）
            'saccade_rate': 0.20,       # 扫视频率（酒驾者降低）
            'fixation_duration': 0.20,  # 注视时长（酒驾者增加）
            'head_tremor': 0.15,        # 头部微抖动（酒驾者增加）
            'reaction_delay': 0.15,     # 反应延迟（酒驾者增加）
            'facial_flush': 0.05,       # 面部潮红（辅助信号）
        }
    
    def extract_features(self, frames: List[dict]) -> dict:
        """
        从帧序列中提取损伤检测特征
        
        Args:
            frames: 每帧包含 gaze, head_pose, facial_landmarks
            
        Returns:
            features dict
        """
        features = {}
        
        # 1. 眼动熵：衡量眼动模式的随机性
        # 正常驾驶：高熵（频繁扫视道路各区域）
        # 酒驾：低熵（凝视固定，扫视减少）
        gaze_points = np.array([f['gaze'] for f in frames])
        hist, _ = np.histogramdd(gaze_points, bins=(5, 5))
        hist_norm = hist / (hist.sum() + 1e-8)
        features['gaze_entropy'] = -np.sum(hist_norm * np.log(hist_norm + 1e-8))
        
        # 2. 扫视频率
        saccades = 0
        for i in range(1, len(gaze_points)):
            dist = np.linalg.norm(gaze_points[i] - gaze_points[i-1])
            if dist > 0.1:  # 扫视阈值
                saccades += 1
        features['saccade_rate'] = saccades / (len(frames) / self.fps)
        
        # 3. 平均注视时长
        fixations = []
        current_fix = 0
        for i in range(1, len(gaze_points)):
            dist = np.linalg.norm(gaze_points[i] - gaze_points[i-1])
            if dist < 0.05:  # 注视阈值
                current_fix += 1
            else:
                if current_fix > 0:
                    fixations.append(current_fix / self.fps)
                current_fix = 0
        features['fixation_duration'] = np.mean(fixations) if fixations else 0.0
        
        # 4. 头部微抖动（高频运动）
        head_poses = np.array([f['head_pose'][:3] for f in frames])  # pitch, yaw, roll
        if len(head_poses) > 3:
            # 高频分量（去除低频趋势后的残差能量）
            from scipy.signal import detrend
            detrended = detrend(head_poses, axis=0)
            features['head_tremor'] = np.mean(np.std(detrended, axis=0))
        else:
            features['head_tremor'] = 0.0
        
        # 5. 反应延迟（从事件到行为响应的时间）
        # 简化：使用眼动变化率作为代理指标
        gaze_change_rate = np.mean(np.abs(np.diff(gaze_points, axis=0)))
        features['reaction_delay'] = 1.0 / (gaze_change_rate + 1e-6)
        
        # 6. 面部潮红（RGB颜色变化）
        if 'face_color' in frames[0]:
            face_colors = np.array([f['face_color'] for f in frames])
            # 红色通道相对变化
            r_ratio = face_colors[:, 0] / (face_colors[:, 1:].mean(axis=1) + 1e-8)
            features['facial_flush'] = np.mean(r_ratio[-30:]) - np.mean(r_ratio[:30])
        else:
            features['facial_flush'] = 0.0
        
        return features
    
    def assess_impairment(self, features: dict) -> dict:
        """
        评估损伤概率
        
        Returns:
            {'impairment_score': float, 'is_impaired': bool, 
             'dominant_indicator': str}
        """
        # 正常驾驶基线值
        baselines = {
            'gaze_entropy': 2.5,        # 正常眼动熵
            'saccade_rate': 3.0,          # 正常扫视频率 (次/秒)
            'fixation_duration': 0.3,     # 正常注视时长 (秒)
            'head_tremor': 0.02,          # 正常头部抖动
            'reaction_delay': 0.5,        # 正常反应延迟基线
            'facial_flush': 0.0,          # 无面部潮红
        }
        
        # 计算各指标偏离度
        deviations = {}
        for key, value in features.items():
            baseline = baselines.get(key, 0.0)
            if baseline > 0:
                deviations[key] = abs(value - baseline) / baseline
            else:
                deviations[key] = abs(value - baseline) * 10
        
        # 加权综合评分
        impairment_score = sum(
            self.weights[k] * min(deviations.get(k, 0), 2.0)
            for k in self.weights
        )
        impairment_score = min(impairment_score, 1.0)
        
        # 主要损伤指标
        dominant = max(deviations, key=deviations.get) if deviations else 'none'
        
        return {
            'impairment_score': float(impairment_score),
            'is_impaired': impairment_score > 0.5,
            'dominant_indicator': dominant,
            'feature_deviations': {k: float(v) for k, v in deviations.items()},
            'confidence': float(min(max(impairment_score, 0.1), 0.95))
        }


# 模拟测试
if __name__ == "__main__":
    detector = VisualImpairmentDetector(fps=30, window_sec=10)
    
    # 模拟正常驾驶帧序列
    np.random.seed(42)
    normal_frames = []
    for i in range(300):  # 10秒@30fps
        normal_frames.append({
            'gaze': np.random.uniform(-0.3, 0.3, 2),  # 眼动分布广泛
            'head_pose': np.random.normal(0, 0.05, 6),  # 头部稳定
            'face_color': np.array([180, 170, 160]) + np.random.normal(0, 5, 3),
        })
    
    # 模拟酒驾帧序列
    impaired_frames = []
    for i in range(300):
        impaired_frames.append({
            'gaze': np.random.uniform(-0.1, 0.1, 2),  # 眼动范围收窄
            'head_pose': np.random.normal(0, 0.08, 6),  # 头部抖动增加
            'face_color': np.array([195, 168, 155]) + np.random.normal(0, 5, 3),  # 偏红
        })
    
    normal_result = detector.assess_impairment(
        detector.extract_features(normal_frames))
    impaired_result = detector.assess_impairment(
        detector.extract_features(impaired_frames))
    
    print("=== 正常驾驶 ===")
    print(f"损伤评分: {normal_result['impairment_score']:.3f}")
    print(f"是否损伤: {normal_result['is_impaired']}")
    print(f"主要指标: {normal_result['dominant_indicator']}")
    
    print("\n=== 酒后驾驶 ===")
    print(f"损伤评分: {impaired_result['impairment_score']:.3f}")
    print(f"是否损伤: {impaired_result['is_impaired']}")
    print(f"主要指标: {impaired_result['dominant_indicator']}")
    print(f"置信度: {impaired_result['confidence']:.2f}")

class DFRInterventionStrategy:
    """
    DFR 分级干预策略
    
    将损伤评分映射到具体干预措施
    """
    
    LEVELS = [
        {
            'level': 0,
            'name': '正常',
            'score_range': (0, 0.3),
            'actions': ['持续监测'],
            'adas_mode': '正常'
        },
        {
            'level': 1,
            'name': '轻度警告',
            'score_range': (0.3, 0.5),
            'actions': ['视觉提示', '听觉提醒'],
            'adas_mode': '提高敏感度'
        },
        {
            'level': 2,
            'name': '中度警告',
            'score_range': (0.5, 0.7),
            'actions': ['语音警告', '振动座椅', '建议停车'],
            'adas_mode': '主动辅助'
        },
        {
            'level': 3,
            'name': '紧急干预',
            'score_range': (0.7, 1.0),
            'actions': ['强制减速', '靠边停车', '紧急呼叫'],
            'adas_mode': '接管控制'
        }
    ]
    
    def get_intervention(self, impairment_score: float, 
                         is_impaired: bool) -> dict:
        for level in self.LEVELS:
            low, high = level['score_range']
            if low <= impairment_score < high:
                return level
        return self.LEVELS[-1]


# 测试
if __name__ == "__main__":
    strategy = DFRInterventionStrategy()
    
    test_cases = [0.15, 0.4, 0.6, 0.85]
    for score in test_cases:
        result = strategy.get_intervention(score, score > 0.5)
        print(f"评分 {score:.2f} → Level {result['level']}: {result['name']} → {result['actions']}")