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

@dataclass
class AviationFatigueIndex:
    """
    航空业疲劳指数模型
    
    融合三个生理维度：
    1. HRV (心率变异性) — 自主神经平衡
    2. 昼夜节律 — 生物钟相位
    3. 累积睡眠负债 — 慢性睡眠不足
    
    相比汽车DMS仅用PERCLOS单一指标
    """
    
    # HRV指标
    hrv_rmssd: float = 45.0  # RMSSD (ms)，正常>40
    hrv_lf_hf_ratio: float = 1.8  # 交感/副交感平衡
    
    # 昼夜节律
    circadian_phase: float = -2.5  # 相位偏移(小时)
    melatonin_offset: float = 0.7  # 褪黑素水平
    
    # 睡眠负债
    sleep_debt_hours: float = 3.5  # 累积睡眠负债
    last_sleep_quality: float = 0.65  # 睡眠质量评分(0-1)
    
    @property
    def fatigue_score(self) -> float:
        """
        综合疲劳评分 (0-100, 越高越疲劳)
        
        权重设计：
        - HRV下降 → 35%
        - 昼夜节律低谷 → 25%
        - 睡眠负债 → 30%
        - 睡眠质量 → 10%
        """
        # HRV评分（越低越疲劳）
        hrv_score = max(0, min(100, 
            100 * (1 - max(0, 40 - self.hrv_rmssd) / 20)))
        
        # 昼夜节律评分（偏离越大越疲劳）
        circadian_score = 100 * min(1, abs(self.circadian_phase) / 4)
        
        # 睡眠负债评分
        sleep_debt_score = min(100, self.sleep_debt_hours * 20)
        
        # 睡眠质量评分
        quality_score = 100 * (1 - self.last_sleep_quality)
        
        # 加权综合
        total = (
            0.35 * hrv_score +
            0.25 * circadian_score +
            0.30 * sleep_debt_score +
            0.10 * quality_score
        )
        
        return total
    
    @property
    def action_threshold(self) -> str:
        """决策阈值"""
        score = self.fatigue_score
        if score < 30:
            return "正常 — 可执行任务"
        elif score < 50:
            return "轻度疲劳 — 加强监控"
        elif score < 70:
            return "中度疲劳 — 建议替换"
        else:
            return "重度疲劳 — 必须替换"


# 测试不同状态
scenarios = [
    ("充分休息", AviationFatigueIndex(hrv_rmssd=55, circadian_phase=0, sleep_debt_hours=0, last_sleep_quality=0.9)),
    ("轻微疲劳", AviationFatigueIndex(hrv_rmssd=42, circadian_phase=-1.5, sleep_debt_hours=2, last_sleep_quality=0.7)),
    ("中度疲劳", AviationFatigueIndex(hrv_rmssd=35, circadian_phase=-2.5, sleep_debt_hours=4, last_sleep_quality=0.5)),
    ("严重疲劳", AviationFatigueIndex(hrv_rmssd=28, circadian_phase=-3.5, sleep_debt_hours=6, last_sleep_quality=0.3)),
]

print(f"{'场景':<12} {'HRV':>5} {'相位':>6} {'负债':>5} {'质量':>5} {'评分':>6} {'决策'}")
print("-" * 70)
for name, s in scenarios:
    print(f"{name:<12} {s.hrv_rmssd:>5.0f} {s.circadian_phase:>+5.1f}h {s.sleep_debt_hours:>4.1f}h {s.last_sleep_quality:>4.2f} {s.fatigue_score:>5.1f} {s.action_threshold}")

class PERCLOS_vs_Aviation:
    """
    PERCLOS局限性分析
    
    PERCLOS = Percentage of Eye Closure
    
    问题1：只能检测"已经发生的"疲劳（眼睑闭合）
    问题2：无法区分原因（疲劳 vs 眨眼 vs 眼疾）
    问题3：没有预防性（疲劳前无法预警）
    问题4：单一维度（不考虑睡眠负债和昼夜节律）
    """
    
    def __init__(self):
        self.perclos_threshold = 0.15  # 15%闭眼率
        
    def calculate_perclos(self, eye_openness: np.ndarray, 
                          window_sec: int = 60,
                          fps: int = 30) -> float:
        """
        PERCLOS计算（传统汽车DMS方案）
        """
        window = int(window_sec * fps)
        closed = np.sum(eye_openness < 0.2) / window
        return closed * 100
    
    def aviation_comparison(self):
        """对比表"""
        comparison = {
            "数据维度": {"PERCLOS": "1维（眼睑开度）", "航空": "3维+（HRV+昼夜+睡眠）"},
            "时间窗": {"PERCLOS": "实时（60s窗口）", "航空": "连续（飞行前+飞行中）"},
            "预防性": {"PERCLOS": "无（事后检测）", "航空": "有（飞行前拦截）"},
            "误报率": {"PERCLOS": "高（眨眼/眼疾）", "航空": "低（多源融合）"},
            "隐私": {"PERCLOS": "车内处理", "航空": "令牌化管道"},
            "部署成本": {"PERCLOS": "低（1×摄像头）", "航空": "高（可穿戴+后端AI）"},
        }
        return comparison


