"""
Inverted-U Alpha 模型复现

论文提出Alpha功率与走神呈倒U型关系：
- 低Alpha(睁眼典型) → Alpha增加 = 走神增加
- 高Alpha(闭眼典型) → Alpha增加 = 走神减少

对IMS的启示：
1. 不能用单一Alpha阈值判断走神
2. 必须先检测眼睛状态，再解读Alpha含义
3. DMS摄像头可以检测眼睛开闭 → 为EEG替代方案提供可能
"""

import numpy as np

class EyeStateAwareDistractionDetector:
    """
    基于眼状态的认知分心检测器
    
    核心原理：
    - 眼睛开闭状态决定Alpha波含义
    - 睁眼+高Alpha → 走神(需警告)
    - 闭眼+高Alpha → 专注(不需警告)
    
    IMS替代方案：
    - 无EEG时用眨眼率+PERCLOS+扫视熵组合
    - 眼动模式可间接反映Alpha状态
    """
    
    def __init__(self):
        # Alpha功率阈值(需要根据实际EEG标定)
        self.alpha_threshold_open = 0.6   # 睁眼时Alpha z-score
        self.alpha_threshold_closed = 0.8  # 闭眼时Alpha z-score
        
        # IMS可用替代指标
        self.eye_openness_threshold = 0.3  # 眼睑开度<0.3视为闭眼
        self.blink_rate_baseline = 15      # 正常眨眼率(次/分)
        self.blink_rate_distraction = 25   # 走神时眨眼率
        self.saccade_entropy_normal = 2.0 # 正常扫视熵
        self.saccade_entropy_low = 1.2    # 低熵=注视固定=可能走神
    
    def detect_cognitive_distraction(self, eye_data: np.ndarray) -> dict:
        """
        基于眼状态感知的认知分心检测
        
        Args:
            eye_data: shape=(N, 4), 列=[eye_openness, gaze_x, gaze_y, pupil_diameter]
                      N = 30fps * 60s = 1800
        
        Returns:
            result: {
                'eye_state': 'open'/'closed'/'blinking',
                'distraction_level': 0-3,
                'distraction_type': str,
                'confidence': float,
                'indicators': dict
            }
        """
        eye_openness = eye_data[:, 0]
        gaze_x, gaze_y = eye_data[:, 1], eye_data[:, 2]
        pupil_d = eye_data[:, 3]
        
        # 1. 判断眼睛状态
        avg_openness = np.mean(eye_openness)
        if avg_openness < self.eye_openness_threshold:
            eye_state = 'closed'
        elif avg_openness > 0.7:
            eye_state = 'open'
        else:
            eye_state = 'blinking'  # 频繁眨眼
        
        # 2. 计算替代指标
        # 眨眼率
        blink_events = np.diff((eye_openness < self.eye_openness_threshold).astype(int))
        blink_count = np.sum(blink_events == -1)
        blink_rate = blink_count / (len(eye_openness) / 30 / 60)
        
        # 扫视熵
        hist, _, _ = np.histogram2d(gaze_x, gaze_y, bins=10, range=[[-1,1],[-1,1]])
        hist = hist / (hist.sum() + 1e-8)
        saccade_entropy = -np.sum(hist * np.log(hist + 1e-8))
        
        # 瞳孔直径变化(认知负荷间接指标)
        pupil_var = np.std(pupil_d)
        
        # 注视偏离比率
        gaze_offset = np.sqrt(gaze_x**2 + gaze_y**2)
        gaze_offset_ratio = np.mean(gaze_offset > 0.5)
        
        # 3. 基于眼状态的不同解读逻辑
        if eye_state == 'open':
            # 睁眼: Alpha↑=走神 → 用眨眼率↑+扫视熵↓作为替代
            distraction_score = 0.0
            
            # 眨眼率异常(高于基线=可能走神)
            if blink_rate > self.blink_rate_distraction:
                distraction_score += 0.3 * min((blink_rate - self.blink_rate_distraction) / 20, 1.0)
            
            # 扫视熵低(注视过于固定=注意力脱离)
            if saccade_entropy < self.saccade_entropy_low:
                distraction_score += 0.4 * (1 - saccade_entropy / self.saccade_entropy_normal)
            
            # 注视偏离(偏离道路=视觉分心)
            distraction_score += 0.3 * gaze_offset_ratio
            
            distraction_type = "视觉分心" if gaze_offset_ratio > 0.3 else "认知走神"
            
        elif eye_state == 'closed':
            # 闭眼: Alpha↑=专注 → 闭眼本身需要关注但不是走神
            # 长时间闭眼 = 疲劳/微睡眠
            closure_duration = np.sum(eye_openness < self.eye_openness_threshold) / 30
            
            if closure_duration > 3:
                distraction_score = min(closure_duration / 10, 1.0)
                distraction_type = "微睡眠/疲劳"
            else:
                # 短暂闭眼可能是思考(根据论文:闭眼+Alpha↑=专注)
                distraction_score = 0.1
                distraction_type = "内部思考(不需干预)"
        
        else:
            # 频繁眨眼: 可能是过渡状态
            distraction_score = 0.3
            distraction_type = "过渡状态(频繁眨眼)"
        
        # 分级
        if distraction_score < 0.3:
            level = 0
        elif distraction_score < 0.5:
            level = 1
        elif distraction_score < 0.7:
            level = 2
        else:
            level = 3
        
        return {
            'eye_state': eye_state,
            'distraction_level': level,
            'distraction_type': distraction_type,
            'confidence': round(distraction_score, 3),
            'indicators': {
                'blink_rate': round(blink_rate, 1),
                'saccade_entropy': round(saccade_entropy, 3),
                'pupil_var': round(float(pupil_var), 3),
                'gaze_offset_ratio': round(float(gaze_offset_ratio), 3),
                'avg_openness': round(float(avg_openness), 3)
            }
        }


# 测试
if __name__ == "__main__":
    np.random.seed(42)
    det = EyeStateAwareDistractionDetector()
    
    # 场景1: 睁眼走神(眨眼率高, 注视固定)
    eye_open = np.column_stack([
        np.random.normal(0.85, 0.05, 1800),  # 睁眼
        np.random.normal(0, 0.1, 1800),       # 注视前方但变化少
        np.random.normal(0, 0.1, 1800),
        np.random.normal(3.5, 0.15, 1800)
    ])
    # 人为增加眨眼
    for i in range(0, 1800, 20):
        eye_open[i:i+3, 0] = 0.1
    
    r1 = det.detect_cognitive_distraction(eye_open)
    print(f"睁眼走神: Level {r1['distraction_level']} - {r1['distraction_type']} (conf={r1['confidence']})")
    print(f"  眨眼率={r1['indicators']['blink_rate']}, 扫视熵={r1['indicators']['saccade_entropy']}")
    
    # 场景2: 闭眼专注(短时间闭眼)
    eye_closed = np.column_stack([
        np.random.normal(0.15, 0.02, 1800),  # 闭眼
        np.zeros(1800),
        np.zeros(1800),
        np.random.normal(2.5, 0.1, 1800)
    ])
    r2 = det.detect_cognitive_distraction(eye_closed)
    print(f"\n闭眼专注: Level {r2['distraction_level']} - {r2['distraction_type']} (conf={r2['confidence']})")
    
    # 场景3: 微睡眠(长时间闭眼)
    eye_microsleep = eye_closed.copy()
    eye_microsleep[:, 0] = 0.05  # 完全闭眼
    r3 = det.detect_cognitive_distraction(eye_microsleep)
    print(f"\n微睡眠: Level {r3['distraction_level']} - {r3['distraction_type']} (conf={r3['confidence']})")