"""
个体校准面部行为监测框架

论文核心：不使用固定阈值，而是为每个驾驶员建立个人基线
这与通航40飞行员研究（Frontiers Neuroergonomics）的结论一致：
"跨人泛化失败→需个体校准"

校准流程：
1. 驾驶员正常驾驶5秒（neutral状态）
2. 计算个人基线：EAR/MAR/头部角度的均值+标准差
3. 后续状态检测：z-score超个人阈值→判定异常
"""

import numpy as np
from dataclasses import dataclass
from typing import Tuple, Optional
from enum import Enum

class BehavioralState(Enum):
    NEUTRAL = "neutral"
    EYE_CLOSURE = "eye_closure"
    OUT_OF_SAFE_ZONE = "out_of_safe_zone"
    YAWNING = "yawning"
    EXCESSIVE_BLINKING = "excessive_blinking"

@dataclass
class IndividualBaseline:
    """个体校准基线"""
    ear_mean: float          # 眼睛纵横比均值
    ear_std: float           # 标准差
    mar_mean: float          # 嘴纵横比均值
    mar_std: float
    head_pitch_mean: float   # 头部俯仰
    head_pitch_std: float
    head_yaw_mean: float     # 头部偏航
    head_yaw_std: float
    blink_rate_baseline: float  # 眨眼频率(次/分钟)
    
    @property
    def ear_threshold(self):
        """闭眼阈值：均值-2σ"""
        return self.ear_mean - 2 * self.ear_std
    
    @property
    def mar_threshold(self):
        """打哈欠阈值：均值+3σ"""
        return self.mar_mean + 3 * self.mar_std
    
    @property
    def blink_rate_threshold(self):
        """频繁眨眼阈值：基线×1.5"""
        return self.blink_rate_baseline * 1.5


class BehavioralStateDetector:
    """
    基于个体校准的行为状态检测器
    
    使用MediaPipe 468个3D面部地标
    特征：EAR(眼睛) + MAR(嘴) + 头部姿态
    分类器：SVM（论文中最佳）
    """
    
    def __init__(self):
        self.baseline: Optional[IndividualBaseline] = None
        self.calibrated = False
        self.history = []
        self.blink_timestamps = []
    
    def calibrate(self, neutral_features: list) -> bool:
        """
        个体校准：从neutral状态数据建立基线
        
        Args:
            neutral_features: [(ear, mar, pitch, yaw, blink), ...]
                              至少5秒数据(150帧@30fps)
        """
        if len(neutral_features) < 30:
            return False
        
        ears = [f[0] for f in neutral_features]
        mars = [f[1] for f in neutral_features]
        pitches = [f[2] for f in neutral_features]
        yaws = [f[3] for f in neutral_features]
        blinks = [f[4] for f in neutral_features if len(f) > 4]
        
        blink_rate = len([b for b in blinks if b]) * (60 / (len(neutral_features) / 30))
        
        self.baseline = IndividualBaseline(
            ear_mean=np.mean(ears), ear_std=np.std(ears),
            mar_mean=np.mean(mars), mar_std=np.std(mars),
            head_pitch_mean=np.mean(pitches), head_pitch_std=np.std(pitches),
            head_yaw_mean=np.mean(yaws), head_yaw_std=np.std(yaws),
            blink_rate_baseline=blink_rate,
        )
        self.calibrated = True
        return True
    
    def detect(self, ear: float, mar: float, 
               pitch: float, yaw: float,
               timestamp: float) -> BehavioralState:
        """
        实时行为状态检测
        
        基于个体阈值的规则判定
        """
        if not self.calibrated:
            return BehavioralState.NEUTRAL
        
        self.history.append((ear, mar, pitch, yaw, timestamp))
        if len(self.history) > 90:  # 3秒@30fps
            self.history = self.history[-90:]
        
        # 闭眼检测
        if ear < self.baseline.ear_threshold:
            return BehavioralState.EYE_CLOSURE
        
        # 打哈欠
        if mar > self.baseline.mar_threshold:
            return BehavioralState.YAWNING
        
        # 频繁眨眼
        recent_blinks = [h for h in self.history 
                        if h[0] < self.baseline.ear_mean - self.baseline.ear_std
                        and timestamp - h[4] < 60]  # 1分钟内
        blink_rate = len(recent_blinks)
        if blink_rate > self.baseline.blink_rate_threshold:
            return BehavioralState.EXCESSIVE_BLINKING
        
        # 头部偏离
        pitch_z = abs(pitch - self.baseline.head_pitch_mean) / max(self.baseline.head_pitch_std, 0.01)
        yaw_z = abs(yaw - self.baseline.head_yaw_mean) / max(self.baseline.head_yaw_std, 0.01)
        if pitch_z > 2 or yaw_z > 2:
            return BehavioralState.OUT_OF_SAFE_ZONE
        
        return BehavioralState.NEUTRAL


