class EmotionAwareCockpit:
    """
    CHI 2025 情感感知座舱框架
    
    四层架构：
    1. Sense: 多模态情绪感知
    2. Interpret: AI 情绪状态推断
    3. Adapt: 自适应座舱响应
    4. Respond: 情感化交互反馈
    
    传感器融合：
    - 视觉：面部表情 + 眼动 + 姿态
    - 听觉：语音情感 + 语义分析
    - 生理：HRV + EDA + 皮肤温度
    - 行为：驾驶模式 + 交互频率
    """
    
    FRAMEWORK = {
        "sense": {
            "visual": ["facial_expression", "eye_gaze", "body_posture"],
            "acoustic": ["speech_emotion", "voice_stress", "linguistic"],
            "physiological": ["HRV", "EDA", "skin_temp"],
            "behavioral": ["steering_pattern", "braking_freq", "interaction_rate"],
        },
        "interpret": {
            "emotion_model": "PAD (Pleasure-Arousal-Dominance)",
            "fusion": "late_fusion (modality-specific models → weighted ensemble)",
            "output": "emotion_state + confidence",
        },
        "adapt": {
            "ambient_lighting": "调整色温和亮度",
            "audio": "选择音乐类型和音量",
            "climate": "调整温度和风量",
            "hud": "调整信息密度和呈现方式",
            "driving_mode": "调整ADAS介入阈值",
        },
        "respond": {
            "voice": "情感化语音回复",
            "haptic": "座椅/方向盘震动模式",
            "visual": "HUD和仪表盘视觉反馈",
        },
    }

import numpy as np
import torch
import torch.nn as nn
from typing import Tuple

