"""
Driver Intent Detection Module
Inspired by BMW Symbiotic Drive concept
For IMS development reference - simplified prototype
"""

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
import time

class IntentState(Enum):
    UNKNOWN = 0
    INTENTIONAL_LANE_CHANGE = 1
    UNINTENTIONAL_DEPARTURE = 2
    EMERGENCY_AVOIDANCE = 3
    NORMAL_DRIVING = 4

@dataclass
class SteeringInput:
    """方向盘输入信号"""
    steering_angle: float        # 度, 右转为正
    steering_rate: float         # 度/秒
    steering_torque: float       # Nm, 驾驶员施加力矩
    timestamp: float = field(default_factory=time.time)

@dataclass
class GazeInput:
    """视线输入信号 (来自 DMS 摄像头)"""
    gaze_yaw: float              # 水平注视角, 度 (正=右看)
    gaze_pitch: float            # 垂直注视角, 度
    head_yaw: float              # 头部偏转角, 度
    gaze_confidence: float       # 置信度 0-1
    timestamp: float = field(default_factory=time.time)

@dataclass
class VehicleState:
    """车辆状态"""
    speed: float                 # m/s
    lateral_accel: float         # m/s²
    yaw_rate: float              # 度/秒
    lane_offset: float          # m, 距车道线偏移 (正=偏右)
    lane_departure_prob: float   # 车道偏离概率 0-1
    timestamp: float = field(default_factory=time.time)

class DriverIntentDetector:
    """
    多模态驾驶员意图检测器
    融合方向盘输入、视线方向、转向灯状态判断驾驶意图
    """
    
    # 阈值参数 - 需根据实车标定
    STEERING_RATE_THRESHOLD = 30.0      # 度/秒, 主动转向最低角速度
    STEERING_TORQUE_THRESHOLD = 1.5     # Nm, 主动施加力矩最低值
    GAZE_YAW_THRESHOLD = 15.0           # 度, 视线偏转阈值
    HEAD_YAW_THRESHOLD = 25.0           # 度, 头部偏转阈值 (肩检查)
    TURN_SIGNAL_MIN_MS = 500           # 转向灯最短激活时间
    LANE_DEPARTURE_HIGH = 0.7          # 高偏离概率阈值
    TIME_WINDOW = 2.0                  # 信号融合时间窗口 (秒)
    
    def __init__(self):
        self.turn_signal_active = False
        self.turn_signal_activated_at: Optional[float] = None
        self.history: list[dict] = []
    
    def update_turn_signal(self, active: bool):
        """更新转向灯状态"""
        if active and not self.turn_signal_active:
            self.turn_signal_activated_at = time.time()
        elif not active:
            self.turn_signal_activated_at = None
        self.turn_signal_active = active
    
    def _check_shoulder_check(self, gaze: GazeInput) -> bool:
        """检测是否在做肩检查 (头部偏转 + 视线偏向)"""
        return (abs(gaze.head_yaw) > self.HEAD_YAW_THRESHOLD and
                abs(gaze.gaze_yaw) > self.GAZE_YAW_THRESHOLD and
                gaze.gaze_confidence > 0.6)
    
    def _check_active_steering(self, steer: SteeringInput) -> bool:
        """检测是否为主动转向输入"""
        return (abs(steer.steering_rate) > self.STEERING_RATE_THRESHOLD or
                abs(steer.steering_torque) > self.STEERING_TORQUE_THRESHOLD)
    
    def _check_turn_signal(self) -> bool:
        """检测转向灯是否已激活足够时长"""
        if not self.turn_signal_active or self.turn_signal_activated_at is None:
            return False
        elapsed = (time.time() - self.turn_signal_activated_at) * 1000
        return elapsed > self.TURN_SIGNAL_MIN_MS
    
    def classify_intent(
        self,
        steer: SteeringInput,
        gaze: GazeInput,
        vehicle: VehicleState,
        turn_signal: bool
    ) -> IntentState:
        """
        主分类函数: 融合多模态信号判断驾驶意图
        
        Returns:
            IntentState: 意图分类结果
        """
        self.update_turn_signal(turn_signal)
        
        # 信号检查
        active_steer = self._check_active_steering(steer)
        shoulder_check = self._check_shoulder_check(gaze)
        signal_long_enough = self._check_turn_signal()
        
        # 意图评分
        intent_score = 0.0
        reasons = []
        
        if active_steer:
            intent_score += 0.40
            reasons.append("active_steering")
        if shoulder_check:
            intent_score += 0.25
            reasons.append("shoulder_check")
        if signal_long_enough:
            intent_score += 0.25
            reasons.append("turn_signal")
        if abs(gaze.gaze_yaw) > self.GAZE_YAW_THRESHOLD:
            intent_score += 0.10
            reasons.append("gaze_diverted")
        
        # 分类决策
        if vehicle.lane_departure_prob > 0.95:
            # 极高偏离概率 - 可能紧急情况
            if intent_score < 0.2:
                return IntentState.UNINTENTIONAL_DEPARTURE
            else:
                return IntentState.INTENTIONAL_LANE_CHANGE
        elif vehicle.lane_departure_prob > self.LANE_DEPARTURE_HIGH:
            # 高偏离概率
            if intent_score >= 0.35:
                # 有足够意图信号 -> 有意变道, 不干预
                return IntentState.INTENTIONAL_LANE_CHANGE
            else:
                # 意图信号不足 -> 非故意偏离, 应干预
                return IntentState.UNINTENTIONAL_DEPARTURE
        else:
            # 偏离概率不高
            if active_steer and intent_score >= 0.5:
                return IntentState.INTENTIONAL_LANE_CHANGE
            return IntentState.NORMAL_DRIVING
    
    def should_intervene(self, intent: IntentState, vehicle: VehicleState) -> bool:
        """
        根据意图判断是否应该触发车道保持干预
        
        BMW Symbiotic Drive 原则:
        - 有意操作不干预 (除非碰撞风险)
        - 非故意偏离才干预
        """
        if intent == IntentState.UNINTENTIONAL_DEPARTURE:
            return True
        if intent == IntentState.INTENTIONAL_LANE_CHANGE:
            # 有意变道, 但仍需检查碰撞风险
            # 碰撞风险检测交由独立模块处理
            return False
        return False


