import numpy as np
from typing import Tuple

class LayeredEthanolSensor:
    """
    分层乙醇气体传感器信号处理
    
    论文: Wang et al., 2025 (Sensors and Actuators B)
    核心: 多层传感器阵列区分驾驶员呼气与环境乙醇
    
    传感器层:
    - Layer 1 (近驾驶员): 高浓度区域
    - Layer 2 (中间区): 扩散过渡区
    - Layer 3 (远端): 环境背景
    """
    
    def __init__(
        self,
        num_layers: int = 3,
        sampling_rate: float = 1.0,
        env_threshold: float = 5.0  # ppm
    ):
        self.num_layers = num_layers
        self.sampling_rate = sampling_rate
        self.env_threshold = env_threshold
        
        # 每层传感器基线校准值
        self.baselines = np.zeros(num_layers)
        self.calibrated = False
    
    def calibrate(self, clean_air_readings: np.ndarray):
        """
        基线校准
        
        Args:
            clean_air_readings: 无酒精环境下的读数, shape=(num_layers,)
        """
        self.baselines = clean_air_readings
        self.calibrated = True
    
    def process(
        self, 
        readings: np.ndarray,
        timestamp: float
    ) -> dict:
        """
        处理传感器读数，判断酒精来源
        
        Args:
            readings: 各层传感器读数, shape=(num_layers,), 单位ppm
            timestamp: 时间戳
            
        Returns:
            result: 检测结果
        """
        if not self.calibrated:
            raise RuntimeError("传感器未校准")
        
        # 减去基线
        delta = readings - self.baselines  # (num_layers,)
        
        # 分层差异分析
        layer_diff_1_3 = delta[0] - delta[-1]  # 近-远差异
        concentration_gradient = np.diff(delta)  # 层间梯度
        
        # 判断酒精来源
        if delta[-1] > self.env_threshold:
            source = "environment"  # 环境乙醇（如消毒剂）
        elif layer_diff_1_3 > 10:
            source = "driver_breath"  # 驾驶员呼气
        else:
            source = "uncertain"
        
        # 估算BAC
        # 经验公式: 驾驶员区域乙醇浓度 → BAC
        driver_ppm = delta[0]
        estimated_bac = self._ppm_to_bac(driver_ppm)
        
        return {
            'source': source,
            'driver_ppm': driver_ppm,
            'env_ppm': delta[-1],
            'gradient': concentration_gradient.tolist(),
            'estimated_bac': estimated_bac,
            'impaired': estimated_bac >= 0.08,
            'timestamp': timestamp
        }
    
    def _ppm_to_bac(self, ppm: float) -> float:
        """
        呼气乙醇浓度(ppm) → 血液酒精浓度(BAC)
        
        转换关系:
        1 ppm ≈ 0.0021% BAC (Henry's Law)
        """
        return max(0.0, ppm * 0.0021)


# 实际测试
if __name__ == "__main__":
    sensor = LayeredEthanolSensor(num_layers=3)
    
    # 校准
    sensor.calibrate(np.array([1.0, 0.8, 0.5]))
    
    # 模拟驾驶员饮酒后的读数
    readings = np.array([35.0, 15.0, 3.0])  # 近→远
    result = sensor.process(readings, timestamp=0)
    
    print(f"来源: {result['source']}")
    print(f"驾驶员区域乙醇: {result['driver_ppm']:.1f} ppm")
    print(f"估算BAC: {result['estimated_bac']:.4f}")
    print(f"损伤判定: {'是' if result['impaired'] else '否'}")

class YSZElectrochemicalSensor:
    """
    YSZ基电化学乙醇传感器模型
    
    特点:
    - SnO2/Co3O4复合感应层
    - 工作温度300-400°C
    - 检出限: 1-500 ppm
    - 响应时间: <5s
    """
    
    def __init__(
        self,
        operating_temp: float = 350.0,  # °C
        sensitivity: float = 0.85,       # mV/ppm
        response_time: float = 3.5       # s
    ):
        self.operating_temp = operating_temp
        self.sensitivity = sensitivity
        self.response_time = response_time
        self.baseline = 0.0
    
    def read_voltage(self, ethanol_ppm: float) -> float:
        """
        乙醇浓度 → 传感器输出电压
        
        Args:
            ethanol_ppm: 乙醇浓度 (ppm)
        Returns:
            voltage: 输出电压 (mV)
        """
        # 线性响应区 (1-200 ppm)
        if ethanol_ppm < 200:
            return self.sensitivity * ethanol_ppm + self.baseline
        # 饱和区 (200-500 ppm)
        else:
            return self.sensitivity * 200 + \
                   self.sensitivity * 0.3 * (ethanol_ppm - 200) + \
                   self.baseline

import numpy as np

