sascar 0.1.0-alpha

// RFC-009: SASCAR 实现示例
// 分布式移动主权与动能资源协议

use std::time::{Duration, Instant};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

// 1. 常量定义
pub const SASCAR_ACTUATION_LOOP_HZ: f64 = 1200.0; // 1.2kHz 执行循环
pub const KINETIC_SYNC_MAX_JITTER_US: u64 = 50;   // < 50µs 运动同步抖动
pub const SAFETY_INTERRUPT_MAX_US: u64 = 300;     // < 300µs 安全中断响应
pub const PATH_CLEAR_FINALITY_MS: u64 = 2;        // < 2ms 路径清算最终性

// 2. 核心数据结构

/// 运动向量 (Velocity Vector)
#[derive(Debug, Clone, Copy)]
pub struct VelocityVector {
    pub x: f32, // 米/秒 (前进)
    pub y: f32, // 米/秒 (侧向)
    pub z: f32, // 米/秒 (垂直)
}

/// 角动量 (Angular Momentum)
#[derive(Debug, Clone, Copy)]
pub struct AngularMomentum {
    pub roll: f32,   // 滚转 (弧度/秒)
    pub pitch: f32,  // 俯仰 (弧度/秒)
    pub yaw: f32,   // 偏航 (弧度/秒)
}

/// 运动脉冲帧 (Mobility Pulse Frame)
#[derive(Debug, Clone)]
pub struct MobilityPulseFrame {
    pub timestamp: u64,           // 纳秒级时间戳
    pub node_id: [u8; 32],        // AID 标识符
    pub velocity: VelocityVector, // 速度向量
    pub angular: AngularMomentum, // 角动量
    pub action_collapse: [f32; 3], // 动作坍缩向量
    pub path_bid: u64,            // 皮克代币路径竞价
    pub rpki_signature: [u8; 32], // RPKI 张量签名
}

/// 路径清算请求 (Path Clearing Request)
#[derive(Debug, Clone)]
pub struct PathClearingRequest {
    pub request_id: u128,         // 唯一请求ID
    pub requester_id: [u8; 32],   // 请求者AID
    pub target_trajectory: Vec<[f32; 3]>, // 目标轨迹点 (x,y,z)
    pub clearance_radius: f32,    // 清理半径 (米)
    pub bid_per_meter: u64,       // 每米竞价 (皮克代币)
    pub urgency_level: u8,        // 紧急级别 0-255
    pub iqa_seal: Option<[u8; 64]>, // IQA 印章 (可选)
    pub expiration_time: u64,     // 过期时间戳
}

/// 碰撞向量 (Collision Vector)
#[derive(Debug, Clone)]
pub struct CollisionVector {
    pub detection_time: u64,      // 检测时间
    pub predicted_collision_time: u64, // 预测碰撞时间
    pub collision_point: [f32; 3], // 碰撞点坐标
    pub relative_velocity: f32,   // 相对速度 (米/秒)
    pub avoidance_vector: [f32; 3], // 规避向量
    pub priority_level: u8,       // 优先级 (0-255, 255最高)
}

// 3. 运动同步引擎

/// 运动同步引擎 (Kinetic Synchronization Engine)
pub struct KineticSyncEngine {
    local_state: Arc<Mutex<LocalMotionState>>,
    neighbor_states: Arc<Mutex<HashMap<[u8; 32], NeighborMotionState>>>,
    last_sync_time: Instant,
}

#[derive(Debug, Clone)]
pub struct LocalMotionState {
    pub position: [f32; 3],      // 当前位置 (x,y,z)
    pub velocity: VelocityVector,
    pub angular: AngularMomentum,
    pub acceleration: [f32; 3],  // 加速度
    pub motion_entropy: f32,     // 运动熵 (稳定性指标)
    pub last_pulse_time: u64,
}

#[derive(Debug, Clone)]
pub struct NeighborMotionState {
    pub last_pulse: MobilityPulseFrame,
    pub received_time: u64,
    pub trust_score: f32,        // 信任分数 (0.0-1.0)
    pub predicted_trajectory: Vec<[f32; 3]>, // 预测轨迹
}

