// BandwidthProfile 标准化带宽画像结构体
type BandwidthProfile struct {
    AvailableBitrateBps   int64   // 当前可用带宽 (bps), 含 0.85 安全系数
    RTTMs                 int64   // 往返时延
    PacketLossRate        float64 // 丢包率 (0.0 - 1.0)
    LinkCapacityHeadroom  float64 // 链路容量余量比 (如 1.2 表示还有 20% 余量)
    TimestampMs           int64   // 画像生成时间戳
}

def select_optimal_layer(profile: BandwidthProfile, current_sl: int, current_tl: int) -> (int, int):
    candidates = []
    # 1. 遍历所有合法的 (SL, TL) 组合
    for sl in SPATIAL_LAYERS:
        for tl in TEMPORAL_LAYERS[sl]:
            target_bitrate = GET_BITRATE(sl, tl)
            # 2. 硬性约束：目标码率 < 可用带宽 * 安全阈值 (0.9)
            if target_bitrate > profile.AvailableBitrateBps * 0.9: continue
            
            # 3. 计算效用值
            utility = calc_utility(sl, tl, profile, current_sl, current_tl)
            candidates.append((utility, sl, tl))
    
    # 4. 选择效用最大者，若并列优先保持当前空间层(稳定性)
    if not candidates: return FALLBACK_LAYER # 兜底最低层
    return max(candidates, key=lambda x: (x[0], -abs(x[1]-current_sl)))[1:]

// SubscriptionState 订阅状态机
type SubscriptionState struct {
    mu sync.RWMutex
    SubscriberID string
    CurrentSpatialLayer int    // 当前转发的空间层 ID
    CurrentTemporalLayer int   // 当前转发的最高时间层 ID
    TargetSpatialLayer  int    // 调度器计算出的目标空间层
    TargetTemporalLayer int    // 调度器计算出的目标时间层
    RenderWidth, RenderHeight int // 客户端声明的渲染分辨率
    LastSwitchTimeMs int64     // 上次切层时间，用于冷却
    Stats *SubscriberStats     // 实时统计: Jitter, Nack, Pli
}

// 核心接口：应用调度决策
func (s *SubscriptionState) ApplyDecision(targetSL, targetTL int, nowMs int64) bool {
    s.mu.Lock()
    defer s.mu.Unlock()
    
    // 空间层切换冷却保护 (建议 2s-3s)
    if targetSL != s.CurrentSpatialLayer && nowMs - s.LastSwitchTimeMs < SPATIAL_SWITCH_COOLDOWN_MS {
        return false // 拒绝本次空间层切换，仅尝试时间层调整
    }
    
    // 时间层可快速切换 (冷却 200ms)
    if targetTL != s.CurrentTemporalLayer && nowMs - s.LastSwitchTimeMs < TEMPORAL_SWITCH_COOLDOWN_MS {
        targetTL = s.CurrentTemporalLayer // 本轮维持原时间层
    }
    
    s.TargetSpatialLayer = targetSL
    s.TargetTemporalLayer = targetTL
    return true
}

func (s *SFUSession) filterAndForward(pkt *rtp.Packet, sub *SubscriptionState) {
    // 1. 解析视频层信息 (需针对 VP8/VP9/H264/AV1 实现不同 Parser)
    vInfo, err := ParseVideoLayerInfo(pkt)
    if err != nil { return } // 非视频包或解析失败直接丢弃/透传音频
    
    sub.mu.RLock()
    targetSL, targetTL := sub.TargetSpatialLayer, sub.TargetTemporalLayer
    sub.mu.RUnlock()
    
    // 2. 空间层过滤：仅转发目标空间层及以下（Simulcast 通常独立流，仅转发目标流）
    // 注：若为 K-SVC (单流多层)，则需 vInfo.SpatialID <= targetSL
    if vInfo.SpatialID != targetSL { 
        return 
    }
    
    // 3. 时间层过滤：丢弃 TID > targetTL 的包
    // 关键点：必须保留 TL0 (基础层)，否则参考链断裂导致花屏
    if vInfo.TemporalID > targetTL {
        return 
    }
    
    // 4. 关键帧强制转发保护：若包含关键帧起始标记，建议无视时间层限制转发 TL0 部分
    // (实际工程中通常由发送端强制 TL0 为关键帧，此处仅做兜底)
    
    // 5. 重写 SSRC / MID / RID 后转发
    s.rewriteAndSend(pkt, sub)
}

