import numpy as np
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class HapticSensation:
    """触觉刺激参数定义"""
    name: str
    frequency_hz: float       # 调制频率
    duration_ms: int           # 持续时间
    intensity: float          # 0-1
    pattern: str              # 'continuous', 'pulsed', 'ramp_up', 'rapid'
    
class KnucklesNotificationSystem:
    """
    方向盘背手超声波触觉通知系统
    
    论文: Frontiers in Computer Science, 2024
    核心: 超声波相控阵 → 手背指关节 → 4种通知编码
    评估: 20名驾驶员，94%识别率
    
    关键发现:
    1. 握方向盘时手背感知增强（声波反射）
    2. 不受车辆振动遮蔽
    3. 4种通知94%正确识别
    4. 不影响驾驶任务（路径偏差无显著差异）
    """
    
    # 4种车载通知的触觉编码（论文定义）
    NOTIFICATIONS = {
        'incoming_call': HapticSensation(
            name='来电',
            frequency_hz=100,     # 100Hz调制
            duration_ms=2000,      # 2秒
            intensity=0.7,
            pattern='continuous'   # 连续脉冲
        ),
        'text_message': HapticSensation(
            name='短信',
            frequency_hz=150,
            duration_ms=800,       # 0.8秒
            intensity=0.5,
            pattern='pulsed'       # 双脉冲
        ),
        'navigation_alert': HapticSensation(
            name='导航',
            frequency_hz=80,
            duration_ms=1200,
            intensity=0.6,
            pattern='ramp_up'      # 渐强
        ),
        'driver_warning': HapticSensation(
            name='驾驶警告',
            frequency_hz=200,
            duration_ms=500,
            intensity=0.9,
            pattern='rapid'         # 急促
        )
    }
    
    def __init__(self, transducer_count=256):
        """
        Args:
            transducer_count: 超声换能器数量（典型256个）
        """
        self.num_transducers = transducer_count
        # 相控阵参数
        self.array_frequency = 40000  # 40kHz 载波
        self.focus_distance = 0.15    # 15cm 聚焦距离
        self.element_spacing = 0.005  # 5mm 阵元间距
        
    def compute_phase_delays(self, target_point: Tuple[float, float, float]) -> np.ndarray:
        """
        计算相控阵延迟以聚焦到目标点
        
        Args:
            target_point: (x, y, z) 目标坐标（米）
            
        Returns:
            phases: 每个阵元的相位延迟（弧度）
        """
        # 声速
        c = 343.0  # m/s
        
        # 阵元位置（方形排列）
        grid_size = int(np.sqrt(self.num_transducers))
        x = np.linspace(-grid_size/2 * self.element_spacing,
                       grid_size/2 * self.element_spacing, grid_size)
        y = np.linspace(-grid_size/2 * self.element_spacing,
                       grid_size/2 * self.element_spacing, grid_size)
        xx, yy = np.meshgrid(x, y)
        
        # 每个阵元到目标点的距离
        distances = np.sqrt(
            (xx - target_point[0])**2 +
            (yy - target_point[1])**2 +
            target_point[2]**2
        )
        
        # 相位延迟
        phases = 2 * np.pi * self.array_frequency * distances / c
        phases = phases % (2 * np.pi)
        
        return phases.flatten()
    
    def generate_amplitude_modulation(self, sensation: HapticSensation, 
                                       duration_s: float = None) -> np.ndarray:
        """
        生成幅度调制信号
        
        Args:
            sensation: 触觉参数
            duration_s: 信号持续时间（秒）
            
        Returns:
            am_signal: 幅度调制后的信号
        """
        if duration_s is None:
            duration_s = sensation.duration_ms / 1000
        
        fs = 44100  # 采样率
        t = np.arange(int(fs * duration_s)) / fs
        
        # 载波
        carrier = np.sin(2 * np.pi * self.array_frequency * t)
        
        # 调制信号
        if sensation.pattern == 'continuous':
            modulation = sensation.intensity * np.ones_like(t)
        elif sensation.pattern == 'pulsed':
            # 双脉冲：0.2s on, 0.1s off, 0.2s on
            modulation = np.zeros_like(t)
            pulse1_end = int(0.2 * fs)
            pulse2_start = int(0.3 * fs)
            pulse2_end = int(0.5 * fs)
            modulation[:pulse1_end] = sensation.intensity
            modulation[pulse2_start:pulse2_end] = sensation.intensity
        elif sensation.pattern == 'ramp_up':
            # 渐强
            ramp = np.linspace(0, sensation.intensity, len(t))
            modulation = ramp
        elif sensation.pattern == 'rapid':
            # 急促脉冲：5次50ms脉冲
            modulation = np.zeros_like(t)
            pulse_duration = int(0.05 * fs)
            gap = int(0.03 * fs)
            for i in range(5):
                start = i * (pulse_duration + gap)
                end = start + pulse_duration
                if end < len(modulation):
                    modulation[start:end] = sensation.intensity
        else:
            modulation = sensation.intensity * np.ones_like(t)
        
        # AM调制
        am_signal = carrier * modulation
        return am_signal
    
    def trigger_notification(self, notification_type: str) -> dict:
        """
        触发通知
        
        Args:
            notification_type: 'incoming_call', 'text_message', 
                              'navigation_alert', 'driver_warning'
        """
        sensation = self.NOTIFICATIONS.get(notification_type)
        if not sensation:
            return {'error': f'unknown notification: {notification_type}'}
        
        # 目标点：驾驶员右手指关节区域
        # 假设方向盘在(z=0.1)，手背在(z=0.15)
        target = (0.0, 0.05, 0.15)  # 右手位置
        
        # 计算相位
        phases = self.compute_phase_delays(target)
        
        # 生成调制信号
        signal = self.generate_amplitude_modulation(sensation)
        
        return {
            'notification': sensation.name,
            'target': target,
            'frequency_hz': sensation.frequency_hz,
            'duration_ms': sensation.duration_ms,
            'pattern': sensation.pattern,
            'intensity': sensation.intensity,
            'phases_count': len(phases),
            'signal_samples': len(signal)
        }