# --- 使用示例 ---
if __name__ == "__main__":
    detector = DriverIntentDetector()
    
    # 场景1: 驾驶员打转向灯 + 肩检查 + 主动转向 -> 有意变道
    steer1 = SteeringInput(steering_angle=15.0, steering_rate=45.0, steering_torque=2.0)
    gaze1 = GazeInput(gaze_yaw=25.0, gaze_pitch=-5.0, head_yaw=35.0, gaze_confidence=0.85)
    vehicle1 = VehicleState(speed=27.0, lateral_accel=1.2, yaw_rate=2.5,
                            lane_offset=0.3, lane_departure_prob=0.75)
    
    intent1 = detector.classify_intent(steer1, gaze1, vehicle1, turn_signal=True)
    print(f"场景1 (有意变道): {intent1.name}")
    print(f"  应干预: {detector.should_intervene(intent1, vehicle1)}")
    
    # 场景2: 无任何意图信号, 车道偏离 -> 非故意偏离
    steer2 = SteeringInput(steering_angle=2.0, steering_rate=5.0, steering_torque=0.3)
    gaze2 = GazeInput(gaze_yaw=3.0, gaze_pitch=0.0, head_yaw=2.0, gaze_confidence=0.7)
    vehicle2 = VehicleState(speed=30.0, lateral_accel=0.5, yaw_rate=1.0,
                            lane_offset=0.4, lane_departure_prob=0.82)
    
    intent2 = detector.classify_intent(steer2, gaze2, vehicle2, turn_signal=False)
    print(f"场景2 (分心偏离): {intent2.name}")
    print(f"  应干预: {detector.should_intervene(intent2, vehicle2)}")