// WebRTC 发送端配置示例
const encodings = [
  { rid: 'h', scaleResolutionDownBy: 1.0, maxBitrate: 2500000, scalabilityMode: 'L1T3' }, // 720p, 3时间层
  { rid: 'm', scaleResolutionDownBy: 2.0, maxBitrate: 800000,  scalabilityMode: 'L1T2' }, // 360p, 2时间层
  { rid: 'l', scaleResolutionDownBy: 4.0, maxBitrate: 250000,  scalabilityMode: 'L1T1' }, // 180p, 1时间层
];

// ParsedLayerInfo 统一视频层元信息
type ParsedLayerInfo struct {
    SpatialID       uint8   // 空间层 ID (0=High, 1=Mid, 2=Low)
    TemporalID      uint8   // 时间层 ID (0=Base, 1, 2...)
    IsKeyFrame      bool    // 是否为关键帧 (可独立解码起点)
    IsFrameStart    bool    // 是否为帧起始包 (用于分片重组边界判断)
    IsFrameEnd      bool    // 是否为帧结束包
    FrameID         uint16  // 帧级唯一 ID (用于乱序/丢包重组)
    LayerSync       bool    // VP9/AV1: Layer Sync 标志 (可作为切换点)
    // AV1 扩展字段
    ScalabilityMode string  // 如 "L3T3_KEY", "L1T3" 等标准化字符串
}

// VideoLayerParser 统一解析接口
type VideoLayerParser interface {
    Parse(pkt *rtp.Packet) (*ParsedLayerInfo, error)
    CodecType() webrtc.RTPCodecType
}

func (p *VP9Parser) Parse(pkt *rtp.Packet) (*ParsedLayerInfo, error) {
    // VP9 Payload Descriptor 变长结构: [I(1) P(1) L(1) F(1) B(1) E(1) V(1) | ...]
    // 参考 RFC 7741 Section 4.2
    payload := pkt.Payload
    if len(payload) < 1 { return nil, ErrPacketTooSmall }
    
    // 1. 解析第一字节固定位
    firstByte := payload[0]
    hasI := (firstByte & 0x80) != 0 // Picture ID present
    hasL := (firstByte & 0x20) != 0 // Layer indices present
    isFlexible := (firstByte & 0x10) != 0 // Flexible mode
    isStart := (firstByte & 0x08) != 0 // Start of frame
    isEnd   := (firstByte & 0x04) != 0 // End of frame
    hasV    := (firstByte & 0x02) != 0 // SSN present (Non-flexible)
    
    offset := 1
    var pid uint16
    if hasI {
        // Picture ID: 8 or 16 bits (M bit)
        pid = uint16(payload[offset])
        if (pid & 0x80) != 0 { // 16 bits
            if len(payload) < offset+2 { return nil, ErrPacketTooSmall }
            pid = (uint16(payload[offset]) << 8) | uint16(payload[offset+1])
            offset += 2
        } else {
            offset += 1
        }
    }
    
    // 2. 解析 Layer Indices (关键：获取 SID/TID)
    var sid, tid uint8 = 0, 0
    if hasL {
        if len(payload) < offset+1 { return nil, ErrPacketTooSmall }
        layerByte := payload[offset]
        offset++
        if isFlexible {
            // Flexible mode: TID(3bits) | SID(3bits) | ... 
            tid = (layerByte >> 5) & 0x07
            sid = (layerByte >> 2) & 0x07
        } else {
            // Non-flexible: TID(3bits) | U(1) | SID(2bits) | D(1) | ...
            tid = (layerByte >> 5) & 0x07
            sid = (layerByte >> 1) & 0x03 // Non-flexible 通常仅支持 2 空间层
        }
    }
    
    // 3. 关键帧判定：VP9 关键帧必须是帧起始(B=1)且 SID=0 且 TID=0
    // 注意：VP9 允许非关键帧也有 B=1 (Layer Sync)，需结合 Frame Type 判断
    // 简化工程判断：IsKeyFrame = isStart && (sid == 0) && (tid == 0) && !isInterFrame(pkt)
    // 更稳健方案：解析 VP9 Uncompressed Header (Frame Header) 中的 frame_type 字段
    
    return &ParsedLayerInfo{
        SpatialID:    sid,
        TemporalID:   tid,
        IsKeyFrame:   isKeyFrame, // 需额外解析 Frame Header 确认
        IsFrameStart: isStart,
        IsFrameEnd:   isEnd,
        FrameID:      pid,
    }, nil
}

