"""
上下文感知疲劳检测框架

论文 Section 4.3: Safety and Security

核心思想: 疲劳检测不应只依赖面部特征,
应融合驾驶行为、环境条件和历史模式
"""

import numpy as np
from dataclasses import dataclass
from typing import Optional, List

@dataclass
class DrivingContext:
    """驾驶上下文"""
    speed: float           # km/h
    acceleration: float    # m/s²
    steering_angle: float  # 度
    road_type: str         # highway/urban/rural
    time_of_day: str       # day/night/dawn/dusk
    weather: str           # clear/rain/fog/snow
    driving_duration: float  # hours

@dataclass 
class OccupantContext:
    """乘员上下文"""
    face_detected: bool
    eye_openness: float    # 0-1
    blink_rate: float     # blinks/min
    head_pose: tuple      # (pitch, yaw, roll)
    gaze_direction: tuple  # (x, y, z)
    body_posture: str     # upright/leaning/slouching

@dataclass
class VehicleContext:
    """车辆上下文"""
    adas_level: int        # 0-5
    lane_departure: bool
    fcw_alert: bool        # forward collision warning
    autopilot_active: bool

class ContextAwareFatigueDetector:
    """
    上下文感知疲劳检测器
    
    融合三层上下文:
    1. 驾驶上下文: 行为特征反映疲劳
    2. 乘员上下文: 面部特征直接测量
    3. 车辆上下文: ADAS 状态影响判定
    """
    
    # 上下文权重配置（论文建议动态调整）
    CONTEXT_WEIGHTS = {
        'highway_night': {
            'face': 0.5, 'driving': 0.3, 'vehicle': 0.2
        },
        'urban_day': {
            'face': 0.7, 'driving': 0.2, 'vehicle': 0.1
        },
        'autopilot_active': {
            'face': 0.8, 'driving': 0.0, 'vehicle': 0.2
        }
    }
    
    def __init__(self):
        self.fatigue_history = []
        self.context_history = []
    
    def detect(self, driving: DrivingContext, 
               occupant: OccupantContext,
               vehicle: VehicleContext) -> dict:
        """
        上下文感知疲劳检测
        
        Returns:
            dict with fatigue_level, confidence, recommendation
        """
        # 1. 确定上下文模式
        context_mode = self._get_context_mode(driving, vehicle)
        weights = self.CONTEXT_WEIGHTS.get(context_mode, 
                                            self.CONTEXT_WEIGHTS['urban_day'])
        
        # 2. 面部特征评分
        face_score = self._face_fatigue_score(occupant)
        
        # 3. 驾驶行为评分
        driving_score = self._driving_fatigue_score(driving)
        
        # 4. 车辆状态评分
        vehicle_score = self._vehicle_fatigue_score(vehicle, driving)
        
        # 5. 加权融合
        total_score = (
            weights['face'] * face_score +
            weights['driving'] * driving_score +
            weights['vehicle'] * vehicle_score
        )
        
        # 6. 时序平滑
        self.fatigue_history.append(total_score)
        if len(self.fatigue_history) > 30:
            self.fatigue_history.pop(0)
        
        smoothed_score = np.mean(self.fatigue_history[-10:])
        
        # 7. 决策
        level = self._score_to_level(smoothed_score, context_mode)
        
        return {
            'fatigue_level': level,
            'confidence': min(smoothed_score, 1 - smoothed_score),
            'context_mode': context_mode,
            'face_score': face_score,
            'driving_score': driving_score,
            'vehicle_score': vehicle_score,
            'recommendation': self._get_recommendation(level, context_mode),
        }
    
    def _get_context_mode(self, driving: DrivingContext,
                          vehicle: VehicleContext) -> str:
        """确定当前上下文模式"""
        if vehicle.autopilot_active:
            return 'autopilot_active'
        if driving.road_type == 'highway' and 'night' in driving.time_of_day:
            return 'highway_night'
        return 'urban_day'
    
    def _face_fatigue_score(self, occ: OccupantContext) -> float:
        """面部疲劳评分 (0-1)"""
        score = 0.0
        
        # PERCLOS 等价指标
        if occ.eye_openness < 0.3:
            score += 0.4
        
        # 眨眼频率异常
        if occ.blink_rate > 25 or occ.blink_rate < 8:
            score += 0.3
        
        # 头部姿态（点头）
        if occ.head_pose[0] > 15:  # pitch > 15°
            score += 0.3
        
        return min(score, 1.0)
    
    def _driving_fatigue_score(self, driving: DrivingContext) -> float:
        """驾驶行为疲劳评分"""
        score = 0.0
        
        # 方向盘微修正增多（疲劳特征）
        steering_var = abs(driving.steering_angle)
        if steering_var > 3:
            score += 0.3
        
        # 驾驶时长
        if driving.driving_duration > 2.0:
            score += 0.3
        if driving.driving_duration > 4.0:
            score += 0.2
        
        # 速度波动
        if abs(driving.acceleration) > 0.5:
            score += 0.2
        
        return min(score, 1.0)
    
    def _vehicle_fatigue_score(self, vehicle: VehicleContext,
                                 driving: DrivingContext) -> float:
        """车辆状态疲劳评分"""
        score = 0.0
        
        if vehicle.lane_departure:
            score += 0.4
        if vehicle.fcw_alert:
            score += 0.3
        if driving.speed < 50 and driving.road_type == 'highway':
            score += 0.3  # 高速公路低速也是疲劳信号
        
        return min(score, 1.0)
    
    def _score_to_level(self, score: float, mode: str) -> str:
        """上下文感知的等级判定"""
        # 高速夜间降低阈值（更保守）
        if mode == 'highway_night':
            thresholds = [0.3, 0.5, 0.7]
        else:
            thresholds = [0.4, 0.6, 0.8]
        
        if score < thresholds[0]:
            return 'awake'
        elif score < thresholds[1]:
            return 'mild_fatigue'
        elif score < thresholds[2]:
            return 'moderate_fatigue'
        else:
            return 'severe_fatigue'
    
    def _get_recommendation(self, level: str, mode: str) -> str:
        """上下文感知的建议"""
        if level == 'severe_fatigue':
            if mode == 'highway_night':
                return 'CRITICAL: 立即靠边停车休息'
            return 'WARNING: 建议休息'
        elif level == 'moderate_fatigue':
            return 'ALERT: 二级警告+空调冷风'
        elif level == 'mild_fatigue':
            return 'INFO: 一级警告+音乐'
        return 'OK: 正常驾驶'