impl KineticSyncEngine {
    pub fn new() -> Self {
        Self {
            local_state: Arc::new(Mutex::new(LocalMotionState {
                position: [0.0, 0.0, 0.0],
                velocity: VelocityVector { x: 0.0, y: 0.0, z: 0.0 },
                angular: AngularMomentum { roll: 0.0, pitch: 0.0, yaw: 0.0 },
                acceleration: [0.0, 0.0, 0.0],
                motion_entropy: 0.0,
                last_pulse_time: 0,
            })),
            neighbor_states: Arc::new(Mutex::new(HashMap::new())),
            last_sync_time: Instant::now(),
        }
    }
    
    /// 生成运动脉冲 (每833µs调用一次)
    pub fn generate_mobility_pulse(&mut self, node_id: [u8; 32]) -> MobilityPulseFrame {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        
        let state = self.local_state.lock().unwrap();
        
        MobilityPulseFrame {
            timestamp: now,
            node_id,
            velocity: state.velocity,
            angular: state.angular,
            action_collapse: [0.0, 0.0, 0.0], // 简化示例
            path_bid: 0, // 默认无竞价
            rpki_signature: [0u8; 32], // 简化示例
        }
    }
    
    /// 处理邻居运动脉冲
    pub fn process_neighbor_pulse(&mut self, pulse: MobilityPulseFrame) -> Result<(), String> {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        
        // 检查时间抖动
        let jitter = (now as i64 - pulse.timestamp as i64).abs() as u64;
        if jitter > KINETIC_SYNC_MAX_JITTER_US * 1000 {
            return Err(format!("运动同步抖动过大: {}ns > {}ns", 
                jitter, KINETIC_SYNC_MAX_JITTER_US * 1000));
        }
        
        // 更新邻居状态
        let mut states = self.neighbor_states.lock().unwrap();
        states.insert(pulse.node_id, NeighborMotionState {
            last_pulse: pulse.clone(),
            received_time: now,
            trust_score: 1.0, // 简化示例
            predicted_trajectory: vec![], // 简化示例
        });
        
        Ok(())
    }
    
    /// 计算协同运动调整
    pub fn calculate_cooperative_adjustment(&self) -> Option<[f32; 3]> {
        let states = self.neighbor_states.lock().unwrap();
        if states.is_empty() {
            return None;
        }
        
        // 简化示例：计算平均邻居速度
        let mut avg_velocity = [0.0f32; 3];
        let mut count = 0;
        
        for (_, state) in states.iter() {
            avg_velocity[0] += state.last_pulse.velocity.x;
            avg_velocity[1] += state.last_pulse.velocity.y;
            avg_velocity[2] += state.last_pulse.velocity.z;
            count += 1;
        }
        
        if count > 0 {
            avg_velocity[0] /= count as f32;
            avg_velocity[1] /= count as f32;
            avg_velocity[2] /= count as f32;
            Some(avg_velocity)
        } else {
            None
        }
    }
}

// 4. 路径拍卖引擎

/// 路径拍卖引擎 (Path Auction Engine)
pub struct PathAuctionEngine {
    active_auctions: Arc<Mutex<HashMap<u128, PathAuction>>>,
    auction_history: Arc<Mutex<Vec<AuctionRecord>>>,
}

#[derive(Debug, Clone)]
pub struct PathAuction {
    pub request: PathClearingRequest,
    pub start_time: u64,
    pub participants: Vec<[u8; 32]>, // 参与竞价的节点
    pub highest_bid: u64,
    pub highest_bidder: Option<[u8; 32]>,
    pub status: AuctionStatus,
}

#[derive(Debug, Clone, PartialEq)]
pub enum AuctionStatus {
    Open,
    Closed,
    Settled,
    Cancelled,
}

#[derive(Debug, Clone)]
pub struct AuctionRecord {
    pub auction_id: u128,
    pub request_id: u128,
    pub winner: [u8; 32],
    pub winning_bid: u64,
    pub clearing_time_ms: u64,
    pub settlement_time: u64,
}

impl PathAuctionEngine {
    pub fn new() -> Self {
        Self {
            active_auctions: Arc::new(Mutex::new(HashMap::new())),
            auction_history: Arc::new(Mutex::new(Vec::new())),
        }
    }
    
    /// 发起路径清算请求
    pub fn initiate_path_clearing(&mut self, request: PathClearingRequest) -> Result<u128, String> {
        let auction_id = rand::random::<u128>();
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        
        let auction = PathAuction {
            request: request.clone(),
            start_time: now,
            participants: Vec::new(),
            highest_bid: 0,
            highest_bidder: None,
            status: AuctionStatus::Open,
        };
        
        let mut auctions = self.active_auctions.lock().unwrap();
        auctions.insert(auction_id, auction);
        
        Ok(auction_id)
    }
    