# ==================== SVM分类器 ====================
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

def train_classifiers(X: np.ndarray, y: np.ndarray):
    """
    训练SVM和RF分类器
    
    论文结果：
    - SVM: 10折CV ~91% 准确率/F1
    - RF: 10折CV ~91%，但室外测试降至~70%
    - CNN: ~80% F1
    - RNN: ~80% F1
    - 启发式规则: ~81% F1
    
    SVM最稳定，混淆集中在out-of-safe-zone/neutral
    """
    # SVM (论文最佳)
    svm = SVC(kernel='rbf', C=10, gamma='scale', random_state=42)
    svm_scores = cross_val_score(svm, X, y, cv=10, scoring='f1_macro')
    
    # RF
    rf = RandomForestClassifier(n_estimators=100, random_state=42)
    rf_scores = cross_val_score(rf, X, y, cv=10, scoring='f1_macro')
    
    print("=== 分类器性能对比（10折CV）===")
    print(f"SVM: F1={svm_scores.mean():.3f} ± {svm_scores.std():.3f}")
    print(f"RF:  F1={rf_scores.mean():.3f} ± {rf_scores.std():.3f}")
    print(f"论文参考: SVM ~91%, RF ~91%(室内), RF ~70%(室外)")
    
    return svm, rf


# ==================== 测试 ====================
if __name__ == "__main__":
    # 模拟个体校准
    np.random.seed(42)
    
    # neutral状态5秒(150帧)
    neutral_data = [
        (np.random.normal(0.28, 0.02),  # EAR
         np.random.normal(0.12, 0.02),  # MAR
         np.random.normal(0, 2),         # pitch
         np.random.normal(0, 3),          # yaw
         False)                           # blink
        for _ in range(150)
    ]
    
    detector = BehavioralStateDetector()
    success = detector.calibrate(neutral_data)
    
    print(f"个体校准: {'成功' if success else '失败'}")
    print(f"EAR基线: {detector.baseline.ear_mean:.3f} ± {detector.baseline.ear_std:.3f}")
    print(f"EAR闭眼阈值: {detector.baseline.ear_threshold:.3f}")
    print(f"MAR基线: {detector.baseline.mar_mean:.3f} ± {detector.baseline.mar_std:.3f}")
    print(f"MAR打哈欠阈值: {detector.baseline.mar_threshold:.3f}")
    print(f"眨眼频率基线: {detector.baseline.blink_rate_baseline:.1f}次/分")
    
    # 模拟实时检测
    print(f"\n--- 实时行为检测 ---")
    test_frames = [
        (0.25, 0.12, 0, 0, 0, "正常驾驶"),
        (0.10, 0.12, 0, 0, 0.5, "闭眼"),      # EAR低
        (0.28, 0.45, 0, 0, 0, "打哈欠"),     # MAR高
        (0.28, 0.12, 25, 0, 0, "头部偏离"),  # pitch大
        (0.28, 0.12, 0, 0, 0, "正常"),
    ]
    
    for ear, mar, pitch, yaw, t, expected in test_frames:
        state = detector.detect(ear, mar, pitch, yaw, t)
        print(f"  EAR={ear:.2f} MAR={mar:.2f} pitch={pitch:.0f}° → {state.value:20s} (期望: {expected})")