# ==================== 测试 ====================
if __name__ == "__main__":
    detector = ContextAwareFatigueDetector()
    
    # 场景1: 高速夜间疲劳
    print("=" * 60)
    print("场景1: 高速公路夜间疲劳驾驶")
    print("=" * 60)
    
    driving1 = DrivingContext(
        speed=120, acceleration=0.1, steering_angle=2.5,
        road_type='highway', time_of_day='night',
        weather='clear', driving_duration=3.5
    )
    occupant1 = OccupantContext(
        face_detected=True, eye_openness=0.25, blink_rate=28,
        head_pose=(18, 5, 2), gaze_direction=(0.1, -0.2, 1),
        body_posture='slouching'
    )
    vehicle1 = VehicleContext(
        adas_level=2, lane_departure=True, fcw_alert=False,
        autopilot_active=False
    )
    
    result1 = detector.detect(driving1, occupant1, vehicle1)
    print(f"疲劳等级: {result1['fatigue_level']}")
    print(f"置信度: {result1['confidence']:.2f}")
    print(f"上下文模式: {result1['context_mode']}")
    print(f"面部评分: {result1['face_score']:.2f}")
    print(f"驾驶评分: {result1['driving_score']:.2f}")
    print(f"建议: {result1['recommendation']}")
    
    # 场景2: 城市白天轻微疲劳
    print("\n" + "=" * 60)
    print("场景2: 城市白天轻微疲劳")
    print("=" * 60)
    
    detector2 = ContextAwareFatigueDetector()
    driving2 = DrivingContext(
        speed=45, acceleration=0.2, steering_angle=1.0,
        road_type='urban', time_of_day='day',
        weather='clear', driving_duration=1.5
    )
    occupant2 = OccupantContext(
        face_detected=True, eye_openness=0.45, blink_rate=22,
        head_pose=(8, 3, 1), gaze_direction=(0, 0, 1),
        body_posture='upright'
    )
    vehicle2 = VehicleContext(
        adas_level=1, lane_departure=False, fcw_alert=False,
        autopilot_active=False
    )
    
    result2 = detector2.detect(driving2, occupant2, vehicle2)
    print(f"疲劳等级: {result2['fatigue_level']}")
    print(f"建议: {result2['recommendation']}")
    
    # 场景3: 自动驾驶模式
    print("\n" + "=" * 60)
    print("场景3: 自动驾驶模式下的乘员监控")
    print("=" * 60)
    
    detector3 = ContextAwareFatigueDetector()
    driving3 = DrivingContext(
        speed=100, acceleration=0, steering_angle=0,
        road_type='highway', time_of_day='day',
        weather='clear', driving_duration=2.0
    )
    occupant3 = OccupantContext(
        face_detected=True, eye_openness=0.15, blink_rate=15,
        head_pose=(25, 10, 5), gaze_direction=(0.2, -0.3, 0.5),
        body_posture='leaning'
    )
    vehicle3 = VehicleContext(
        adas_level=4, lane_departure=False, fcw_alert=False,
        autopilot_active=True
    )
    
    result3 = detector3.detect(driving3, occupant3, vehicle3)
    print(f"疲劳等级: {result3['fatigue_level']}")
    print(f"上下文模式: {result3['context_mode']}")
    print(f"面部权重: {detector3.CONTEXT_WEIGHTS['autopilot_active']['face']}")
    print(f"建议: {result3['recommendation']}")
    print("💡 自动驾驶时面部特征权重提升至0.8（驾驶行为不再可靠）")