第 10 章：深入 TQUIC——腾讯的多路径 QUIC 引擎

// MultipathScheduler trait（简化自 TQUIC 源码）
pub trait MultipathScheduler: Send + Sync {
    /// 选择下一个要发送数据的路径
    /// 
    /// 参数：
    /// - paths: 所有可用路径的信息
    /// - frame: 要发送的数据帧信息
    ///
    /// 返回：选中的路径 ID，或 None（所有路径都不可用）
    fn on_select_path(
        &mut self,
        paths: &PathMap,
        frame: &FrameInfo,
    ) -> Option<PathId>;
    
    /// 当路径状态变化时通知调度器
    fn on_path_updated(&mut self, path_id: PathId, event: PathEvent);
    
    /// 当数据被确认时通知调度器
    fn on_ack(&mut self, path_id: PathId, acked_bytes: usize);
    
    /// 当数据丢失时通知调度器  
    fn on_loss(&mut self, path_id: PathId, lost_bytes: usize);
}

// MinRtt：选择 RTT 最小的路径
// 适用场景：延迟敏感（游戏、音视频）
pub struct MinRttScheduler;

impl MultipathScheduler for MinRttScheduler {
    fn on_select_path(
        &mut self,
        paths: &PathMap,
        _frame: &FrameInfo,
    ) -> Option<PathId> {
        paths.iter()
            .filter(|p| p.is_active() && p.can_send())
            .min_by_key(|p| p.rtt())     // ← 选 RTT 最小的
            .map(|p| p.id())
    }
}

// 工作原理：
// 
//   Path 0 (WiFi):  RTT = 20ms, 可用 ✓  ← 选这条！
//   Path 1 (4G):    RTT = 80ms, 可用 ✓
//   Path 2 (5G):    RTT = 10ms, 不可用 ✗（窗口满了）
//
// 每次要发数据时：看看谁最快且还能发 → 选它
// 
// 优点：延迟最优
// 缺点：可能让快路径过载，慢路径闲置

// Redundant：在所有可用路径上发送同样的数据
// 适用场景：可靠性极高要求（关键控制消息）
pub struct RedundantScheduler;

impl MultipathScheduler for RedundantScheduler {
    fn on_select_path(
        &mut self,
        paths: &PathMap,
        _frame: &FrameInfo,
    ) -> Option<PathId> {
        // 返回所有可用路径（实际实现中会发送到每条路径）
        // 简化：这里返回第一条，但会标记"需要冗余"
        paths.iter()
            .filter(|p| p.is_active() && p.can_send())
            .next()
            .map(|p| p.id())
    }
    
    fn should_replicate(&self) -> bool {
        true  // 标记：数据需要在所有路径上复制
    }
}

// 工作原理：
//
//   要发送数据 "Hello"
//   Path 0 (WiFi): 发送 "Hello"  ←
//   Path 1 (4G):   发送 "Hello"  ←  同样的数据！
//
//   收端：谁先到用谁，重复的丢弃
//
// 优点：只要有一条路通，数据就能到达
// 缺点：带宽利用率低（每条路都在传相同数据）
// 适合：小数据量但极高可靠性（如游戏的操作指令）

// RoundRobin：轮流在各路径上发送
// 适用场景：带宽最大化（大文件下载）
pub struct RoundRobinScheduler {
    next_path_index: usize,
}

impl MultipathScheduler for RoundRobinScheduler {
    fn on_select_path(
        &mut self,
        paths: &PathMap,
        _frame: &FrameInfo,
    ) -> Option<PathId> {
        let active_paths: Vec<_> = paths.iter()
            .filter(|p| p.is_active() && p.can_send())
            .collect();
        
        if active_paths.is_empty() {
            return None;
        }
        
        // 轮流选择
        let selected = &active_paths[self.next_path_index % active_paths.len()];
        self.next_path_index += 1;
        Some(selected.id())
    }
}