    /// 参与路径竞价
    pub fn submit_bid(&mut self, auction_id: u128, bidder_id: [u8; 32], bid_amount: u64) -> Result<bool, String> {
        let mut auctions = self.active_auctions.lock().unwrap();
        
        if let Some(auction) = auctions.get_mut(&auction_id) {
            if auction.status != AuctionStatus::Open {
                return Err("拍卖已关闭".to_string());
            }
            
            // 检查竞价是否高于当前最高价
            if bid_amount > auction.highest_bid {
                auction.highest_bid = bid_amount;
                auction.highest_bidder = Some(bidder_id);
                
                // 添加参与者
                if !auction.participants.contains(&bidder_id) {
                    auction.participants.push(bidder_id);
                }
                
                Ok(true) // 成为当前最高竞价者
            } else {
                Ok(false) // 竞价不够高
            }
        } else {
            Err("拍卖不存在".to_string())
        }
    }
    
    /// 结算拍卖
    pub fn settle_auction(&mut self, auction_id: u128) -> Result<AuctionRecord, String> {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        
        let mut auctions = self.active_auctions.lock().unwrap();
        
        if let Some(auction) = auctions.get_mut(&auction_id) {
            if auction.status != AuctionStatus::Open {
                return Err("拍卖已关闭".to_string());
            }
            
            // 检查是否超时
            let elapsed_ms = (now - auction.start_time) / 1_000_000;
            if elapsed_ms > PATH_CLEAR_FINALITY_MS {
                auction.status = AuctionStatus::Cancelled;
                return Err("拍卖超时".to_string());
            }
            
            // 必须有获胜者
            let winner = match auction.highest_bidder {
                Some(id) => id,
                None => return Err("无有效竞价".to_string()),
            };
            
            // 创建结算记录
            let record = AuctionRecord {
                auction_id,
                request_id: auction.request.request_id,
                winner,
                winning_bid: auction.highest_bid,
                clearing_time_ms: elapsed_ms,
                settlement_time: now,
            };
            
            // 更新状态
            auction.status = AuctionStatus::Settled;
            
            // 保存历史记录
            let mut history = self.auction_history.lock().unwrap();
            history.push(record.clone());
            
            // 从活跃拍卖中移除
            auctions.remove(&auction_id);
            
            Ok(record)
        } else {
            Err("拍卖不存在".to_string())
        }
    }
}

// 5. 碰撞检测与规避系统

/// 碰撞检测与规避系统 (Collision Detection & Avoidance System)
pub struct CollisionAvoidanceSystem {
    collision_buffer: Arc<Mutex<Vec<CollisionVector>>>,
    last_detection_time: Instant,
    avoidance_strategies: HashMap<u8, AvoidanceStrategy>,
}

#[derive(Debug, Clone)]
pub struct AvoidanceStrategy {
    pub priority: u8,
    pub response_time_us: u64,
    pub adjustment_vector: [f32; 3],
    pub energy_cost: f32,
}

impl CollisionAvoidanceSystem {
    pub fn new() -> Self {
        let mut strategies = HashMap::new();
        
        // 优先级 255: 紧急规避 (最高优先级)
        strategies.insert(255, AvoidanceStrategy {
            priority: 255,
            response_time_us: 100, // < 100µs 响应
            adjustment_vector: [0.0, -5.0, 0.0], // 紧急侧向规避
            energy_cost: 100.0,
        });
        
        // 优先级 200: 高优先级规避
        strategies.insert(200, AvoidanceStrategy {
            priority: 200,
            response_time_us: 200, // < 200µs 响应
            adjustment_vector: [0.0, -2.0, 0.0], // 中等侧向规避
            energy_cost: 50.0,
        });
        
        // 优先级 100: 标准规避
        strategies.insert(100, AvoidanceStrategy {
            priority: 100,
            response_time_us: 300, // < 300µs 响应
            adjustment_vector: [0.0, -1.0, 0.0], // 轻微侧向规避
            energy_cost: 20.0,
        });
        
        Self {
            collision_buffer: Arc::new(Mutex::new(Vec::new())),
            last_detection_time: Instant::now(),
            avoidance_strategies: strategies,
        }
    }
    