class AlcoholImpairmentVisualDetector:
    """
    基于DMS视觉信号的酒精损伤检测
    
    特征维度:
    1. 眨眼频率 (酒精导致眨眼不规律)
    2. 头部摇摆幅度 (运动控制下降)
    3. 凝视稳定性 (注视点抖动增大)
    4. 面部对称性 (面部肌肉控制下降)
    5. 反应时延 (对刺激的响应变慢)
    """
    
    def __init__(self):
        self.baseline_blink_rate = 15.0  # 次/分钟 正常
        self.baseline_sway = 2.0          # 度 正常头部摇摆
        self.baseline_gaze_stability = 0.95  # 归一化
        
    def extract_features(
        self,
        blink_timestamps: list,
        head_pose_sequence: np.ndarray,
        gaze_sequence: np.ndarray,
        duration_sec: float = 60.0
    ) -> dict:
        """
        提取酒精损伤视觉特征
        
        Args:
            blink_timestamps: 眨眼时间戳列表
            head_pose_sequence: 头部姿态序列, shape=(T, 3) [pitch, yaw, roll]
            gaze_sequence: 视线序列, shape=(T, 2) [theta, phi]
            duration_sec: 观测时长 (秒)
        
        Returns:
            features: 特征字典
        """
        # 1. 眨眼频率
        blink_rate = len(blink_timestamps) / (duration_sec / 60)
        # 酒精影响: 眨眼频率异常波动
        
        # 2. 眨眼间隔标准差 (酒精导致不规律)
        if len(blink_timestamps) > 2:
            intervals = np.diff(blink_timestamps)
            blink_irregularity = np.std(intervals) / np.mean(intervals)
        else:
            blink_irregularity = 0
        
        # 3. 头部摇摆幅度
        sway_pitch = np.std(head_pose_sequence[:, 0])
        sway_yaw = np.std(head_pose_sequence[:, 1])
        sway_roll = np.std(head_pose_sequence[:, 2])
        total_sway = np.sqrt(sway_pitch**2 + sway_yaw**2 + sway_roll**2)
        
        # 4. 凝视稳定性 (注视点离散度)
        gaze_dispersion = np.mean(np.std(gaze_sequence, axis=0))
        gaze_stability = 1.0 / (1.0 + gaze_dispersion)
        
        # 5. 微睡眠事件 (闭眼>1.5s)
        microsleep_count = self._count_microsleeps(blink_timestamps)
        
        return {
            'blink_rate': blink_rate,
            'blink_irregularity': blink_irregularity,
            'head_sway': total_sway,
            'gaze_stability': gaze_stability,
            'microsleep_count': microsleep_count,
            # 归一化损伤评分
            'impairment_score': self._compute_impairment_score(
                blink_rate, blink_irregularity, total_sway,
                gaze_stability, microsleep_count
            )
        }
    
    def _count_microsleeps(self, timestamps: list) -> int:
        """统计微睡眠事件（间隔>1.5s的闭眼）"""
        if len(timestamps) < 2:
            return 0
        intervals = np.diff(timestamps)
        return np.sum(intervals > 1.5)
    
    def _compute_impairment_score(
        self, blink_rate, irregularity, sway,
        stability, microsleeps
    ) -> float:
        """综合损伤评分 (0-1)"""
        score = 0.0
        # 眨眼频率偏离
        score += 0.2 * min(1.0, abs(blink_rate - 15) / 15)
        # 不规律性
        score += 0.2 * min(1.0, irregularity / 0.5)
        # 头部摇摆
        score += 0.25 * min(1.0, sway / 5.0)
        # 凝视不稳定
        score += 0.25 * (1.0 - stability)
        # 微睡眠
        score += 0.1 * min(1.0, microsleeps / 3.0)
        return score


# 测试
if __name__ == "__main__":
    detector = AlcoholImpairmentVisualDetector()
    
    # 模拟60秒数据
    np.random.seed(42)
    n_frames = 60 * 30  # 30fps
    
    # 正常驾驶
    head_normal = np.random.randn(n_frames, 3) * 2
    gaze_normal = np.random.randn(n_frames, 2) * 0.05
    blinks_normal = list(np.sort(np.random.uniform(0, 60, 15)))  # 15次/分钟
    
    normal_features = detector.extract_features(
        blinks_normal, head_normal, gaze_normal, 60
    )
    print("=== 正常驾驶 ===")
    for k, v in normal_features.items():
        print(f"  {k}: {v:.3f}")
    
    # 模拟酒精损伤
    head_impaired = np.random.randn(n_frames, 3) * 5  # 摇摆增大
    gaze_impaired = np.random.randn(n_frames, 2) * 0.15  # 凝视不稳定
    blinks_impaired = list(np.sort(np.random.uniform(0, 60, 8)))  # 频率降低
    
    impaired_features = detector.extract_features(
        blinks_impaired, head_impaired, gaze_impaired, 60
    )
    print("\n=== 酒精损伤 ===")
    for k, v in impaired_features.items():
        print(f"  {k}: {v:.3f}")