import numpy as np

class EyeMovementFeatures:
    """
    L3被动疲劳眼动特征提取
    
    特征类别：
    1. 注视特征：时长/频率/分散度
    2. 眨眼特征：频率/时长/PERCLOS
    3. 扫视特征：幅度/速度/方向
    4. 眼动熵：注视点分布随机性
    """
    
    def extract_features(self, gaze_x, gaze_y, blink_events, fps=60):
        features = {}
        
        # 1. 注视特征
        fixation_durations = [b['duration'] for b in blink_events if b['type'] == 'fixation']
        features['fixation_duration_mean'] = np.mean(fixation_durations) if fixation_durations else 0
        features['fixation_count'] = len(fixation_durations)
        
        # 注视点分散度（越高越警觉）
        features['gaze_dispersion'] = np.std(gaze_x) + np.std(gaze_y)
        
        # 2. 眨眼特征
        blink_durations = [b['duration'] for b in blink_events if b['type'] == 'blink']
        features['blink_frequency'] = len(blink_durations) / (len(gaze_x) / fps)
        features['blink_duration_mean'] = np.mean(blink_durations) if blink_durations else 0
        features['perclos'] = np.sum(np.array(blink_durations) > 0.5) / (len(gaze_x) / fps)
        
        # 3. 扫视特征
        saccades = [b for b in blink_events if b['type'] == 'saccade']
        saccade_amplitudes = [b['amplitude'] for b in saccades]
        features['saccade_amplitude_mean'] = np.mean(saccade_amplitudes) if saccade_amplitudes else 0
        features['saccade_velocity_mean'] = np.mean([b['velocity'] for b in saccades]) if saccades else 0
        
        # 4. 眼动熵（gaze entropy）
        features['gaze_entropy'] = self._calc_gaze_entropy(gaze_x, gaze_y)
        
        return features
    
    def _calc_gaze_entropy(self, gx, gy, grid_size=10):
        """计算注视点分布熵"""
        # 网格化
        gx_bin = np.histogram(gx, bins=grid_size)[0]
        gy_bin = np.histogram(gy, bins=grid_size)[0]
        
        # 联合分布
        joint = np.outer(gx_bin, gy_bin).astype(float)
        joint /= joint.sum() + 1e-8
        
        # Shannon熵
        entropy = -np.sum(joint * np.log2(joint + 1e-8))
        return entropy

class ECGFeatures:
    """
    L3被动疲劳ECG特征提取
    
    特征类别：
    1. HRV时域：SDNN/RMSSD/pNN50
    2. HRV频域：LF/HF/LF/HF比值
    3. 心率趋势：均值/斜率/方差
    """
    
    def extract_features(self, r_peaks, fs=250):
        """
        Args:
            r_peaks: R波检测点索引
        Returns:
            features: dict
        """
        features = {}
        
        # 计算RR间期
        rr_intervals = np.diff(r_peaks) / fs  # 秒
        
        # 1. 时域HRV
        features['hr_mean'] = 60 / np.mean(rr_intervals) if len(rr_intervals) > 0 else 0
        features['sdnn'] = np.std(rr_intervals) * 1000  # ms
        features['rmssd'] = np.sqrt(np.mean(np.diff(rr_intervals)**2)) * 1000  # ms
        
        nn50 = np.sum(np.abs(np.diff(rr_intervals)) > 0.05)
        features['pnn50'] = nn50 / len(rr_intervals) * 100 if len(rr_intervals) > 0 else 0
        
        # 2. 频域HRV
        if len(rr_intervals) > 10:
            freqs, psd = self._calc_psd(rr_intervals, fs)
            features['lf_power'] = np.sum(psd[(freqs >= 0.04) & (freqs <= 0.15)])
            features['hf_power'] = np.sum(psd[(freqs >= 0.15) & (freqs <= 0.4)])
            features['lf_hf_ratio'] = features['lf_power'] / (features['hf_power'] + 1e-8)
        
        # 3. 心率趋势
        hr_series = 60 / rr_intervals
        features['hr_trend'] = np.polyfit(range(len(hr_series)), hr_series, 1)[0]
        features['hr_variability'] = np.std(hr_series)
        
        return features
    
    def _calc_psd(self, rr_intervals, fs):
        """Lomb-Scargle功率谱密度"""
        from numpy.fft import fft, fftfreq
        n = len(rr_intervals)
        fft_vals = np.abs(fft(rr_intervals - np.mean(rr_intervals)))**2
        freqs = fftfreq(n, d=np.mean(rr_intervals))
        return freqs[:n//2], fft_vals[:n//2]

class MultimodalFatigueFusion:
    """
    眼动+ECG多模态被动疲劳融合检测
    
    论文方法：特征级融合+分类器
    """
    
    def __init__(self):
        self.eye_features = EyeMovementFeatures()
        self.ecg_features = ECGFeatures()
    
    def detect_passive_fatigue(self, gaze_data, blink_events, ecg_data):
        """
        多模态被动疲劳检测
        
        返回：
            - fatigue_level: 0-1
            - modality_confidence: 各模态置信度
        """
        # 1. 提取眼动特征
        eye_feat = self.eye_features.extract_features(
            gaze_data['x'], gaze_data['y'], blink_events
        )
        
        # 2. 提取ECG特征
        ecg_feat = self.ecg_features.extract_features(ecg_data['r_peaks'])
        
        # 3. 被动疲劳指标
        # 眼动：熵降低+注视分散减少+PERCLOS增加
        eye_fatigue = self._eye_fatigue_score(eye_feat)
        
        # ECG：HRV变化趋势+心率降低
        ecg_fatigue = self._ecg_fatigue_score(ecg_feat)
        
        # 4. 融合决策
        # 被动疲劳时眼动先变化，ECG后变化
        if eye_fatigue > 0.5 and ecg_fatigue > 0.3:
            combined = 0.6 * eye_fatigue + 0.4 * ecg_fatigue
            confidence = 'high'
        elif eye_fatigue > 0.5:
            combined = eye_fatigue
            confidence = 'medium'  # 仅眼动变化，需持续观察
        elif ecg_fatigue > 0.5:
            combined = ecg_fatigue
            confidence = 'medium'  # 仅ECG变化，可能是其他原因
        else:
            combined = 0.3 * eye_fatigue + 0.3 * ecg_fatigue
            confidence = 'low'
        
        return {
            'fatigue_level': combined,
            'confidence': confidence,
            'eye_fatigue': eye_fatigue,
            'ecg_fatigue': ecg_fatigue
        }