# 实际测试
if __name__ == "__main__":
    system = KnucklesNotificationSystem(transducer_count=256)
    
    print("=== Knuckles通知系统测试 ===\n")
    
    # 触发所有通知类型
    for ntype in ['incoming_call', 'text_message', 'navigation_alert', 'driver_warning']:
        result = system.trigger_notification(ntype)
        print(f"通知: {result['notification']}")
        print(f"  频率: {result['frequency_hz']}Hz")
        print(f"  时长: {result['duration_ms']}ms")
        print(f"  模式: {result['pattern']}")
        print(f"  强度: {result['intensity']}")
        print(f"  阵元数: {result['phases_count']}")
        print(f"  信号采样数: {result['signal_samples']}")
        print()
    
    # 论文测试结果
    print("=== 论文测试结果 ===")
    print(f"参与者: 20名驾驶员")
    print(f"通知识别率: 94%")
    print(f"路径偏差: 无显著影响（p>0.05）")
    print(f"振动遮蔽: 无影响（成功率不降）")
    print()
    print("关键发现:")
    print("1. 握方向盘时手背感知增强（声波反射聚焦）")
    print("2. 不受车辆振动遮蔽（vs 方向盘内嵌振动电机）")
    print("3. 4种通知可区分（94%准确率）")
    print("4. 支持hands-on-the-wheel范式（不松手）")

class DMSHapticIntegration:
    """
    DMS + Knuckles触觉反馈集成方案
    
    当DMS检测到疲劳/分心时，通过knuckles触觉通知驾驶员
    无需松手，无需视觉确认，响应快
    """
    
    def __init__(self):
        self.haptic = KnucklesNotificationSystem()
        self.fatigue_level = 0  # 0清醒, 1轻度, 2中度, 3重度
        self.distraction_level = 0
        
    def on_fatigue_detected(self, level: int, perclos: float):
        """DMS检测到疲劳时触发触觉反馈"""
        self.fatigue_level = level
        
        if level == 1:
            # 轻度：导航通知模式（渐强）
            self.haptic.trigger_notification('navigation_alert')
        elif level == 2:
            # 中度：短信通知模式（双脉冲）+ HUD
            self.haptic.trigger_notification('text_message')
            self._activate_hud("请休息")
        elif level == 3:
            # 重度：驾驶警告模式（急促）+ HUD + 声音
            self.haptic.trigger_notification('driver_warning')
            self._activate_hud("疲劳驾驶！")
            self._activate_audio_alarm()
    
    def on_distraction_detected(self, duration_s: float, gaze_target: str):
        """DMS检测到分心时触发触觉反馈"""
        if duration_s > 3.0:  # >3秒分心
            self.haptic.trigger_notification('incoming_call')  # 来电模式
            self._activate_hud(f"注意前方道路")
    
    def _activate_hud(self, message: str):
        """激活HUD显示"""
        print(f"[HUD] {message}")
    
    def _activate_audio_alarm(self):
        """激活声音警报"""
        print("[AUDIO] ⚠️ 疲劳驾驶警告 ⚠️")