"""
Minieye DFR (Driver Functional Readiness) 概念实现
基于公开信息复现的核心逻辑框架

核心思路：
1. 融合舱内驾驶员状态 + 车外 ADAS 道路情境
2. 输出功能就绪度评分 (0-100)
3. 根据评分触发分级干预
"""

import numpy as np
from dataclasses import dataclass, field
from typing import Optional
from enum import IntEnum


class InterventionLevel(IntEnum):
    """干预等级，对应 Euro NCAP 分级警告体系"""
    NORMAL = 0       # 正常驾驶，无需干预
    LEVEL_1 = 1       # 舱内安全警报
    LEVEL_2 = 2       # ADAS 辅助介入
    LEVEL_3 = 3       # 紧急接管


@dataclass
class DriverState:
    """驾驶员状态向量（来自 DMS 摄像头）"""
    perclos: float = 0.0          # PERCLOS 值 (0-100%)
    gaze_off_road: float = 0.0    # 视线偏离道路比例 (0-100%)
    blink_rate: float = 0.0       # 眨眼频率 (次/分钟)
    head_pose_dev: float = 0.0    # 头部姿态偏差角度 (度)
    alcohol_impairment: float = 0.0  # 酒驾损伤概率 (0-1)
    emotion_state: str = "neutral"  # 情绪状态


@dataclass  
class RoadContext:
    """ADAS 道路情境向量"""
    collision_risk: float = 0.0     # 碰撞风险 (0-1)
    road_complexity: float = 0.0   # 道路复杂度 (0-1)
    speed_kmh: float = 0.0         # 车速
    traffic_density: float = 0.0   # 交通密度 (0-1)
    lane_deviation: float = 0.0    # 车道偏离程度 (0-1)


class DFRModel:
    """
    Driver Functional Readiness 模型
    
    融合驾驶员状态和道路情境，输出功能就绪度评分和干预等级
    
    理论基础：
    - 驾驶员功能就绪度 = f(驾驶员状态, 道路情境要求)
    - 同样的驾驶员状态在不同道路情境下，功能就绪度不同
    - 例如：轻度疲劳在高速直路上可接受，在复杂城市场景则不可接受
    """
    
    def __init__(self):
        # 驾驶员状态权重
        self.driver_weights = {
            'perclos': 0.25,
            'gaze_off_road': 0.20,
            'blink_rate': 0.10,
            'head_pose_dev': 0.10,
            'alcohol_impairment': 0.30,
            'emotion_distress': 0.05
        }
        
        # 道路情境要求权重
        self.road_weights = {
            'collision_risk': 0.40,
            'road_complexity': 0.25,
            'speed_factor': 0.15,
            'traffic_density': 0.10,
            'lane_deviation': 0.10
        }
    
    def assess_driver_state(self, state: DriverState) -> float:
        """
        评估驾驶员状态得分 (0-100, 越高越差)
        
        Args:
            state: 驾驶员状态向量
            
        Returns:
            driver_impairment: 驾驶员损伤度 (0-100)
        """
        # PERCLOS 评估
        perclos_score = min(state.perclos / 30.0, 1.0) * 100
        
        # 视线偏离评估
        gaze_score = min(state.gaze_off_road / 50.0, 1.0) * 100
        
        # 眨眼频率评估（正常 15-20 次/分，异常 <8 或 >30）
        if state.blink_rate < 8 or state.blink_rate > 30:
            blink_score = 60.0
        else:
            blink_score = abs(state.blink_rate - 18) * 5
        
        # 头部姿态偏差评估
        head_score = min(state.head_pose_dev / 30.0, 1.0) * 100
        
        # 酒驾损伤评估
        alcohol_score = state.alcohol_impairment * 100
        
        # 情绪困扰
        emotion_score = 80.0 if state.emotion_state in ['angry', 'sad'] else 10.0
        
        # 加权融合
        driver_impairment = (
            perclos_score * self.driver_weights['perclos'] +
            gaze_score * self.driver_weights['gaze_off_road'] +
            blink_score * self.driver_weights['blink_rate'] +
            head_score * self.driver_weights['head_pose_dev'] +
            alcohol_score * self.driver_weights['alcohol_impairment'] +
            emotion_score * self.driver_weights['emotion_distress']
        )
        
        return min(driver_impairment, 100.0)
    
    def assess_road_demand(self, context: RoadContext) -> float:
        """
        评估道路情境需求 (0-100, 越高表示对驾驶员要求越高)
        
        Args:
            context: 道路情境向量
            
        Returns:
            road_demand: 道路需求度 (0-100)
        """
        collision_score = context.collision_risk * 100
        complexity_score = context.road_complexity * 100
        speed_score = min(context.speed_kmh / 120.0, 1.0) * 100
        traffic_score = context.traffic_density * 100
        lane_score = context.lane_deviation * 100
        
        road_demand = (
            collision_score * self.road_weights['collision_risk'] +
            complexity_score * self.road_weights['road_complexity'] +
            speed_score * self.road_weights['speed_factor'] +
            traffic_score * self.road_weights['traffic_density'] +
            lane_score * self.road_weights['lane_deviation']
        )
        
        return min(road_demand, 100.0)
    
    def compute_readiness(self, state: DriverState, 
                          context: RoadContext) -> tuple:
        """
        计算驾驶员功能就绪度
        
        DFR 核心公式：
            readiness = 100 - (driver_impairment * (0.4 + road_demand/200))
        
        道路需求越高，同样的驾驶员损伤对就绪度影响越大
        这体现了"情境感知"的核心思想
        
        Args:
            state: 驾驶员状态
            context: 道路情境
            
        Returns:
            readiness_score: 功能就绪度 (0-100, 越高越好)
            intervention: 干预等级
        """
        driver_impairment = self.assess_driver_state(state)
        road_demand = self.assess_road_demand(context)
        
        # 核心融合：道路需求放大驾驶员损伤的影响
        amplification = 0.4 + road_demand / 200.0
        effective_impairment = min(driver_impairment * amplification, 100.0)
        
        readiness_score = 100.0 - effective_impairment
        
        # 分级干预决策
        if readiness_score >= 80:
            intervention = InterventionLevel.NORMAL
        elif readiness_score >= 60:
            intervention = InterventionLevel.LEVEL_1
        elif readiness_score >= 40:
            intervention = InterventionLevel.LEVEL_2
        else:
            intervention = InterventionLevel.LEVEL_3
        
        return readiness_score, intervention