    /// 检测碰撞风险
    pub fn detect_collision_risk(
        &mut self,
        self_position: [f32; 3],
        self_velocity: VelocityVector,
        neighbor_position: [f32; 3],
        neighbor_velocity: VelocityVector,
        detection_time: u64,
    ) -> Option<CollisionVector> {
        // 简化碰撞检测算法
        let distance = Self::calculate_distance(self_position, neighbor_position);
        let relative_velocity = Self::calculate_relative_velocity(self_velocity, neighbor_velocity);
        
        // 如果距离过近且相对速度指向对方
        if distance < 10.0 && relative_velocity > 5.0 {
            let time_to_collision = distance / relative_velocity;
            let predicted_collision_time = detection_time + (time_to_collision * 1_000_000_000.0) as u64;
            
            if time_to_collision < 1.0 { // 1秒内可能碰撞
                let collision_vector = CollisionVector {
                    detection_time,
                    predicted_collision_time,
                    collision_point: Self::calculate_midpoint(self_position, neighbor_position),
                    relative_velocity,
                    avoidance_vector: self.calculate_avoidance_vector(self_position, neighbor_position),
                    priority_level: self.calculate_priority_level(time_to_collision, relative_velocity),
                };
                
                // 添加到碰撞缓冲区
                let mut buffer = self.collision_buffer.lock().unwrap();
                buffer.push(collision_vector.clone());
                
                self.last_detection_time = Instant::now();
                return Some(collision_vector);
            }
        }
        
        None
    }
    
    /// 获取规避策略
    pub fn get_avoidance_strategy(&self, priority: u8) -> Option<&AvoidanceStrategy> {
        self.avoidance_strategies.get(&priority)
    }
    
    /// 处理安全中断
    pub fn handle_safety_interrupt(&self, collision_vector: &CollisionVector) -> Result<[f32; 3], String> {
        let start_time = Instant::now();
        
        // 获取规避策略
        let strategy = match self.get_avoidance_strategy(collision_vector.priority_level) {
            Some(s) => s,
            None => return Err("无对应规避策略".to_string()),
        };
        
        // 检查响应时间
        let elapsed = start_time.elapsed();
        let elapsed_us = elapsed.as_micros() as u64;
        
        if elapsed_us > SAFETY_INTERRUPT_MAX_US {
            return Err(format!("安全中断响应超时: {}µs > {}µs", 
                elapsed_us, SAFETY_INTERRUPT_MAX_US));
        }
        
        // 返回规避向量
        Ok(strategy.adjustment_vector)
    }
    
    // 辅助方法
    fn calculate_distance(a: [f32; 3], b: [f32; 3]) -> f32 {
        let dx = a[0] - b[0];
        let dy = a[1] - b[1];
        let dz = a[2] - b[2];
        (dx * dx + dy * dy + dz * dz).sqrt()
    }
    
    fn calculate_relative_velocity(self_v: VelocityVector, neighbor_v: VelocityVector) -> f32 {
        let dx = self_v.x - neighbor_v.x;
        let dy = self_v.y - neighbor_v.y;
        let dz = self_v.z - neighbor_v.z;
        (dx * dx + dy * dy + dz * dz).sqrt()
    }
    
    fn calculate_midpoint(a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
        [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0, (a[2] + b[2]) / 2.0]
    }
    
    fn calculate_avoidance_vector(&self, self_pos: [f32; 3], neighbor_pos: [f32; 3]) -> [f32; 3] {
        // 简化示例：向侧方规避
        let dx = neighbor_pos[0] - self_pos[0];
        let dy = neighbor_pos[1] - self_pos[1];
        
        // 计算垂直于连线的向量
        [-dy, dx, 0.0]
    }
    
    fn calculate_priority_level(&self, time_to_collision: f32, relative_velocity: f32) -> u8 {
        // 根据碰撞时间和相对速度计算优先级
        if time_to_collision < 0.1 && relative_velocity > 20.0 {
            255 // 最高优先级
        } else if time_to_collision < 0.5 && relative_velocity > 10.0 {
            200 // 高优先级
        } else {
            100 // 标准优先级
        }
    }
}

// 6. 主 SASCAR 引擎