"""
Emergency Brake & Steering Coordination Module
Neue Klasse Active Safety - EBA + ESI Coordination
"""

from enum import IntEnum
from dataclasses import dataclass

class CollisionRisk(IntEnum):
    NONE = 0
    LOW = 1      # TTC > 4s
    MEDIUM = 2   # TTC 2-4s
    HIGH = 3     # TTC 1-2s
    CRITICAL = 4 # TTC < 1s

class ObstacleType(IntEnum):
    PEDESTRIAN = 0
    CYCLIST = 1
    VEHICLE = 2
    ANIMAL_LARGE = 3    # 鹿、马、牛
    ANIMAL_SMALL = 4    # 狗、猫 (不触发制动)
    STATIC_OBJECT = 5  # 墙、护栏

@dataclass
class Obstacle:
    obstacle_type: ObstacleType
    distance_m: float
    relative_speed_mps: float  # 相对速度 (正=接近)
    width_m: float
    lane_position: float       # 车道内位置 (-1=左线, 0=中心, 1=右线)
    confidence: float          # 检测置信度

class BrakeSteerCoordinator:
    """
    制动-转向协调器
    决定: 制动 vs 转向 vs 制动+转向
    """
    
    # 车辆参数 (需标定)
    MAX_DECEL_MPS2 = 9.5        # 最大减速度 m/s²
    MIN_STEER_SPACE_M = 1.5     # 最小绕行空间
    LANE_WIDTH_M = 3.75         # 标准车道宽度
    VEHICLE_WIDTH_M = 1.89      # BMW iX3 车宽
    
    def calculate_ttc(self, obs: Obstacle) -> float:
        """计算碰撞时间 (Time to Collision)"""
        if obs.relative_speed_mps <= 0:
            return float('inf')  # 不接近, 无碰撞风险
        return obs.distance_m / obs.relative_speed_mps
    
    def assess_risk(self, obs: Obstacle) -> CollisionRisk:
        """评估碰撞风险等级"""
        if obs.confidence < 0.5:
            return CollisionRisk.NONE
        
        ttc = self.calculate_ttc(obs)
        
        # 小动物不触发
        if obs.obstacle_type == ObstacleType.ANIMAL_SMALL:
            return CollisionRisk.NONE
        
        if ttc < 1.0:
            return CollisionRisk.CRITICAL
        elif ttc < 2.0:
            return CollisionRisk.HIGH
        elif ttc < 4.0:
            return CollisionRisk.MEDIUM
        elif ttc < 6.0:
            return CollisionRisk.LOW
        else:
            return CollisionRisk.NONE
    
    def can_avoid_by_braking(self, obs: Obstacle, current_speed: float) -> bool:
        """判断仅靠制动是否可以避免碰撞"""
        if obs.relative_speed_mps <= 0:
            return True
        # 制动距离 = v² / (2*a)
        braking_distance = (current_speed ** 2) / (2 * self.MAX_DECEL_MPS2)
        return braking_distance < obs.distance_m
    
    def has_steering_space(self, obs: Obstacle) -> bool:
        """判断车道内是否有足够绕行空间"""
        # 计算可用空间
        if obs.lane_position >= 0:
            # 障碍物在右侧, 左侧有空间
            available = (self.LANE_WIDTH_M / 2 + obs.lane_position * self.LANE_WIDTH_M / 2
                        - obs.width_m / 2 - self.VEHICLE_WIDTH_M / 2)
        else:
            # 障碍物在左侧, 右侧有空间
            available = (self.LANE_WIDTH_M / 2 - obs.lane_position * self.LANE_WIDTH_M / 2
                        - obs.width_m / 2 - self.VEHICLE_WIDTH_M / 2)
        return available > self.MIN_STEER_SPACE_M
    
    def decide_action(self, obs: Obstacle, current_speed: float) -> dict:
        """
        决策: 制动 vs 转向 vs 组合
        
        Returns:
            dict with 'action', 'decel', 'steer_angle'
        """
        risk = self.assess_risk(obs)
        
        if risk == CollisionRisk.NONE or risk == CollisionRisk.LOW:
            return {"action": "monitor", "decel": 0.0, "steer_angle": 0.0}
        
        can_brake = self.can_avoid_by_braking(obs, current_speed)
        can_steer = self.has_steering_space(obs)
        
        if risk == CollisionRisk.MEDIUM:
            # 中等风险: 预警 + 轻制动
            return {"action": "warn_and_prebrake", "decel": 3.0, "steer_angle": 0.0}
        
        if risk == CollisionRisk.HIGH or risk == CollisionRisk.CRITICAL:
            if can_brake:
                # 制动可避免碰撞 -> 全力制动
                return {
                    "action": "full_brake",
                    "decel": self.MAX_DECEL_MPS2,
                    "steer_angle": 0.0,
                    "reason": "braking_sufficient"
                }
            elif can_steer:
                # 制动不够但有绕行空间 -> 紧急转向
                steer_dir = -1 if obs.lane_position >= 0 else 1  # 向反方向转
                return {
                    "action": "emergency_steer",
                    "decel": 2.0,  # 轻制动辅助
                    "steer_angle": steer_dir * 15.0,  # 度
                    "reason": "steering_space_available"
                }
            else:
                # 都不行 -> 最大力制动 (降低碰撞能量)
                return {
                    "action": "full_brake",
                    "decel": self.MAX_DECEL_MPS2,
                    "steer_angle": 0.0,
                    "reason": "no_avoidance_possible"
                }
        
        return {"action": "monitor", "decel": 0.0, "steer_angle": 0.0}


