import numpy as np
from dataclasses import dataclass
from typing import Optional

"""
非侵入式 BAC 检测系统模拟
参考 Aumovio + trinamiX 红外光谱组织液检测方案

模拟红外光谱采集 -> 酒精浓度提取 -> BAC 换算 -> 阈值判断
"""

@dataclass
class BACResult:
    """BAC 检测结果"""
    bac_value: float          # 血液酒精浓度 (g/dL)
    confidence: float        # 检测置信度 (0-1)
    is_impaired: bool       # 是否损伤
    warning_level: str      # 警告等级
    response_time_ms: float # 检测耗时(ms)


class InfraredBACSensors:
    """
    红外光谱 BAC 传感器模拟器
    
    模拟 Aumovio/trinamiX 方案：
    - 多波长红外光源照射手指
    - 检测组织液酒精浓度
    - 换算为血液酒精浓度
    """
    
    # 红外波长定义 (nm)
    WAVELENGTHS = np.array([
        1000, 1200, 1450, 1700, 1900, 2100, 2300, 2500
    ])
    
    # 酒精分子特征吸收峰 (nm)
    ALCOHOL_PEAKS = np.array([1450, 1700, 2100, 2300])
    
    # 组织液-血液酒精浓度转换系数
    ISF_TO_BLOOD_RATIO = 1.1  # 组织液浓度略高于血液
    
    # BAC 阈值 (g/dL)
    LEGAL_LIMIT = 0.08       # 美国法定上限
    WARNING_LIMIT = 0.04     # 警告阈值
    IMPAIRMENT_LIMIT = 0.02  # 损伤开始
    
    def __init__(self, sensor_temp: float = 25.0, 
                 calibration_offset: float = 0.0):
        """
        Args:
            sensor_temp: 传感器温度(°C)
            calibration_offset: 校准偏移量
        """
        self.sensor_temp = sensor_temp
        self.calibration_offset = calibration_offset
        self.is_calibrated = False
        
    def _generate_spectrum(self, isf_alcohol: float, 
                           skin_temp: float = 33.0,
                           skin_tone: int = 3) -> np.ndarray:
        """
        生成模拟红外光谱
        
        Args:
            isf_alcohol: 组织液酒精浓度 (g/dL)
            skin_temp: 皮肤温度 (°C)
            skin_tone: 肤肤色调 (1-6, Fitzpatrick scale)
        
        Returns:
            spectrum: 各波长吸光度, shape=(8,)
        """
        # 基线吸光度（无酒精）
        baseline = np.array([0.12, 0.08, 0.15, 0.10, 0.09, 0.11, 0.07, 0.06])
        
        # 酒精吸收峰强度
        alcohol_signal = np.zeros_like(baseline)
        for i, wl in enumerate(self.WAVELENGTHS):
            for peak in self.ALCOHOL_PEAKS:
                if abs(wl - peak) < 100:
                    # 高斯峰
                    alcohol_signal[i] += isf_alcohol * 0.5 * np.exp(
                        -((wl - peak) ** 2) / (2 * 30 ** 2)
                    )
        
        # 温度影响（温度越高吸收略强）
        temp_factor = 1.0 + (skin_temp - 33.0) * 0.003
        
        # 皮肤色调影响（深色皮肤吸收更强）
        tone_factor = 1.0 + (skin_tone - 3) * 0.05
        
        # 水分吸收干扰
        water_interference = np.array([0.02, 0.01, 0.05, 0.03, 0.02, 0.02, 0.01, 0.01])
        
        # 噪声
        noise = np.random.normal(0, 0.003, len(baseline))
        
        spectrum = (baseline + alcohol_signal) * temp_factor * tone_factor
        spectrum += water_interference + noise
        
        return spectrum
    
    def _extract_alcohol(self, spectrum: np.ndarray) -> float:
        """
        从光谱中提取酒精浓度
        
        使用多波长最小二乘法拟合
        """
        # 构建参考光谱矩阵
        ref_matrix = np.zeros((len(self.WAVELENGTHS), 3))
        
        # 参考1：纯酒精吸收
        ref_alcohol = np.zeros(len(self.WAVELENGTHS))
        for i, wl in enumerate(self.WAVELENGTHS):
            for peak in self.ALCOHOL_PEAKS:
                if abs(wl - peak) < 100:
                    ref_alcohol[i] += 0.5 * np.exp(
                        -((wl - peak) ** 2) / (2 * 30 ** 2)
                    )
        ref_matrix[:, 0] = ref_alcohol
        
        # 参考2：水分吸收
        ref_matrix[:, 1] = np.array([0.02, 0.01, 0.05, 0.03, 0.02, 0.02, 0.01, 0.01])
        
        # 参考3：基线
        ref_matrix[:, 2] = 1.0
        
        # 最小二乘法拟合
        coeffs, residuals, _, _ = np.linalg.lstsq(
            ref_matrix, spectrum, rcond=None
        )
        
        isf_alcohol = coeffs[0]
        return isf_alcohol
    
    def _is_to_bac(self, isf_alcohol: float) -> float:
        """组织液浓度转血液浓度"""
        return isf_alcohol / self.ISF_TO_BLOOD_RATIO
    
    def _check_spoof(self, dot_projector_data: Optional[dict] = None) -> bool:
        """
        反欺骗检测（dot projector + 摄像头）
        
        Returns:
            True: 真实手指, False: 伪造
        """
        if dot_projector_data is None:
            return True  # 无 dot projector 时跳过
        
        # 检查点阵深度图一致性
        depth_variance = dot_projector_data.get('depth_variance', 0)
        texture_score = dot_projector_data.get('texture_score', 1.0)
        
        # 真实手指有适度深度变化和纹理
        if depth_variance < 0.1 or texture_score < 0.5:
            return False
        
        return True
    
    def detect_bac(self, finger_data: dict) -> BACResult:
        """
        执行 BAC 检测
        
        Args:
            finger_data: {
                'spectrum': 红外光谱,
                'skin_temp': 皮肤温度,
                'skin_tone': 肤肤色调,
                'dot_projector': dot projector 数据(可选)
            }
        
        Returns:
            BACResult 检测结果
        """
        import time
        start = time.time()
        
        # 1. 反欺骗检测
        is_real = self._check_spoof(finger_data.get('dot_projector'))
        if not is_real:
            return BACResult(
                bac_value=-1, confidence=0.0,
                is_impaired=False, warning_level="SPOOF_DETECTED",
                response_time_ms=(time.time() - start) * 1000
            )
        
        # 2. 获取光谱
        spectrum = finger_data.get('spectrum')
        if spectrum is None:
            # 模拟采集
            true_bac = finger_data.get('true_bac', 0.0)
            isf = true_bac * self.ISF_TO_BLOOD_RATIO
            spectrum = self._generate_spectrum(isf, 
                finger_data.get('skin_temp', 33.0),
                finger_data.get('skin_tone', 3)
            )
        
        # 3. 提取酒精浓度
        isf_alcohol = self._extract_alcohol(spectrum)
        
        # 4. 换算 BAC
        bac = self._is_to_bac(isf_alcohol) + self.calibration_offset
        
        # 5. 置信度计算（基于拟合残差）
        ref_matrix = np.zeros((len(self.WAVELENGTHS), 3))
        ref_alcohol = np.zeros(len(self.WAVELENGTHS))
        for i, wl in enumerate(self.WAVELENGTHS):
            for peak in self.ALCOHOL_PEAKS:
                if abs(wl - peak) < 100:
                    ref_alcohol[i] += 0.5 * np.exp(
                        -((wl - peak) ** 2) / (2 * 30 ** 2)
                    )
        ref_matrix[:, 0] = ref_alcohol
        ref_matrix[:, 1] = np.array([0.02, 0.01, 0.05, 0.03, 0.02, 0.02, 0.01, 0.01])
        ref_matrix[:, 2] = 1.0
        predicted = ref_matrix @ np.linalg.lstsq(ref_matrix, spectrum, rcond=None)[0]
        residual = np.sqrt(np.mean((spectrum - predicted) ** 2))
        confidence = max(0.0, min(1.0, 1.0 - residual * 10))
        
        # 6. 阈值判断
        if bac >= self.LEGAL_LIMIT:
            warning = "IMPAIRED_BLOCK"
            impaired = True
        elif bac >= self.WARNING_LIMIT:
            warning = "WARNING"
            impaired = False
        elif bac >= self.IMPAIRMENT_LIMIT:
            warning = "CAUTION"
            impaired = False
        else:
            warning = "OK"
            impaired = False
        
        elapsed = (time.time() - start) * 1000
        
        return BACResult(
            bac_value=round(bac, 4),
            confidence=round(confidence, 3),
            is_impaired=impaired,
            warning_level=warning,
            response_time_ms=round(elapsed, 1)
        )