/// 主 SASCAR 引擎
pub struct SascarEngine {
    kinetic_sync: KineticSyncEngine,
    path_auction: PathAuctionEngine,
    collision_avoidance: CollisionAvoidanceSystem,
    node_id: [u8; 32],
    is_active: bool,
}

impl SascarEngine {
    pub fn new(node_id: [u8; 32]) -> Self {
        Self {
            kinetic_sync: KineticSyncEngine::new(),
            path_auction: PathAuctionEngine::new(),
            collision_avoidance: CollisionAvoidanceSystem::new(),
            node_id,
            is_active: true,
        }
    }
    
    /// 主循环 (每833µs执行一次)
    pub fn main_loop(&mut self) -> Result<(), String> {
        if !self.is_active {
            return Err("引擎未激活".to_string());
        }
        
        // 1. 生成并广播运动脉冲
        let pulse = self.kinetic_sync.generate_mobility_pulse(self.node_id);
        
        // 2. 处理收到的邻居脉冲 (简化示例)
        // 在实际实现中，这里会从网络接收脉冲
        
        // 3. 计算协同调整
        if let Some(adjustment) = self.kinetic_sync.calculate_cooperative_adjustment() {
            // 应用调整到本地状态
            // self.apply_motion_adjustment(adjustment);
        }
        
        // 4. 检查碰撞风险 (简化示例)
        // 在实际实现中，这里会基于邻居位置进行检测
        
        // 5. 更新本地运动状态
        self.update_local_state();
        
        Ok(())
    }
    
    /// 请求路径清算
    pub fn request_path_clearing(
        &mut self,
        trajectory: Vec<[f32; 3]>,
        clearance_radius: f32,
        bid_per_meter: u64,
        urgency: u8,
    ) -> Result<u128, String> {
        let request = PathClearingRequest {
            request_id: rand::random::<u128>(),
            requester_id: self.node_id,
            target_trajectory: trajectory,
            clearance_radius,
            bid_per_meter,
            urgency_level: urgency,
            iqa_seal: None, // 简化示例
            expiration_time: 0, // 简化示例
        };
        
        self.path_auction.initiate_path_clearing(request)
    }
    
    /// 处理碰撞检测
    pub fn handle_collision_detection(
        &mut self,
        self_position: [f32; 3],
        self_velocity: VelocityVector,
        neighbor_position: [f32; 3],
        neighbor_velocity: VelocityVector,
    ) -> Result<Option<[f32; 3]>, String> {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        
        if let Some(collision_vector) = self.collision_avoidance.detect_collision_risk(
            self_position,
            self_velocity,
            neighbor_position,
            neighbor_velocity,
            now,
        ) {
            // 处理安全中断
            match self.collision_avoidance.handle_safety_interrupt(&collision_vector) {
                Ok(avoidance_vector) => Ok(Some(avoidance_vector)),
                Err(e) => Err(e),
            }
        } else {
            Ok(None)
        }
    }
    
    fn update_local_state(&mut self) {
        // 简化示例：更新本地状态
        // 在实际实现中，这里会基于传感器数据更新位置和速度
    }
}

// 7. 单元测试
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_kinetic_sync_pulse_generation() {
        let mut engine = KineticSyncEngine::new();
        let node_id = [1u8; 32];
        
        let pulse = engine.generate_mobility_pulse(node_id);
        
        assert_eq!(pulse.node_id, node_id);
        assert!(pulse.timestamp > 0);
    }
    
    #[test]
    fn test_path_auction_lifecycle() {
        let mut engine = PathAuctionEngine::new();
        let node_id = [1u8; 32];
        
        // 创建请求
        let request = PathClearingRequest {
            request_id: 123,
            requester_id: node_id,
            target_trajectory: vec![[0.0, 0.0, 0.0], [100.0, 0.0, 0.0]],
            clearance_radius: 2.0,
            bid_per_meter: 1000,
            urgency_level: 200,
            iqa_seal: None,
            expiration_time: 0,
        };
        
        // 发起拍卖
        let auction_id = engine.initiate_path_clearing(request).unwrap();
        
        // 提交竞价
        let is_highest = engine.submit_bid(auction_id, [2u8; 32], 1500).unwrap();
        assert!(is_highest);
        
        // 另一个竞价
        let is_highest2 = engine.submit_bid(auction_id, [3u8; 32], 1200).unwrap();
        assert!(!is_highest2);
        
        // 结算拍卖 (简化测试，实际需要等待)
        // 注意：这个测试可能会因为超时而失败
        // let record = engine.settle_auction(auction_id);
        // assert!(record.is_ok());
    }
    
    #[test]
    fn test_collision_avoidance_priority() {
        let system = CollisionAvoidanceSystem::new();
        
        // 测试优先级255的策略
        let strategy = system.get_avoidance_strategy(255).unwrap();
        assert_eq!(strategy.priority, 255);
        assert!(strategy.response_time_us <= 100);
        
        // 测试优先级100的策略
        let strategy = system.get_avoidance_strategy(100).unwrap();
        assert_eq!(strategy.priority, 100);
        assert!(strategy.response_time_us <= 300);
    }
    
    #[test]
    fn test_sascar_engine_creation() {
        let node_id = [1u8; 32];
        let engine = SascarEngine::new(node_id);
        
        assert_eq!(engine.node_id, node_id);
        assert!(engine.is_active);
    }
}