# 测试用例
if __name__ == "__main__":
    coordinator = BrakeSteerCoordinator()
    
    # 场景1: 前方行人突然穿出, 距离 15m, 相对速度 20m/s
    # 制动距离 = 20²/(2*9.5) ≈ 21m > 15m -> 制动不够
    ped = Obstacle(
        obstacle_type=ObstacleType.PEDESTRIAN,
        distance_m=15.0,
        relative_speed_mps=20.0,
        width_m=0.5,
        lane_position=0.3,
        confidence=0.9
    )
    result1 = coordinator.decide_action(ped, current_speed=20.0)
    print(f"场景1 (行人紧急穿出): {result1}")
    # 预期: emergency_steer (制动不够, 有绕行空间)
    
    # 场景2: 前方大型动物 (鹿), 距离 40m
    deer = Obstacle(
        obstacle_type=ObstacleType.ANIMAL_LARGE,
        distance_m=40.0,
        relative_speed_mps=15.0,
        width_m=0.6,
        lane_position=0.0,
        confidence=0.85
    )
    result2 = coordinator.decide_action(deer, current_speed=15.0)
    print(f"场景2 (野生动物): {result2}")
    # 预期: full_brake (制动距离 11.8m < 40m, 制动足够)
    
    # 场景3: 小动物 (猫), 不触发
    cat = Obstacle(
        obstacle_type=ObstacleType.ANIMAL_SMALL,
        distance_m=5.0,
        relative_speed_mps=25.0,
        width_m=0.2,
        lane_position=0.0,
        confidence=0.8
    )
    result3 = coordinator.decide_action(cat, current_speed=25.0)
    print(f"场景3 (小动物-猫): {result3}")
    # 预期: monitor (小动物不触发干预)

"""
Driver Incapacitation Detection Module
Neue Klasse Attentiveness Assistant
"""

from dataclasses import dataclass
from enum import IntEnum

class IncapacitationLevel(IntEnum):
    ALERT = 0           # 正常警觉
    DROWSY = 1          # 轻度疲劳
    SIGNIFICANTLY_FATIGUED = 2  # 显著疲劳
    INCAPACITATED = 3   # 失能 (需紧急停车)
    MEDICAL_EMERGENCY = 4  # 疑似医疗紧急情况

