import numpy as np
import pandas as pd
from scipy.signal import coherence, hilbert
from typing import Dict, Tuple, List

class NetworkPhysiologyAnalyzer:
    """
    网络生理学耦合分析器
    
    论文: Frontiers in Network Physiology, 2026
    核心思想: 生理系统间的耦合模式是健康状态的关键指标
    
    航天→车载迁移价值:
    - 航天: 多系统失调通过耦合网络传播
    - 车载: 疲劳→认知→情绪→行为的级联退化
    """
    
    def __init__(self, fs=250):
        self.fs = fs  # 采样率
        
    def compute_phase_locking_value(
        self, signal1: np.ndarray, signal2: np.ndarray
    ) -> float:
        """
        计算两个生理信号之间的相位锁定值（PLV）
        
        PLV反映两个系统之间的相位同步程度
        高PLV → 强耦合 → 协同调节
        低PLV → 解耦合 → 系统失调
        
        Args:
            signal1: 生理信号1 (如HRV)
            signal2: 生理信号2 (如EEG theta)
            
        Returns:
            plv: 相位锁定值 (0-1)
        """
        # Hilbert变换提取瞬时相位
        analytic1 = hilbert(signal1)
        analytic2 = hilbert(signal2)
        
        phase1 = np.unwrap(np.angle(analytic1))
        phase2 = np.unwrap(np.angle(analytic2))
        
        # 相位差
        phase_diff = phase1 - phase2
        plv = np.abs(np.mean(np.exp(1j * phase_diff)))
        
        return plv
    
    def compute_cross_coherence(
        self, signal1: np.ndarray, signal2: np.ndarray,
        nperseg: int = 256
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        计算交叉相干性（频域耦合）
        
        Args:
            signal1: 生理信号1
            signal2: 生理信号2
            
        Returns:
            freqs: 频率轴
            coh: 相干性值 (0-1)
        """
        freqs, coh = coherence(signal1, signal2, fs=self.fs, nperseg=nperseg)
        return freqs, coh
    
    def build_coupling_matrix(
        self, signals: Dict[str, np.ndarray]
    ) -> pd.DataFrame:
        """
        构建多系统耦合矩阵
        
        论文核心: 系统间耦合模式是健康状态指标
        
        Args:
            signals: {
                'hrv': HRV信号,
                'eeg_theta': EEG theta,
                'eeg_alpha': EEG alpha,
                'breathing': 呼吸信号,
                'eda': 皮电信号,
                'eye_blink': 眨眼频率
            }
            
        Returns:
            coupling_df: 耦合矩阵 (n×n)
        """
        names = list(signals.keys())
        n = len(names)
        matrix = np.zeros((n, n))
        
        for i in range(n):
            for j in range(i, n):
                if i == j:
                    matrix[i, j] = 1.0
                else:
                    s1 = signals[names[i]]
                    s2 = signals[names[j]]
                    # 确保长度一致
                    min_len = min(len(s1), len(s2))
                    plv = self.compute_phase_locking_value(
                        s1[:min_len], s2[:min_len]
                    )
                    matrix[i, j] = plv
                    matrix[j, i] = plv
        
        return pd.DataFrame(matrix, index=names, columns=names)
    
    def detect_decoupling(
        self, baseline_matrix: pd.DataFrame,
        current_matrix: pd.DataFrame,
        threshold: float = 0.3
    ) -> List[dict]:
        """
        检测系统解耦合（功能障碍的早期标志）
        
        论文发现: 系统失调首先表现为耦合模式变化
        如: 压力-睡眠解耦合 → 睡眠-认知解耦合 → 级联失效
        
        Args:
            baseline_matrix: 基线耦合矩阵（健康状态）
            current_matrix: 当前耦合矩阵
            threshold: 解耦合阈值
            
        Returns:
            alerts: 解耦合警报列表
        """
        alerts = []
        
        for col in baseline_matrix.columns:
            for idx in baseline_matrix.index:
                if idx == col:
                    continue
                baseline_val = baseline_matrix.loc[idx, col]
                current_val = current_matrix.loc[idx, col]
                change = baseline_val - current_val
                
                if change > threshold:
                    alerts.append({
                        'system_pair': f"{idx} ↔ {col}",
                        'baseline_coupling': baseline_val,
                        'current_coupling': current_val,
                        'decoupling': change,
                        'severity': 'high' if change > 0.5 else 'moderate'
                    })
        
        return sorted(alerts, key=lambda x: x['decoupling'], reverse=True)


# 实际分析代码
if __name__ == "__main__":
    np.random.seed(42)
    analyzer = NetworkPhysiologyAnalyzer(fs=250)
    
    # 模拟基线（健康）和疲劳状态生理信号
    duration_s = 60
    t = np.arange(duration_s * 250) / 250
    
    # 基线信号（强耦合：HRV↔呼吸↔EEG theta）
    breathing_baseline = np.sin(2 * np.pi * 0.25 * t) + np.random.normal(0, 0.1, len(t))
    hrv_baseline = 0.7 * np.sin(2 * np.pi * 0.25 * t + 0.3) + np.random.normal(0, 0.15, len(t))
    eeg_theta_baseline = 0.5 * np.sin(2 * np.pi * 0.25 * t + 0.5) + np.random.normal(0, 0.2, len(t))
    eda_baseline = 0.3 * np.sin(2 * np.pi * 0.1 * t) + np.random.normal(0, 0.1, len(t))
    
    # 疲劳状态（解耦合：各系统独立波动）
    hrv_fatigue = np.sin(2 * np.pi * 0.15 * t) + np.random.normal(0, 0.3, len(t))  # 频率变化
    eeg_theta_fatigue = np.sin(2 * np.pi * 0.4 * t) + np.random.normal(0, 0.3, len(t))  # 失同步
    eda_fatigue = np.random.normal(0.5, 0.2, len(t))  # 近似随机
    
    baseline_signals = {
        'hrv': hrv_baseline,
        'breathing': breathing_baseline,
        'eeg_theta': eeg_theta_baseline,
        'eda': eda_baseline
    }
    
    fatigue_signals = {
        'hrv': hrv_fatigue,
        'breathing': breathing_baseline,  # 呼吸不变
        'eeg_theta': eeg_theta_fatigue,
        'eda': eda_fatigue
    }
    
    baseline_matrix = analyzer.build_coupling_matrix(baseline_signals)
    fatigue_matrix = analyzer.build_coupling_matrix(fatigue_signals)
    
    print("=== 基线耦合矩阵（健康）===")
    print(baseline_matrix.round(3))
    print("\n=== 疲劳耦合矩阵 ===")
    print(fatigue_matrix.round(3))
    
    alerts = analyzer.detect_decoupling(baseline_matrix, fatigue_matrix, threshold=0.2)
    
    print("\n=== 解耦合警报 ===")
    for alert in alerts:
        print(f"  {alert['system_pair']}: "
              f"基线{alert['baseline_coupling']:.3f} → "
              f"当前{alert['current_coupling']:.3f} "
              f"(↓{alert['decoupling']:.3f}, {alert['severity']})")

# IMS疲劳检测的阶段模型
FATIGUE_STAGES = {
    'stage_0_normal': {
        'description': '各系统强耦合，协同调节',
        'hrv_breathing_plv': '>0.7',
        'perclos_blink_plv': '>0.6',
        'action': 'continue_monitoring'
    },
    'stage_1_decoupling': {
        'description': 'HRV↔呼吸开始解耦合',
        'hrv_breathing_plv': '0.4-0.7',
        'perclos_blink_plv': '>0.5',
        'action': 'early_warning'
    },
    'stage_2_single_abnormal': {
        'description': '单指标超阈值',
        'hrv_breathing_plv': '<0.4',
        'perclos_blink_plv': '0.3-0.5',
        'action': 'active_warning'
    },
    'stage_3_multi_abnormal': {
        'description': '多系统失调',
        'hrv_breathing_plv': '<0.3',
        'perclos_blink_plv': '<0.3',
        'action': 'critical_alert'
    }
}