// 工作原理：
//
//   数据块 1 → Path 0 (WiFi)
//   数据块 2 → Path 1 (4G)
//   数据块 3 → Path 0 (WiFi)
//   数据块 4 → Path 1 (4G)
//   ...
//
// 优点：简单，带宽利用率高
// 缺点：如果两条路 RTT 差异大，接收端需要等慢路径的数据
//       → 导致"头部阻塞"（快路径的数据到了但要等慢路径的才能交付）

// PathMap 管理所有路径（简化）
pub struct PathMap {
    /// 所有路径
    paths: Vec<Path>,
    /// 当前活跃路径的数量
    active_count: usize,
    /// 主路径 ID
    primary_path: PathId,
}

// 单条路径的完整信息
pub struct Path {
    /// 路径唯一标识
    id: PathId,
    /// 四元组（本地地址:端口 + 远端地址:端口）
    local_addr: SocketAddr,
    remote_addr: SocketAddr,
    /// 路径状态
    state: PathState,
    /// RTT 估计器
    rtt_estimator: RttEstimator,
    /// 独立的拥塞控制器
    congestion_controller: Box<dyn CongestionController>,
    /// 独立的丢包恢复
    recovery: Recovery,
    /// 路径 MTU
    mtu: u16,
    /// 路径验证 token
    validation: PathValidation,
    /// 统计信息
    stats: PathStats,
}

#[derive(Clone, Copy)]
pub enum PathState {
    /// 新创建，未验证
    New,
    /// 正在验证（PATH_CHALLENGE 已发）
    Validating,
    /// 已验证，可用
    Active,
    /// 暂时不可用（例如检测到严重丢包）
    Degraded,
    /// 已关闭
    Closed,
}

impl PathMap {
    /// 添加新路径
    pub fn add_path(&mut self, local: SocketAddr, remote: SocketAddr, 
                    cc: Box<dyn CongestionController>) -> PathId {
        let id = PathId(self.paths.len());
        self.paths.push(Path {
            id,
            local_addr: local,
            remote_addr: remote,
            state: PathState::New,
            rtt_estimator: RttEstimator::new(),
            congestion_controller: cc,
            recovery: Recovery::new(),
            mtu: 1200,  // 初始 MTU
            validation: PathValidation::new(),
            stats: PathStats::default(),
        });
        // 自动发起路径验证
        self.initiate_validation(id);
        id
    }
    
    /// 获取所有活跃路径
    pub fn active_paths(&self) -> impl Iterator<Item = &Path> {
        self.paths.iter().filter(|p| p.state == PathState::Active)
    }
    
    /// 路径上报丢包
    pub fn on_path_loss(&mut self, path_id: PathId, lost_bytes: usize) {
        let path = &mut self.paths[path_id.0];
        path.congestion_controller.on_loss(lost_bytes, Instant::now());
        path.stats.bytes_lost += lost_bytes as u64;
        
        // 如果丢包率过高，标记路径为降级
        if path.stats.loss_rate() > 0.30 {
            path.state = PathState::Degraded;
            self.active_count -= 1;
        }
    }
}

// 每条路径创建时选择自己的拥塞控制算法
fn create_path_with_cc(
    local: SocketAddr, 
    remote: SocketAddr,
    cc_algorithm: CcAlgorithm
) -> Path {
    let cc: Box<dyn CongestionController> = match cc_algorithm {
        CcAlgorithm::Cubic => Box::new(CubicController::new()),
        CcAlgorithm::Bbr => Box::new(BbrController::new()),
        CcAlgorithm::Bbr3 => Box::new(Bbr3Controller::new()),
        CcAlgorithm::Copa => Box::new(CopaController::new()),
    };
    
    Path {
        congestion_controller: cc,
        // ...
    }
}

// 甚至可以每条路径用不同的算法！
// 例如：WiFi 路径用 BBR（带宽探测好），4G 路径用 CUBIC（公平性好）