@dataclass
class DMSFeatures:
    """驾驶员监控摄像头特征"""
    eye_openness_ratio: float     # 眼睛开合比 0-1 (PERCLOS)
    blink_rate_per_min: float     # 每分钟眨眼率
    avg_blink_duration_ms: float  # 平均眨眼时长
    gaze_stability: float        # 视线稳定性 0-1
    head_nod_angle: float        # 头部下垂角度 (度)
    head_pitch_variance: float   # 头部俯仰方差 (度²)
    mouth_yawn_ratio: float      # 打哈欠嘴部开合比 0-1
    posture_collapsed: bool      # 身体姿态是否垮塌
    eye_closure_duration_s: float # 持续闭眼时长 (秒)
    
class IncapacitationDetector:
    """
    驾驶员失能检测器
    多特征融合判断驾驶员是否仍具备驾驶能力
    """
    
    # 阈值 (需实车标定)
    PERCLOS_THRESHOLD = 0.15        # PERCLOS > 15% -> 疲劳
    EYE_CLOSURE_CRITICAL_S = 3.0   # 闭眼>3秒 -> 可能失能
    EYE_CLOSURE_EMERGENCY_S = 6.0  # 闭眼>6秒 -> 紧急
    BLINK_RATE_LOW = 5.0           # 眨眼率<5次/分 -> 可能疲劳
    BLINK_RATE_HIGH = 30.0         # 眨眼率>30次/分 -> 可能紧张/疲劳
    HEAD_NOD_THRESHOLD = 15.0      # 头部下垂>15度 -> 疲劳
    YAWN_THRESHOLD = 0.6           # 嘴部开合>0.6 -> 打哈欠
    
    def detect(self, features: DMSFeatures) -> IncapacitationLevel:
        """多特征融合失能检测"""
        score = 0
        
        # PERCLOS (单位时间内眼睛闭合比例)
        if features.eye_openness_ratio < 0.5:
            score += 3  # 眼睛大部分时间闭合
        elif features.eye_openness_ratio < 0.85:
            score += 1  # 轻度闭合
        
        # 持续闭眼时间 (最关键指标)
        if features.eye_closure_duration_s > self.EYE_CLOSURE_EMERGENCY_S:
            score += 5  # 紧急级别
        elif features.eye_closure_duration_s > self.EYE_CLOSURE_CRITICAL_S:
            score += 3
        
        # 眨眼率
        if features.blink_rate_per_min < self.BLINK_RATE_LOW:
            score += 1
        elif features.blink_rate_per_min > self.BLINK_RATE_HIGH:
            score += 1
        
        # 头部姿态
        if features.head_nod_angle > self.HEAD_NOD_THRESHOLD:
            score += 2
        if features.posture_collapsed:
            score += 3  # 身体垮塌 = 严重信号
        
        # 打哈欠
        if features.mouth_yawn_ratio > self.YAWN_THRESHOLD:
            score += 1
        
        # 视线稳定性
        if features.gaze_stability < 0.3:
            score += 2  # 视线不稳定
        
        # 分级决策
        if score >= 8:
            return IncapacitationLevel.MEDICAL_EMERGENCY
        elif score >= 5:
            return IncapacitationLevel.INCAPACITATED
        elif score >= 3:
            return IncapacitationLevel.SIGNIFICANTLY_FATIGUED
        elif score >= 1:
            return IncapacitationLevel.DROWSY
        else:
            return IncapacitationLevel.ALERT
    
    def should_trigger_emergency_stop(self, level: IncapacitationLevel) -> bool:
        """是否应触发紧急停车"""
        return level in (IncapacitationLevel.INCAPACITATED,
                        IncapacitationLevel.MEDICAL_EMERGENCY)


# 示例: 检测到驾驶员疑似心脏不适 (突然垮塌 + 持续闭眼)
if __name__ == "__main__":
    detector = IncapacitationDetector()
    
    # 模拟医疗紧急情况
    emergency_features = DMSFeatures(
        eye_openness_ratio=0.2,
        blink_rate_per_min=3,
        avg_blink_duration_ms=400,
        gaze_stability=0.1,
        head_nod_angle=35.0,
        head_pitch_variance=50.0,
        mouth_yawn_ratio=0.0,
        posture_collapsed=True,
        eye_closure_duration_s=7.5
    )
    
    level = detector.detect(emergency_features)
    print(f"失能等级: {level.name}")
    print(f"触发紧急停车: {detector.should_trigger_emergency_stop(level)}")
    # 预期: MEDICAL_EMERGENCY -> 触发紧急停车 + eCall