# ========== 测试用例 ==========

if __name__ == "__main__":
    model = DFRModel()
    
    # 场景1：轻度疲劳 + 高速直路（低道路需求）
    driver1 = DriverState(
        perclos=12.0,
        gaze_off_road=15.0,
        blink_rate=22,
        head_pose_dev=5,
        alcohol_impairment=0.0,
        emotion_state="neutral"
    )
    road1 = RoadContext(
        collision_risk=0.1,
        road_complexity=0.2,
        speed_kmh=100,
        traffic_density=0.2,
        lane_deviation=0.05
    )
    score1, level1 = model.compute_readiness(driver1, road1)
    print(f"场景1 - 轻度疲劳+高速直路:")
    print(f"  就绪度: {score1:.1f}/100, 干预: {level1.name}")
    print()
    
    # 场景2：同样轻度疲劳 + 复杂城市场景（高道路需求）
    driver2 = DriverState(
        perclos=12.0,
        gaze_off_road=15.0,
        blink_rate=22,
        head_pose_dev=5,
        alcohol_impairment=0.0,
        emotion_state="neutral"
    )
    road2 = RoadContext(
        collision_risk=0.6,
        road_complexity=0.8,
        speed_kmh=50,
        traffic_density=0.7,
        lane_deviation=0.2
    )
    score2, level2 = model.compute_readiness(driver2, road2)
    print(f"场景2 - 轻度疲劳+复杂城区:")
    print(f"  就绪度: {score2:.1f}/100, 干预: {level2.name}")
    print()
    
    # 场景3：酒驾损伤 + 任何道路
    driver3 = DriverState(
        perclos=8.0,
        gaze_off_road=25.0,
        blink_rate=28,
        head_pose_dev=12,
        alcohol_impairment=0.7,
        emotion_state="neutral"
    )
    road3 = RoadContext(
        collision_risk=0.3,
        road_complexity=0.5,
        speed_kmh=60,
        traffic_density=0.4,
        lane_deviation=0.15
    )
    score3, level3 = model.compute_readiness(driver3, road3)
    print(f"场景3 - 酒驾损伤+普通道路:")
    print(f"  就绪度: {score3:.1f}/100, 干预: {level3.name}")