// 每条路径独立的丢包恢复
pub struct Recovery {
    /// 已发送但未确认的包
    sent_packets: BTreeMap<PacketNumber, SentPacket>,
    /// PTO 超时计算
    pto_count: u32,
    /// 最大 ACK 的包号
    largest_acked: Option<PacketNumber>,
    /// 丢包检测阈值
    loss_threshold: Duration,
}

impl Recovery {
    /// 在特定路径上检测丢包
    pub fn detect_lost_packets(&mut self, now: Instant) -> Vec<LostPacket> {
        let mut lost = Vec::new();
        
        if let Some(largest_acked) = self.largest_acked {
            for (pn, pkt) in self.sent_packets.iter() {
                // 时间阈值：超过 loss_threshold 没被 ACK → 丢了
                if now - pkt.time_sent > self.loss_threshold {
                    lost.push(LostPacket { pn: *pn, bytes: pkt.size });
                }
                // 包号阈值：比最大 ACK 小 3 个以上 → 丢了
                if largest_acked - *pn > 3 {
                    lost.push(LostPacket { pn: *pn, bytes: pkt.size });
                }
            }
        }
        
        lost
    }
}

// TQUIC 的 API 风格（简化）
let mut conn = Connection::new(config)?;

// 应用的 I/O 循环
loop {
    // 1. 从 socket 读取数据，喂给 TQUIC
    let (len, from) = socket.recv_from(&mut buf)?;
    conn.recv(&mut buf[..len], RecvInfo { from })?;
    
    // 2. 处理应用层事件
    for event in conn.events() {
        match event {
            Event::StreamReadable { stream_id } => {
                let mut data = vec![0u8; 4096];
                let len = conn.stream_recv(stream_id, &mut data)?;
                // 处理收到的流数据
            }
            Event::StreamWritable { stream_id } => {
                conn.stream_send(stream_id, b"response", false)?;
            }
            Event::Connected => {
                println!("Connected!");
            }
            _ => {}
        }
    }
    
    // 3. 从 TQUIC 获取要发送的数据
    loop {
        let (len, send_info) = match conn.send(&mut out) {
            Ok(v) => v,
            Err(Error::Done) => break,
            Err(e) => return Err(e),
        };
        socket.send_to(&out[..len], send_info.to)?;
    }
    
    // 4. 处理超时
    if let Some(timeout) = conn.timeout() {
        // 设置定时器
    }
}

// 示例：带权重的自适应调度器
pub struct AdaptiveScheduler {
    /// 每条路径的权重（基于估计带宽）
    weights: HashMap<PathId, f64>,
    /// 累计未发送字节
    pending: usize,
}

impl MultipathScheduler for AdaptiveScheduler {
    fn on_select_path(
        &mut self,
        paths: &PathMap,
        frame: &FrameInfo,
    ) -> Option<PathId> {
        // 策略：根据每条路径的可用带宽分配权重
        let active: Vec<_> = paths.active_paths().collect();
        if active.is_empty() {
            return None;
        }
        
        // 计算每条路径的"得分"
        // 得分 = 估计带宽 / (RTT * (1 + loss_rate))
        let scores: Vec<(PathId, f64)> = active.iter()
            .map(|p| {
                let bw = p.estimated_bandwidth();
                let rtt = p.rtt().as_secs_f64();
                let loss = p.loss_rate();
                let score = bw / (rtt * (1.0 + loss));
                (p.id(), score)
            })
            .collect();
        
        // 选得分最高的路径
        scores.into_iter()
            .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
            .map(|(id, _)| id)
    }
    
    fn on_path_updated(&mut self, path_id: PathId, event: PathEvent) {
        match event {
            PathEvent::RttUpdated(new_rtt) => {
                // 路径 RTT 变化 → 重新计算权重
            }
            PathEvent::CongestionEvent => {
                // 路径拥塞 → 降低权重
            }
            _ => {}
        }
    }
}