// PacketBuffer 复用对象，绑定元数据避免逃逸
type PacketBuffer struct {
    Data   []byte      // 容量固定 1500/2048 (MTU)
    Len    int
    Meta   PacketMeta  // 解析后的层信息、时间戳、SSRC 等，避免二次解析
    RefCnt int32       // 引用计数，支持多订阅者零拷贝共享
}

// 分级池：小包池(100B)、中包池(500B)、大包池(1500B)、巨帧池(64KB for reassembly)
var (
    poolSmall = sync.Pool{New: func() any { return &PacketBuffer{Data: make([]byte, 256)} }}
    poolMTU   = sync.Pool{New: func() any { return &PacketBuffer{Data: make([]byte, 1500)} }}
    poolJumbo = sync.Pool{New: func() any { return &PacketBuffer{Data: make([]byte, 65536)} }}
)

func AcquireBuffer(size int) *PacketBuffer {
    switch {
    case size <= 256: return poolSmall.Get().(*PacketBuffer)
    case size <= 1500: return poolMTU.Get().(*PacketBuffer)
    default: return poolJumbo.Get().(*PacketBuffer)
    }
}

func ReleaseBuffer(b *PacketBuffer) {
    b.Len = 0; b.Meta = PacketMeta{}; b.RefCnt = 0
    switch cap(b.Data) {
    case 256: poolSmall.Put(b)
    case 1500: poolMTU.Put(b)
    default: poolJumbo.Put(b)
    }
}

// Dispatcher 核心分发逻辑 (单协程驱动多订阅者，无锁)
func (d *Dispatcher) Run(ctx context.Context) {
    // 订阅者 Ring Buffer 预分配
    subRings := make(map[string]*ringbuffer.RingBuffer) 
    
    for {
        select {
        case <-ctx.Done(): return
        case pktBuf := <-d.parseOutputChan: // 来自解析阶段
            // 1. 快速路径：广播型转发 (如全员订阅同层)
            if pktBuf.Meta.IsBroadcastLayer {
                d.broadcastToAll(pktBuf)
                continue
            }
            
            // 2. 精准路径：按订阅状态分发
            // 遍历该流的活跃订阅者 (通常 < 50 人/流)
            for _, sub := range d.getActiveSubscribers(pktBuf.Meta.SSRC) {
                // 零拷贝：增加引用计数，指针入 Ring
                atomic.AddInt32(&pktBuf.RefCnt, 1)
                // 非阻塞写入，Ring 满即丢包 (触发 NACK/PLI 机制)
                if !sub.TxRing.TryPush(pktBuf) {
                    atomic.AddInt32(&pktBuf.RefCnt, -1)
                    sub.Stats.DropCount++
                }
            }
            // 3. 释放原始持有引用
            if atomic.AddInt32(&pktBuf.RefCnt, -1) == 0 {
                ReleaseBuffer(pktBuf)
            }
        }
    }
}