class InCabinSER(nn.Module):
    """
    车载语音情感识别 (SER) 系统
    
    架构：CNN + LSTM 双流
    - CNN：提取频谱空间特征（MFCC/Mel图谱）
    - LSTM：捕获时序韵律变化
    - 融合：双流特征拼接后分类
    
    硬件配置：
    | 组件 | 型号 | 参数 | 安装位置 |
    |------|------|------|----------|
    | 麦克风阵列 | 4麦环形阵列 | 16kHz, 16bit | 车顶控制台 |
    | DSP | 专用音频DSP | 降噪+回声消除 | 中控 |
    | 处理器 | QCS8255 | NPU推理 | 中控 |
    
    降噪管道：
    1. 回声消除 (AEC)
    2. 波束成形 (Beamforming)
    3. 非平稳噪声抑制
    4. 残差噪声消除
    """
    
    EMOTIONS = {
        0: "neutral",      # 中性
        1: "calm",         # 平静
        2: "happy",        # 快乐
        3: "sad",          # 悲伤
        4: "angry",        # 愤怒
        5: "fearful",      # 恐惧
        6: "stress",       # 压力
        7: "fatigued",     # 疲劳
    }
    
    def __init__(self, num_classes: int = 8, sample_rate: int = 16000):
        super().__init__()
        self.sample_rate = sample_rate
        
        # 频谱分支：CNN 处理 Mel 频谱图
        self.spectral_branch = nn.Sequential(
            # 输入: (B, 1, 128, T)  Mel 频谱图
            nn.Conv2d(1, 32, kernel_size=(3, 3), padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d((2, 2)),
            
            nn.Conv2d(32, 64, kernel_size=(3, 3), padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d((2, 2)),
            
            nn.Conv2d(64, 128, kernel_size=(3, 3), padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((1, 1)),
        )
        spectral_dim = 128
        
        # 韵律分支：LSTM 处理时序特征
        # 输入: [pitch, energy, speaking_rate, pause_duration, jitter, shimmer]
        self.prosody_branch = nn.LSTM(
            input_size=6,
            hidden_size=64,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
        )
        prosody_dim = 128  # 64 * 2 (双向)
        
        # 融合分类头
        self.classifier = nn.Sequential(
            nn.Linear(spectral_dim + prosody_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.4),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes)
        )
    
    def forward(self, mel_spectrogram, prosody_features):
        """
        Args:
            mel_spectrogram: (B, 1, 128, T) Mel 频谱图
            prosody_features: (B, T_p, 6) 韵律特征序列
        
        Returns:
            logits: (B, 8) 情绪分类
        """
        # 频谱分支
        spec_feat = self.spectral_branch(mel_spectrogram)
        spec_feat = spec_feat.flatten(1)
        
        # 韵律分支
        _, (hn, _) = self.prosody_branch(prosody_features)
        # 拼接双向 LSTM 最后层
        prosody_feat = torch.cat([hn[-2], hn[-1]], dim=-1)
        
        # 融合
        fused = torch.cat([spec_feat, prosody_feat], dim=-1)
        return self.classifier(fused)


class CabinNoiseFilter:
    """
    车载降噪管道
    
    基于 CAVEMOVE 数据库的车载噪声特征：
    - 引擎噪声: 50-200Hz 低频
    - 风噪: 500-2000Hz 宽带
    - 路面噪声: 100-500Hz
    - 轮胎噪声: 800-1500Hz
    - HVAC: 宽带低频
    """
    
    def __init__(self, sample_rate: int = 16000):
        self.fs = sample_rate
        self.noise_profile = None
    
    def extract_mel(self, audio: np.ndarray, n_mels: int = 128) -> np.ndarray:
        """提取 Mel 频谱图"""
        # 简化版 Mel 提取
        from scipy.signal import stft
        f, t, Zxx = stft(audio, fs=self.fs, nperseg=512)
        # Mel 滤波器组
        mel_filter = self._mel_filterbank(n_mels, len(f), self.fs)
        mel_spec = np.dot(mel_filter, np.abs(Zxx))
        # 对数压缩
        mel_spec = 10 * np.log10(mel_spec + 1e-10)
        return mel_spec
    
    def extract_prosody(self, audio: np.ndarray) -> np.ndarray:
        """提取韵律特征"""
        # 基频提取（简化版自相关）
        frame_size = int(0.03 * self.fs)  # 30ms
        hop = int(0.01 * self.fs)  # 10ms
        
        features = []
        for i in range(0, len(audio) - frame_size, hop):
            frame = audio[i:i+frame_size]
            # 基频（pitch）
            pitch = self._estimate_pitch(frame)
            # 能量
            energy = np.sum(frame ** 2) / frame_size
            # 过零率
            zcr = np.sum(np.diff(np.sign(frame)) != 0) / frame_size
            # 抖动（jitter）和闪烁（shimmer）简化
            features.append([pitch, energy, zcr, 0, 0, 0])
        
        return np.array(features)
    
    def _estimate_pitch(self, frame):
        """简化版基频估计"""
        autocorr = np.correlate(frame, frame, mode='full')
        autocorr = autocorr[len(autocorr)//2:]
        # 找第一个峰
        for i in range(int(self.fs/400), int(self.fs/80)):
            if autocorr[i] > 0.3 * autocorr[0]:
                return self.fs / i
        return 0
    
    def _mel_filterbank(self, n_mels, n_fft, fs):
        """简化 Mel 滤波器组"""
        mel_filter = np.random.rand(n_mels, n_fft) * 0.1 + 0.1
        return mel_filter


# 测试
if __name__ == "__main__":
    ser = InCabinSER(num_classes=8)
    
    # 模拟输入
    mel = torch.randn(2, 1, 128, 100)  # 2个样本, Mel频谱
    prosody = torch.randn(2, 30, 6)    # 韵律特征
    
    with torch.no_grad():
        out = ser(mel, prosody)
    
    print("=== 车载 SER 测试 ===")
    print(f"输出: {out.shape}")
    emotions = InCabinSER.EMOTIONS
    for i, emo in emotions.items():
        prob = torch.softmax(out, dim=-1)[0, i]
        print(f"  {emo}: {prob:.4f}")
    
    print(f"\n参数量: {sum(p.numel() for p in ser.parameters()):,}")
    print(f"模型大小: {sum(p.numel() for p in ser.parameters()) * 4 / 1024 / 1024:.1f} MB")

class MultiModalEmotionFusion(nn.Module):
    """
    多模态情绪融合：视觉 DMS + 语音 SER + 生理
    
    融合策略：late fusion with learnable weights
    
    优势：
    - 视觉受限时（口罩/墨镜/夜间）语音接管
    - 语音受限时（嘈杂/无语音）视觉接管
    - 两者互补时精度最高
    """
    
    def __init__(self):
        super().__init__()
        self.ser = InCabinSER(num_classes=8)
        self.dms_feat = nn.Linear(10, 64)  # 视觉特征
        self.hrv_feat = nn.Linear(5, 32)   # HRV特征
        
        # 可学习融合权重
        self.weights = nn.Parameter(torch.tensor([0.4, 0.4, 0.2]))
        
        self.classifier = nn.Sequential(
            nn.Linear(8 + 64 + 32, 128),
            nn.ReLU(),
            nn.Linear(128, 8)
        )
    
    def forward(self, mel, prosody, dms, hrv):
        ser_logits = self.ser(mel, prosody)
        dms_feat = self.dms_feat(dms)
        hrv_feat = self.hrv_feat(hrv)
        
        w = torch.softmax(self.weights, dim=0)
        ser_weighted = w[0] * ser_logits
        dms_weighted = w[1] * self.classifier(
            torch.cat([ser_logits, dms_feat, hrv_feat], dim=-1)
        ) * 0 + dms_feat  # 简化
        hrv_weighted = w[2] * hrv_feat
        
        fused = torch.cat([ser_weighted, dms_weighted, hrv_weighted], dim=-1)
        return self.classifier(torch.cat([ser_logits, dms_feat, hrv_feat], dim=-1))