comp = PERCLOS_vs_Aviation()
# 模拟PERCLOS计算
np.random.seed(42)
normal_eyes = np.random.normal(0.8, 0.1, 1800)  # 正常
drowsy_eyes = np.random.normal(0.5, 0.15, 1800)  # 困倦

print(f"正常驾驶 PERCLOS: {comp.calculate_perclos(normal_eyes):.1f}%")
print(f"困倦状态 PERCLOS: {comp.calculate_perclos(drowsy_eyes):.1f}%")
print(f"阈值: {comp.perclos_threshold*100:.0f}%")
print(f"\n航空方案多维度融合，可提前8小时预警")

class TokenizedHealthPipeline:
    """
    航空业令牌化健康数据管道
    
    核心思想：健康遥测数据不以原始个人数据形式到达调度器
    
    流程：
    1. 可穿戴设备采集原始生理数据
    2. 边缘AI计算疲劳评分（0-100）
    3. 仅传输评分（不含原始生理数据）
    4. 评分与阈值比较→排班决策
    5. 原始数据保留在设备/本地
    """
    
    def __init__(self):
        self.privacy_level = "high"
        self.data_retention = "device_only"
    
    def process(self, raw_physiology: dict) -> dict:
        """
        处理流程：原始生理数据 → 疲劳评分 → 决策令牌
        """
        # Step 1: 边缘计算（不传输原始数据）
        fatigue_score = self._compute_fatigue(raw_physiology)
        
        # Step 2: 仅输出评分+决策（不含原始生理数据）
        token = {
            "pilot_id_hash": hash(raw_physiology.get("pilot_id", "")),
            "timestamp": raw_physiology.get("timestamp"),
            "fatigue_score": fatigue_score,
            "action": "clear" if fatigue_score < 50 else "hold",
            # 注意：不包含HRV、睡眠数据等原始值
        }
        
        return token
    
    def _compute_fatigue(self, raw: dict) -> float:
        """边缘AI计算"""
        hrv = raw.get("hrv_rmssd", 45)
        sleep_debt = raw.get("sleep_debt_hours", 0)
        circadian = raw.get("circadian_phase", 0)
        
        score = (
            0.35 * max(0, (40 - hrv) / 20 * 100) +
            0.30 * min(100, sleep_debt * 20) +
            0.25 * min(100, abs(circadian) / 4 * 100) +
            0.10 * (1 - raw.get("sleep_quality", 0.7)) * 100
        )
        return min(100, max(0, score))


# 模拟
pipeline = TokenizedHealthPipeline()
raw_data = {
    "pilot_id": "PLT001",
    "timestamp": "2026-10-11T04:00:00Z",
    "hrv_rmssd": 32,
    "sleep_debt_hours": 5,
    "circadian_phase": -3.0,
    "sleep_quality": 0.4
}

token = pipeline.process(raw_data)
print("原始数据:", {k:v for k,v in raw_data.items() if k != "pilot_id"})
print("输出令牌:", token)
print("→ 调度器只能看到评分，看不到HRV/睡眠等原始数据")