# ==================== 测试 ====================
if __name__ == "__main__":
    np.random.seed(42)
    sensor = InfraredBACSensors(sensor_temp=25.0, calibration_offset=0.0)
    
    test_cases = [
        {"name": "清醒", "true_bac": 0.00, "skin_temp": 33.0, "skin_tone": 3},
        {"name": "轻度饮酒", "true_bac": 0.03, "skin_temp": 33.0, "skin_tone": 3},
        {"name": "警告阈值", "true_bac": 0.05, "skin_temp": 33.0, "skin_tone": 3},
        {"name": "法限阈值", "true_bac": 0.08, "skin_temp": 33.0, "skin_tone": 3},
        {"name": "严重醉酒", "true_bac": 0.15, "skin_temp": 33.0, "skin_tone": 3},
        {"name": "深色皮肤", "true_bac": 0.08, "skin_temp": 33.0, "skin_tone": 5},
        {"name": "浅色皮肤", "true_bac": 0.08, "skin_temp": 33.0, "skin_tone": 1},
        {"name": "手冷", "true_bac": 0.08, "skin_temp": 28.0, "skin_tone": 3},
    ]
    
    print("=" * 70)
    print("BAC 检测系统测试 - Aumovio 红外光谱方案模拟")
    print("=" * 70)
    print(f"{'场景':<12} {'真实BAC':>8} {'检测BAC':>8} {'置信度':>8} {'警告':>20}")
    print("-" * 70)
    
    for tc in test_cases:
        result = sensor.detect_bac(tc)
        print(f"{tc['name']:<12} {tc['true_bac']:>8.3f} {result.bac_value:>8.3f} "
              f"{result.confidence:>8.3f} {result.warning_level:>20}")
    
    print("=" * 70)
    print("\n关键指标：")
    print(f"  法定上限: {sensor.LEGAL_LIMIT} g/dL (0.08%)")
    print(f"  警告阈值: {sensor.WARNING_LIMIT} g/dL (0.04%)")
    print(f"  ISF/血液比: {sensor.ISF_TO_BLOOD_RATIO}")
    print(f"  红外波长: {sensor.WAVELENGTHS.tolist()}")