// 8. 性能基准测试
#[cfg(test)]
mod benchmarks {
    use super::*;
    use std::time::Instant;
    
    #[test]
    fn benchmark_kinetic_sync_latency() {
        let mut engine = KineticSyncEngine::new();
        let node_id = [1u8; 32];
        
        let start = Instant::now();
        let pulse = engine.generate_mobility_pulse(node_id);
        let elapsed = start.elapsed();
        
        // 检查是否在合理时间内完成
        assert!(elapsed.as_micros() < 50, "运动脉冲生成延迟过大: {}µs", elapsed.as_micros());
    }
    
    #[test]
    fn benchmark_collision_response_time() {
        let system = CollisionAvoidanceSystem::new();
        
        // 创建一个模拟碰撞向量
        let collision_vector = CollisionVector {
            detection_time: 0,
            predicted_collision_time: 100_000_000, // 100ms后
            collision_point: [0.0, 0.0, 0.0],
            relative_velocity: 20.0,
            avoidance_vector: [0.0, -1.0, 0.0],
            priority_level: 255,
        };
        
        let start = Instant::now();
        let result = system.handle_safety_interrupt(&collision_vector);
        let elapsed = start.elapsed();
        
        assert!(result.is_ok(), "安全中断处理失败: {:?}", result.err());
        assert!(elapsed.as_micros() < 300, "安全中断响应时间过大: {}µs", elapsed.as_micros());
    }
}

// 9. 集成示例
fn main() {
    println!("=== RFC-009 SASCAR 实现示例 ===");
    
    // 创建 SASCAR 引擎
    let node_id = [0xAB; 32];
    let mut sascar = SascarEngine::new(node_id);
    
    println!("1. 初始化 SASCAR 引擎 - 节点ID: {:?}", &node_id[0..8]);
    
    // 模拟主循环执行
    println!("2. 执行主循环 (模拟)...");
    match sascar.main_loop() {
        Ok(_) => println!("   主循环执行成功"),
        Err(e) => println!("   主循环执行失败: {}", e),
    }
    
    // 模拟路径清算请求
    println!("3. 发起路径清算请求...");
    match sascar.request_path_clearing(
        vec![[0.0, 0.0, 0.0], [1000.0, 0.0, 0.0]], // 1公里直线路径
        3.0,  // 3米清理半径
        5000, // 每米5000皮克代币
        200,  // 高紧急级别
    ) {
        Ok(auction_id) => println!("   拍卖ID: {}", auction_id),
        Err(e) => println!("   请求失败: {}", e),
    }
    
    // 模拟碰撞检测
    println!("4. 模拟碰撞检测...");
    let self_pos = [0.0, 0.0, 0.0];
    let self_vel = VelocityVector { x: 10.0, y: 0.0, z: 0.0 };
    let neighbor_pos = [5.0, 1.0, 0.0];
    let neighbor_vel = VelocityVector { x: 10.0, y: 0.0, z: 0.0 };
    
    match sascar.handle_collision_detection(self_pos, self_vel, neighbor_pos, neighbor_vel) {
        Ok(Some(avoidance)) => println!("   检测到碰撞风险，规避向量: {:?}", avoidance),
        Ok(None) => println!("   未检测到碰撞风险"),
        Err(e) => println!("   碰撞检测失败: {}", e),
    }
    
    println!("=== 示例完成 ===");
}