class EnhancedCabinFatigueModel:
    """
    借鉴航空方案的增强座舱疲劳检测模型
    
    核心改进：从单一PERCLOS→多维融合+预防性
    
    数据源（全部来自车载传感器，无需可穿戴）：
    1. 摄像头：PERCLOS + 眨眼频率 + 头部姿态 + 视线分散度
    2. 方向盘ECG：HRV（当手握方向盘时）
    3. rPPG摄像头：心率（替代ECG）
    4. 驾驶行为：方向盘操作频率+车道保持+刹车平滑度
    5. 上下文：驾驶时长+时间（昼夜节律）+历史数据
    """
    
    def __init__(self):
        self.weights = {
            'perclos': 0.20,          # 眼睑闭合度
            'blink_frequency': 0.10,  # 眨眼频率变化
            'head_pose': 0.10,        # 头部点头/侧倾
            'gaze_scatter': 0.10,     # 视线分散度
            'hrv_proxy': 0.15,        # rPPG-HRV替代
            'driving_behavior': 0.15, # 驾驶行为退化
            'time_context': 0.10,     # 驾驶时长+昼夜节律
            'history_trend': 0.10,    # 历史疲劳趋势
        }
    
    def compute_fatigue(self, features: dict) -> dict:
        """
        多维融合疲劳评分
        
        Returns:
            {
                'score': 0-100,
                'level': 'normal'/'mild'/'moderate'/'severe',
                'primary_indicator': '主要贡献因子',
                'preventive_alert': bool  # 预防性预警
            }
        """
        scores = {}
        
        # PERCLOS
        perclos = features.get('perclos', 5)
        scores['perclos'] = min(100, perclos * 4)  # 15%→60分
        
        # 眨眼频率（正常15-20次/分钟）
        blink = features.get('blink_frequency', 17)
        scores['blink_frequency'] = min(100, abs(blink - 17) * 8)
        
        # 头部姿态（点头频率）
        nod_count = features.get('head_nod_count_5min', 0)
        scores['head_pose'] = min(100, nod_count * 15)
        
        # 视线分散度
        gaze_std = features.get('gaze_std_deg', 5)
        scores['gaze_scatter'] = min(100, max(0, (gaze_std - 15) * 5))
        
        # HRV代理（rPPG心率变异性）
        hrv_proxy = features.get('rppg_hrv_ms', 40)
        scores['hrv_proxy'] = max(0, (40 - hrv_proxy) / 20 * 100)
        
        # 驾驶行为
        lane_dev = features.get('lane_deviation_cm', 10)
        scores['driving_behavior'] = min(100, max(0, (lane_dev - 20) * 3))
        
        # 时间上下文
        drive_hours = features.get('drive_hours', 0)
        circadian = abs(features.get('circadian_phase', 0))
        time_score = drive_hours * 8 + circadian * 15
        scores['time_context'] = min(100, time_score)
        
        # 历史趋势
        history = features.get('yesterday_sleep_hours', 7)
        scores['history_trend'] = max(0, (7 - history) / 3 * 100)
        
        # 加权综合
        total = sum(self.weights[k] * scores[k] for k in scores)
        
        # 主要贡献因子
        primary = max(scores, key=scores.get)
        
        # 预防性预警（驾驶>2小时+时间在2-5AM）
        is_preventive = (
            features.get('drive_hours', 0) > 2 and
            features.get('time_of_day', 12) in range(0, 6)
        )
        
        if total < 25:
            level = 'normal'
        elif total < 45:
            level = 'mild'
        elif total < 65:
            level = 'moderate'
        else:
            level = 'severe'
        
        return {
            'score': round(total, 1),
            'level': level,
            'primary_indicator': primary,
            'preventive_alert': is_preventive,
            'component_scores': {k: round(v, 1) for k, v in scores.items()}
        }


# 测试
model = EnhancedCabinFatigueModel()

scenarios = {
    "精力充沛": {
        'perclos': 3, 'blink_frequency': 17, 'head_nod_count_5min': 0,
        'gaze_std_deg': 8, 'rppg_hrv_ms': 50, 'lane_deviation_cm': 8,
        'drive_hours': 0.5, 'circadian_phase': 0, 'time_of_day': 14,
        'yesterday_sleep_hours': 8
    },
    "长途夜间": {
        'perclos': 12, 'blink_frequency': 25, 'head_nod_count_5min': 3,
        'gaze_std_deg': 18, 'rppg_hrv_ms': 28, 'lane_deviation_cm': 25,
        'drive_hours': 3.5, 'circadian_phase': -3, 'time_of_day': 3,
        'yesterday_sleep_hours': 5
    },
    "微睡眠边缘": {
        'perclos': 25, 'blink_frequency': 30, 'head_nod_count_5min': 8,
        'gaze_std_deg': 25, 'rppg_hrv_ms': 20, 'lane_deviation_cm': 35,
        'drive_hours': 4.5, 'circadian_phase': -3.5, 'time_of_day': 2,
        'yesterday_sleep_hours': 4.5
    }
}

for name, features in scenarios.items():
    result = model.compute_fatigue(features)
    print(f"\n{'='*50}")
    print(f"场景: {name}")
    print(f"总评分: {result['score']}/100 ({result['level']})")
    print(f"主要因子: {result['primary_indicator']}")
    print(f"预防性预警: {'是' if result['preventive_alert'] else '否'}")
    print("分项:")
    for k, v in result['component_scores'].items():
        bar = '█' * int(v/5)
        print(f"  {k:<22} {v:5.1f} {bar}")