"""
IMS Active Safety Test Scenario Runner
Automated test framework for Neue Klasse-equivalent safety features
"""

import json
import time
from dataclasses import dataclass, asdict
from typing import List

@dataclass
class TestScenario:
    """测试场景定义"""
    scenario_id: str
    name: str
    category: str          # dooring | steering | braking | dms | intent
    vehicle_speed_kmh: float
    target_type: str       # cyclist | pedestrian | vehicle | animal | none
    target_speed_kmh: float
    target_distance_m: float
    weather: str           # clear | rain | night | fog
    expected_action: str   # warn | brake | steer | delay_door | emergency_stop
    ttc_threshold_s: float
    pass_criteria: str

class TestScenarioRunner:
    """测试场景执行器"""
    
    def __init__(self):
        self.scenarios: List[TestScenario] = []
        self.results = []
        self._init_scenarios()
    
    def _init_scenarios(self):
        """初始化标准测试场景集"""
        
        # --- Dooring 防护 ---
        self.scenarios.extend([
            TestScenario(
                scenario_id="DOOR-001",
                name="骑车人从左侧接近 - 晴天",
                category="dooring",
                vehicle_speed_kmh=0,
                target_type="cyclist",
                target_speed_kmh=20,
                target_distance_m=30,
                weather="clear",
                expected_action="delay_door",
                ttc_threshold_s=3.0,
                pass_criteria="门锁延迟 >= 1.5s, 声光警告触发"
            ),
            TestScenario(
                scenario_id="DOOR-002",
                name="骑车人从右侧接近 - 夜间",
                category="dooring",
                vehicle_speed_kmh=0,
                target_type="cyclist",
                target_speed_kmh=15,
                target_distance_m=20,
                weather="night",
                expected_action="delay_door",
                ttc_threshold_s=3.0,
                pass_criteria="门锁延迟, 氛围灯红色闪烁"
            ),
            TestScenario(
                scenario_id="DOOR-003",
                name="无目标 - 正常开门",
                category="dooring",
                vehicle_speed_kmh=0,
                target_type="none",
                target_speed_kmh=0,
                target_distance_m=0,
                weather="clear",
                expected_action="none",
                ttc_threshold_s=99.0,
                pass_criteria="门立即释放, 无延迟, 无警告"
            ),
        ])
        
        # --- 紧急转向绕障 ---
        self.scenarios.extend([
            TestScenario(
                scenario_id="STEER-001",
                name="行人从停放车辆间穿出",
                category="steering",
                vehicle_speed_kmh=50,
                target_type="pedestrian",
                target_speed_kmh=5,
                target_distance_m=15,
                weather="clear",
                expected_action="steer",
                ttc_threshold_s=1.5,
                pass_criteria="自动转向绕过, 不出车道, 不碰撞"
            ),
            TestScenario(
                scenario_id="STEER-002",
                name="骑车人低光条件",
                category="steering",
                vehicle_speed_kmh=40,
                target_type="cyclist",
                target_speed_kmh=15,
                target_distance_m=10,
                weather="night",
                expected_action="steer",
                ttc_threshold_s=1.0,
                pass_criteria="识别骑车人, 转向绕过, 保持车道"
            ),
        ])
        
        # --- 紧急制动 (含动物) ---
        self.scenarios.extend([
            TestScenario(
                scenario_id="BRAKE-001",
                name="大型动物 (鹿) - 黄昏",
                category="braking",
                vehicle_speed_kmh=80,
                target_type="animal",
                target_speed_kmh=0,
                target_distance_m=60,
                weather="night",
                expected_action="brake",
                ttc_threshold_s=2.5,
                pass_criteria="识别动物, 全力制动, 避免碰撞"
            ),
            TestScenario(
                scenario_id="BRAKE-002",
                name="行人 - 城市速度",
                category="braking",
                vehicle_speed_kmh=50,
                target_type="pedestrian",
                target_speed_kmh=0,
                target_distance_m=20,
                weather="clear",
                expected_action="brake",
                ttc_threshold_s=1.5,
                pass_criteria="全力制动, 避免碰撞或速度降至 < 20km/h"
            ),
        ])
        
        # --- 失能检测 ---
        self.scenarios.extend([
            TestScenario(
                scenario_id="DMS-001",
                name="驾驶员持续闭眼 6s - 高速",
                category="dms",
                vehicle_speed_kmh=100,
                target_type="none",
                target_speed_kmh=0,
                target_distance_m=0,
                weather="clear",
                expected_action="emergency_stop",
                ttc_threshold_s=99.0,
                pass_criteria="10s内开始减速, 靠边停车, 双闪, eCall"
            ),
        ])
        
        # --- 意图识别 ---
        self.scenarios.extend([
            TestScenario(
                scenario_id="INTENT-001",
                name="有意变道 - 转向灯+肩检查",
                category="intent",
                vehicle_speed_kmh=80,
                target_type="none",
                target_speed_kmh=0,
                target_distance_m=0,
                weather="clear",
                expected_action="none",
                ttc_threshold_s=99.0,
                pass_criteria="车道保持不干预, 无误触发警告"
            ),
            TestScenario(
                scenario_id="INTENT-002",
                name="分心偏离 - 无意图信号",
                category="intent",
                vehicle_speed_kmh=80,
                target_type="none",
                target_speed_kmh=0,
                target_distance_m=0,
                weather="clear",
                expected_action="warn",
                ttc_threshold_s=99.0,
                pass_criteria="车道保持主动回正, 触发警告"
            ),
        ])
    
    def run_scenario(self, scenario: TestScenario) -> dict:
        """执行单个测试场景 (模拟/实车)"""
        print(f"\n{'='*60}")
        print(f"执行场景: {scenario.scenario_id} - {scenario.name}")
        print(f"  类别: {scenario.category}")
        print(f"  车速: {scenario.vehicle_speed_kmh} km/h")
        print(f"  目标: {scenario.target_type} @ {scenario.target_speed_kmh} km/h")
        print(f"  天气: {scenario.weather}")
        print(f"  预期: {scenario.expected_action}")
        print(f"  通过标准: {scenario.pass_criteria}")
        
        # TODO: 调用实际 HIL/SIL/实车 测试接口
        # 这里仅打印场景定义
        
        result = {
            "scenario_id": scenario.scenario_id,
            "name": scenario.name,
            "status": "DEFINED",  # PASSED / FAILED / DEFINED
            "timestamp": time.time(),
        }
        self.results.append(result)
        return result
    
    def run_all(self):
        """执行所有场景"""
        print(f"共 {len(self.scenarios)} 个测试场景\n")
        for s in self.scenarios:
            self.run_scenario(s)
        
        print(f"\n{'='*60}")
        print(f"测试总结: {len(self.scenarios)} 场景已定义")
        print(f"  Dooring: {sum(1 for s in self.scenarios if s.category == 'dooring')}")
        print(f"  紧急转向: {sum(1 for s in self.scenarios if s.category == 'steering')}")
        print(f"  紧急制动: {sum(1 for s in self.scenarios if s.category == 'braking')}")
        print(f"  失能检测: {sum(1 for s in self.scenarios if s.category == 'dms')}")
        print(f"  意图识别: {sum(1 for s in self.scenarios if s.category == 'intent')}")
        
        # 导出场景定义
        with open("test_scenarios_export.json", "w", encoding="utf-8") as f:
            json.dump([asdict(s) for s in self.scenarios], f,
                     ensure_ascii=False, indent=2)
        print("\n场景定义已导出: test_scenarios_export.json")


if __name__ == "__main__":
    runner = TestScenarioRunner()
    runner.run_all()