//! RTP 解包器（Depacketizer）
//!
//! 将 RTP 包还原为完整的音视频帧：
//! - **H.264 FU-A 重组**：将多个 FU-A 分片重新拼接为原始 NALU
//! - **SPS/PPS 检测**：从 NALU 类型中识别 SPS(7)、PPS(8)，合并为 sequence header 帧
//! - **帧分类**：IDR(5) → 关键帧，non-IDR(1) → P 帧
//! - **AAC 解包**：跳过 AU-headers-length + AU-header，提取原始 AAC 数据
//!
//! 输出的 AVFrame.data 采用 FLV/AVCC 格式，与引擎其余部分兼容。

use std::sync::Arc;

use crate::codec::h264::{encode_avcc_sequence_header, nal_unit_type, nal_type};
use crate::sdk::types::{AudioCodec, AVFrame, CodecExtraInfo, FrameType, H264SeqHeader, VideoCodec};

use super::rtp::RtpPacket;

// ── NALU 类型常量 ──────────────────────────────────────────

/// FU-A（Fragmentation Unit）NALU 类型
const NALU_TYPE_FU_A: u8 = 28;

// ── FU-A 重组器 ────────────────────────────────────────────

/// FU-A 分片重组器
///
/// 当一个 NALU 被拆分为多个 RTP 包（FU-A 分片）时，
/// 逐包积累负载数据，在最后一个分片（end bit = 1）到达时
/// 输出完整的 NALU。
struct FuAssembler {
    /// 原始 NALU 头部（由 FU indicator 的高 3 位 + FU header 的低 5 位重建）
    nalu_header: u8,
    /// 累积的 NALU 数据（nalu_header + 各分片负载）
    buffer: Vec<u8>,
    /// 是否正在重组中（收到 start bit 后为 true）
    active: bool,
}

impl FuAssembler {
    /// 创建空的重组器
    fn new() -> Self {
        Self {
            nalu_header: 0,
            buffer: Vec::new(),
            active: false,
        }
    }

    /// 重置重组状态（新 FU-A 序列开始前调用）
    fn reset(&mut self) {
        self.nalu_header = 0;
        self.buffer.clear();
        self.active = false;
    }
}

// ── RTP 视频解包器 ─────────────────────────────────────────

/// RTP 视频解包器
///
/// 维护 FU-A 重组状态和 SPS/PPS 缓存，
/// 将 RTP 包流转换为引擎内部使用的 AVFrame。
///
/// 每个 RTSP 推流会话（Recording 模式）对应一个实例。
pub struct RtpDepacketizer {
    /// FU-A 重组器
    fu_assembler: FuAssembler,
    /// 缓存最近收到的 SPS NALU（不含起始码）
    pending_sps: Option<Vec<u8>>,
    /// 缓存最近收到的 PPS NALU（不含起始码）
    pending_pps: Option<Vec<u8>>,
    /// 标记是否已向引擎发送过 sequence header
    seq_header_emitted: bool,
    /// 上一个视频帧的 RTP 时间戳（检测时间戳跳变以判断新帧）
    last_video_timestamp: u32,
    /// 当前访问单元（Access Unit）中累积的 NALU 列表
    ///
    /// H.264 一帧画面可能包含多个 NALU（如多 slice），
    /// 它们共享相同的 RTP 时间戳，需要合并为一个 AVFrame。
    pending_nalus: Vec<Vec<u8>>,
    /// 当前累积 NALU 的 RTP 时间戳
    pending_timestamp: u32,
    /// 时间戳归一化基准：首个视频帧的 RTP 时间戳
    /// RTP 时间戳从随机值开始，转换为毫秒后可能超过 RTMP 扩展时间戳阈值 (0xFFFFFF)，
    /// 导致 ffmpeg 解析失败。记录首个帧的 RTP 时间戳，后续帧减去此基准值。
    video_ts_base: Option<u32>,
}

impl RtpDepacketizer {
    /// 创建新的视频解包器
    pub fn new() -> Self {
        Self {
            fu_assembler: FuAssembler::new(),
            pending_sps: None,
            pending_pps: None,
            seq_header_emitted: false,
            last_video_timestamp: 0,
            pending_nalus: Vec::new(),
            pending_timestamp: 0,
            video_ts_base: None,
        }
    }

    /// 从 SDP sprop-parameter-sets 预设 SPS/PPS
    ///
    /// 当推流端在 SDP 中声明了 SPS/PPS 但不在 RTP 中发送时，
    /// 通过此方法预设到解包器中，避免重复发送 seq_header。
    pub fn set_sps_pps(&mut self, sps: Vec<u8>, pps: Vec<u8>) {
        self.pending_sps = Some(sps);
        self.pending_pps = Some(pps);
        self.seq_header_emitted = false;
        // 预设 SPS/PPS 时重置累积状态，避免残留数据
        self.pending_nalus.clear();
        self.pending_timestamp = 0;
    }

    /// 输入一个 RTP 包，返回零个或多个完整的 AVFrame
    ///
    /// 对于 FU-A 分片，中间包返回空；最后一个分片返回完整的帧。
    /// 单个 NALU 包立即返回对应帧。
    ///
    /// # 参数
    /// - `rtp` — 已解析的 RTP 包
    ///
    /// # 返回
    /// 完整的 AVFrame 列表（可能为空）
    pub fn push_rtp(&mut self, rtp: &RtpPacket) -> Vec<AVFrame> {
        let payload = &rtp.payload;
        if payload.is_empty() {
            return Vec::new();
        }

        let first_byte = payload[0];
        let ntype = nal_unit_type(first_byte);

        if ntype == NALU_TYPE_FU_A {
            // FU-A 分片模式：重组
            self.handle_fu_a(rtp)
        } else {
            // 单 NALU 模式：直接处理
            let nalu = payload.clone();
            self.emit_nalu(&nalu, rtp.timestamp, rtp.marker)
        }
    }

    /// 处理 FU-A 分片
    ///
    /// 根据 FU header 的 start/end bit 累积或输出 NALU。
    fn handle_fu_a(&mut self, rtp: &RtpPacket) -> Vec<AVFrame> {
        let payload = &rtp.payload;
        if payload.len() < 2 {
            return Vec::new();
        }

        // FU indicator: forbidden(1)=0 | NRI(2) | Type(5)=28
        let fu_indicator = payload[0];
        // FU header: Start(1) | End(1) | Reserved(1) | Type(5)
        let fu_header = payload[1];

        let start = (fu_header & 0x80) != 0;
        let end = (fu_header & 0x40) != 0;

        if start {
            // 新的 FU-A 序列开始
            self.fu_assembler.reset();
            // 重建原始 NALU 头部：NRI 来自 FU indicator，Type 来自 FU header
            let nri = fu_indicator & 0x60;
            let nalu_type = fu_header & 0x1F;
            self.fu_assembler.nalu_header = nri | nalu_type;
            self.fu_assembler.buffer = vec![self.fu_assembler.nalu_header];
            // 附加第一个分片的负载（跳过 FU indicator + FU header = 2 字节）
            if payload.len() > 2 {
                self.fu_assembler.buffer.extend_from_slice(&payload[2..]);
            }
            self.fu_assembler.active = true;
        } else if self.fu_assembler.active {
            // 中间或最后分片：追加负载
            if payload.len() > 2 {
                self.fu_assembler.buffer.extend_from_slice(&payload[2..]);
            }
        } else {
            // 未收到 start 就收到中间/末尾分片，丢弃
            return Vec::new();
        }

        if end && self.fu_assembler.active {
            // 最后一个分片：输出完整 NALU
            let nalu = std::mem::take(&mut self.fu_assembler.buffer);
            self.fu_assembler.reset();
            self.emit_nalu(&nalu, rtp.timestamp, rtp.marker)
        } else {
            Vec::new()
        }
    }

    /// 将一个完整 NALU 转换为一个或多个 AVFrame
    ///
    /// 多 NALU 合并策略：
    /// - IDR(5) 和 non-IDR(1) NALU 会被累积到 `pending_nalus` 中
    /// - 当 RTP 时间戳跳变或 marker=true 时，将所有累积的 NALU 合并为一帧输出
    /// - SPS(7)/PPS(8) 到达时，先刷新已累积的 NALU，再缓存 SPS/PPS
    ///
    /// 这样可以正确处理多 slice 编码的 H.264 码流，
    /// 避免每个 NALU 单独输出导致拉流端解码错误（如 cabac_init_idc overflow）。
    fn emit_nalu(&mut self, nalu: &[u8], rtp_timestamp: u32, marker: bool) -> Vec<AVFrame> {
        if nalu.is_empty() {
            return Vec::new();
        }

        let ntype = nal_unit_type(nalu[0]);
        // 归一化 RTP 时间戳：减去首个帧的基准值，避免毫秒时间戳超过 RTMP 扩展阈值
        let norm_ts = self.normalize_video_ts(rtp_timestamp);
        let timestamp_ms = norm_ts as u64 / 90;
        let mut frames = Vec::new();

        match ntype {
            nal_type::SPS => {
                // SPS 到达意味着新的访问单元开始，先刷新已累积的 NALU
                if let Some(f) = self.flush() {
                    frames.push(f);
                }
                self.pending_sps = Some(nalu.to_vec());
                self.seq_header_emitted = false;
            }
            nal_type::PPS => {
                // PPS 同理，先刷新已累积的 NALU
                if let Some(f) = self.flush() {
                    frames.push(f);
                }
                self.pending_pps = Some(nalu.to_vec());
                self.seq_header_emitted = false;
            }
            nal_type::IDR | nal_type::NON_IDR => {
                // 检测时间戳跳变：如果新 NALU 的时间戳与累积的不同，
                // 说明这是新的访问单元，需要先输出之前的帧
                if rtp_timestamp != self.pending_timestamp && !self.pending_nalus.is_empty() {
                    let old_nalus = std::mem::take(&mut self.pending_nalus);
                    let old_timestamp_ms = self.pending_timestamp as u64 / 90;
                    let old_is_keyframe =
                        old_nalus.iter().any(|n| nal_unit_type(n[0]) == nal_type::IDR);

                    // 如果 seq_header 尚未发送，先发送
                    if !self.seq_header_emitted {
                        if let (Some(sps), Some(pps)) = (&self.pending_sps, &self.pending_pps) {
                            if let Some(sh_frame) =
                                self.build_seq_header_frame(sps, pps, old_timestamp_ms)
                            {
                                frames.push(sh_frame);
                                self.seq_header_emitted = true;
                            }
                        }
                    }

                    if let Some(f) =
                        self.build_video_frame_multi(&old_nalus, old_timestamp_ms, old_is_keyframe)
                    {
                        frames.push(f);
                    }
                }

                // 如果是 IDR 且是访问单元的第一个 NALU，发送 seq_header
                if ntype == nal_type::IDR
                    && self.pending_nalus.is_empty()
                    && !self.seq_header_emitted
                {
                    if let (Some(sps), Some(pps)) = (&self.pending_sps, &self.pending_pps) {
                        if let Some(sh_frame) = self.build_seq_header_frame(sps, pps, timestamp_ms)
                        {
                            frames.push(sh_frame);
                            self.seq_header_emitted = true;
                        }
                    }
                }

                // 累积当前 NALU
                self.pending_nalus.push(nalu.to_vec());
                self.pending_timestamp = rtp_timestamp;

                // marker=true 表示 RTP 包是访问单元的最后一个包，输出合并帧
                if marker {
                    let nalus = std::mem::take(&mut self.pending_nalus);
                    let is_keyframe = nalus.iter().any(|n| nal_unit_type(n[0]) == nal_type::IDR);
                    if let Some(f) = self.build_video_frame_multi(&nalus, timestamp_ms, is_keyframe)
                    {
                        frames.push(f);
                    }
                    self.pending_timestamp = 0;
                }
            }
            // 其他 NALU 类型（SEI 等）暂时忽略
            _ => {}
        }

        self.last_video_timestamp = rtp_timestamp;
        frames
    }

    /// 构建 sequence header 帧（FLV/AVCC 格式）
    ///
    /// 格式：
    /// ```text
    /// byte[0] = 0x17  (keyframe + H264)
    /// byte[1] = 0x00  (AVC sequence header)
    /// byte[2..4] = 0x00 0x00 0x00  (CTTS)
    /// byte[5..] = AVCDecoderConfigurationRecord
    /// ```
    fn build_seq_header_frame(
        &self,
        sps: &[u8],
        pps: &[u8],
        timestamp_ms: u64,
    ) -> Option<AVFrame> {
        let avcc_record = encode_avcc_sequence_header(sps, pps);

        let mut data = Vec::with_capacity(5 + avcc_record.len());
        data.push(0x17); // keyframe + H.264
        data.push(0x00); // AVC sequence header
        data.push(0x00); // CTTS 3 bytes
        data.push(0x00);
        data.push(0x00);
        data.extend_from_slice(&avcc_record);

        let mut frame = AVFrame::new_video(
            timestamp_ms,
            Arc::new(data),
            VideoCodec::H264,
            FrameType::KeyFrame,
        );
        frame.codec_info = Some(CodecExtraInfo::H264SeqHeader(H264SeqHeader {
            sps: Arc::new(sps.to_vec()),
            pps: Arc::new(pps.to_vec()),
        }));
        Some(frame)
    }

    /// 构建多 NALU 视频帧（FLV/AVCC 格式）
    ///
    /// 当一个 H.264 访问单元包含多个 NALU（如多 slice 编码）时，
    /// 将所有 NALU 合并到同一个 AVCC 帧中。
    ///
    /// 格式：
    /// ```text
    /// byte[0] = (frame_type << 4) | 0x07
    /// byte[1] = 0x01  (AVC NALU)
    /// byte[2..4] = 0x00 0x00 0x00  (CTTS)
    /// byte[5..] = AVCC: [4-byte BE length + NALU1] [4-byte BE length + NALU2] ...
    /// ```
    fn build_video_frame_multi(
        &self,
        nalus: &[Vec<u8>],
        timestamp_ms: u64,
        is_keyframe: bool,
    ) -> Option<AVFrame> {
        if nalus.is_empty() {
            return None;
        }

        let frame_type_byte = if is_keyframe { 0x17 } else { 0x27 };

        // 预分配空间：5 字节 FLV 头 + 每个 NALU（4 字节长度前缀 + 数据）
        let avcc_total: usize = nalus.iter().map(|n| 4 + n.len()).sum();
        let mut data = Vec::with_capacity(5 + avcc_total);
        data.push(frame_type_byte);
        data.push(0x01); // AVC NALU
        data.push(0x00); // CTTS 3 bytes
        data.push(0x00);
        data.push(0x00);

        // 逐个写入 AVCC 格式的 NALU（4 字节大端长度 + 数据）
        for nalu in nalus {
            let nalu_len = nalu.len() as u32;
            data.extend_from_slice(&nalu_len.to_be_bytes());
            data.extend_from_slice(nalu);
        }

        let frame_type = if is_keyframe {
            FrameType::KeyFrame
        } else {
            FrameType::InterFrame
        };

        Some(AVFrame::new_video(
            timestamp_ms,
            Arc::new(data),
            VideoCodec::H264,
            frame_type,
        ))
    }

    /// 刷新所有累积的 NALU，输出为一个 AVFrame
    ///
    /// 在时间戳跳变、SPS/PPS 到达或流结束时调用，
    /// 确保之前累积的 NALU 不会丢失。
    pub fn flush(&mut self) -> Option<AVFrame> {
        if self.pending_nalus.is_empty() {
            return None;
        }
        let nalus = std::mem::take(&mut self.pending_nalus);
        // 只要包含 IDR NALU 即视为关键帧
        let is_keyframe = nalus.iter().any(|n| nal_unit_type(n[0]) == nal_type::IDR);
        let norm_ts = self.normalize_video_ts(self.pending_timestamp);
        let timestamp_ms = norm_ts as u64 / 90;
        self.pending_timestamp = 0;
        self.build_video_frame_multi(&nalus, timestamp_ms, is_keyframe)
    }

    /// 归一化视频 RTP 时间戳
    ///
    /// RTP 时间戳从随机值开始，直接转换为毫秒可能超过 RTMP 扩展时间戳阈值 (0xFFFFFF = ~4.6 小时)，
    /// 导致 ffmpeg 等客户端在解析 RTMP chunk 时出现 "packet size mismatch" 错误。
    /// 记录首个帧的 RTP 时间戳作为基准，后续帧减去基准值，使毫秒时间戳从 0 开始。
    fn normalize_video_ts(&mut self, rtp_ts: u32) -> u32 {
        if self.video_ts_base.is_none() {
            self.video_ts_base = Some(rtp_ts);
        }
        // 使用 wrapping_sub 处理 RTP 时间戳回绕（32-bit 溢出）
        rtp_ts.wrapping_sub(self.video_ts_base.unwrap())
    }
}

// ── RTP 音频解包器 ─────────────────────────────────────────

/// RTP 音频解包器（AAC-hbr 模式）
///
/// 每个 RTP 包含一个 AAC 帧，负载格式：
/// - AU-headers-length (2 字节，大端，值为 16 表示 1 个 AU header)
/// - AU-header (2 字节)：[size(13 bits) | index(3 bits)]
/// - AAC 帧数据
///
/// 解包后跳过 AU 头部，只提取原始 AAC 数据。
pub fn depacketize_aac(rtp: &RtpPacket) -> Option<AVFrame> {
    let payload = &rtp.payload;
    if payload.len() < 4 {
        return None;
    }

    // AU-headers-length：位数为 16（即 2 字节 = 1 个 AU header）
    let au_headers_len_bits = u16::from_be_bytes([payload[0], payload[1]]);
    let au_headers_bytes = (au_headers_len_bits as usize + 7) / 8;

    // AU-header 中的 size 字段（高 13 位）
    let au_header = u16::from_be_bytes([payload[2], payload[3]]);
    let au_size = (au_header >> 3) as usize;

    // 跳过 AU-headers-length(2) + AU-header 数据
    let header_total = 2 + au_headers_bytes;
    if payload.len() < header_total + au_size {
        // 尝试取剩余所有数据
        if payload.len() > header_total {
            let aac_data = payload[header_total..].to_vec();
            let timestamp_ms = rtp.timestamp as u64 * 1000 / 44100;
            // 封装为 FLV 音频帧格式
            let mut data = Vec::with_capacity(2 + aac_data.len());
            data.push(0xAF); // AAC, 44100Hz, 16bit, stereo
            data.push(0x01); // AAC raw data
            data.extend_from_slice(&aac_data);
            return Some(AVFrame::new_audio(
                timestamp_ms,
                Arc::new(data),
                AudioCodec::Aac,
            ));
        }
        return None;
    }

    let aac_data = payload[header_total..header_total + au_size].to_vec();
    // AAC 采样率 44100 Hz → ms = timestamp * 1000 / 44100
    let timestamp_ms = rtp.timestamp as u64 * 1000 / 44100;

    // 封装为 FLV 音频帧格式：[sound_info, aac_packet_type, aac_data]
    // sound_info: SoundFormat=10(AAC) | SoundRate=3(44100) | SoundSize=1(16bit) | SoundType=1(stereo) = 0xAF
    // aac_packet_type: 0x01 = raw AAC data
    let mut data = Vec::with_capacity(2 + aac_data.len());
    data.push(0xAF); // AAC, 44100Hz, 16bit, stereo
    data.push(0x01); // AAC raw data
    data.extend_from_slice(&aac_data);

    Some(AVFrame::new_audio(
        timestamp_ms,
        Arc::new(data),
        AudioCodec::Aac,
    ))
}

// ════════════════════════════════════════════════════════════
// 测试
// ════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;
    use crate::sdk::types::MediaType;

    /// 辅助：构建 RTP 包
    fn make_rtp(seq: u16, timestamp: u32, marker: bool, payload: Vec<u8>) -> RtpPacket {
        RtpPacket::new(seq, timestamp, 0x12345678, 96, marker, payload)
    }

    /// 辅助：构建 FU-A 分片负载
    ///
    /// - `nri`: NALU ref_idc (2 bits)
    /// - `nalu_type`: 原始 NALU 类型 (5 bits)
    /// - `start`: FU-A start bit
    /// - `end`: FU-A end bit
    /// - `fragment`: 分片负载数据
    fn make_fu_a_payload(nri: u8, nalu_type: u8, start: bool, end: bool, fragment: &[u8]) -> Vec<u8> {
        let fu_indicator = (nri << 5) | NALU_TYPE_FU_A;
        let fu_header = (if start { 0x80 } else { 0 })
            | (if end { 0x40 } else { 0 })
            | (nalu_type & 0x1F);
        let mut payload = vec![fu_indicator, fu_header];
        payload.extend_from_slice(fragment);
        payload
    }

    /// 辅助：构建 AAC-hbr RTP 负载
    fn make_aac_payload(aac_data: &[u8]) -> Vec<u8> {
        let mut payload = Vec::new();
        // AU-headers-length = 16 bits
        payload.extend_from_slice(&16u16.to_be_bytes());
        // AU-header: size(13) | index(3)=0
        let au_header = ((aac_data.len() as u16) << 3) & 0xFFF8;
        payload.extend_from_slice(&au_header.to_be_bytes());
        payload.extend_from_slice(aac_data);
        payload
    }

    // ── FU-A 重组测试 ──────────────────────────────────────

    /// 测试：单个 NALU（非 FU-A）直接输出帧
    #[test]
    fn test_fu_a_single_fragment_emits_nalu() {
        let mut depacketizer = RtpDepacketizer::new();
        // 单个 IDR NALU（type=5, ref_idc=3）
        let nalu = vec![0x65, 0x88, 0x84, 0x00, 0x40];
        let rtp = make_rtp(1, 90000, true, nalu.clone());

        let frames = depacketizer.push_rtp(&rtp);
        // IDR + 未发送过的 seq_header（但无 SPS/PPS，所以只输出 IDR 帧）
        assert!(!frames.is_empty(), "单个 NALU 应输出帧");
        let frame = frames.last().unwrap();
        assert_eq!(frame.media_type, MediaType::Video);
        assert_eq!(frame.frame_type, FrameType::KeyFrame);
        assert_eq!(frame.video_codec, VideoCodec::H264);
        // FLV 格式：0x17 0x01 0x00 0x00 0x00 + AVCC length + NALU
        assert_eq!(frame.data[0], 0x17, "应为 keyframe+H264");
        assert_eq!(frame.data[1], 0x01, "应为 AVC NALU");
    }

    /// 测试：三个 FU-A 分片正确重组
    #[test]
    fn test_fu_a_three_fragments_reassembled_correctly() {
        let mut depacketizer = RtpDepacketizer::new();

        // 模拟一个 IDR NALU (type=5, ref_idc=3) 被拆分为 3 个分片
        let nri = 3; // ref_idc = 3
        let nalu_type = 5; // IDR

        // 第一个分片（start=1, end=0）
        let frag1 = vec![0x88, 0x84];
        let rtp1 = make_rtp(
            1,
            90000,
            false,
            make_fu_a_payload(nri, nalu_type, true, false, &frag1),
        );
        let frames1 = depacketizer.push_rtp(&rtp1);
        assert!(frames1.is_empty(), "第一个分片不应输出帧");

        // 第二个分片（start=0, end=0）
        let frag2 = vec![0x00, 0x40];
        let rtp2 = make_rtp(
            2,
            90000,
            false,
            make_fu_a_payload(nri, nalu_type, false, false, &frag2),
        );
        let frames2 = depacketizer.push_rtp(&rtp2);
        assert!(frames2.is_empty(), "中间分片不应输出帧");

        // 第三个分片（start=0, end=1, marker=1）
        let frag3 = vec![0xAB, 0xCD];
        let rtp3 = make_rtp(
            3,
            90000,
            true,
            make_fu_a_payload(nri, nalu_type, false, true, &frag3),
        );
        let frames3 = depacketizer.push_rtp(&rtp3);
        assert!(!frames3.is_empty(), "最后一个分片应输出帧");

        // 验证重组后的 NALU 数据
        let frame = frames3.last().unwrap();
        assert_eq!(frame.frame_type, FrameType::KeyFrame);
        // FLV 头部 5 字节 + AVCC length 4 字节 + 重组后的 NALU
        let avcc_data = &frame.data[5..];
        // AVCC 长度前缀
        let nalu_len = u32::from_be_bytes([
            avcc_data[0],
            avcc_data[1],
            avcc_data[2],
            avcc_data[3],
        ]) as usize;
        let reassembled = &avcc_data[4..4 + nalu_len];
        // 期望：原始 NALU header (0x65 = nri=3|type=5) + frag1 + frag2 + frag3
        let expected: Vec<u8> = vec![0x65]
            .into_iter()
            .chain(frag1.into_iter())
            .chain(frag2.into_iter())
            .chain(frag3.into_iter())
            .collect();
        assert_eq!(reassembled, expected.as_slice(), "重组数据应匹配原始 NALU");
    }

    /// 测试：SPS + PPS + IDR 正确输出 sequence header 帧
    #[test]
    fn test_sps_pps_emitted_as_seq_header() {
        let mut depacketizer = RtpDepacketizer::new();

        // 发送 SPS（type=7, ref_idc=3 → 0x67）
        let sps = vec![0x67, 0x42, 0xC0, 0x1E, 0xD9, 0x00, 0xA0, 0x47, 0xFE, 0x88];
        let rtp_sps = make_rtp(1, 0, false, sps.clone());
        let frames_sps = depacketizer.push_rtp(&rtp_sps);
        assert!(frames_sps.is_empty(), "SPS 单独不应输出帧");

        // 发送 PPS（type=8, ref_idc=3 → 0x68）
        let pps = vec![0x68, 0xCE, 0x38, 0x80];
        let rtp_pps = make_rtp(2, 0, false, pps.clone());
        let frames_pps = depacketizer.push_rtp(&rtp_pps);
        assert!(frames_pps.is_empty(), "PPS 单独不应输出帧");

        // 发送 IDR（type=5, ref_idc=3 → 0x65）
        let idr = vec![0x65, 0x88, 0x84, 0x00, 0x40];
        let rtp_idr = make_rtp(3, 90000, true, idr);
        let frames = depacketizer.push_rtp(&rtp_idr);

        // 应输出 2 个帧：seq_header + IDR
        assert_eq!(frames.len(), 2, "应输出 seq_header 和 IDR 两个帧");

        // 验证 seq_header 帧
        let sh_frame = &frames[0];
        assert_eq!(sh_frame.data[0], 0x17, "seq_header 应为 keyframe+H264");
        assert_eq!(sh_frame.data[1], 0x00, "seq_header 应为 AVC seq header");
        assert!(sh_frame.is_seq_header(), "应有 codec_info");
        assert!(sh_frame.is_keyframe());

        // 验证 IDR 帧
        let idr_frame = &frames[1];
        assert_eq!(idr_frame.data[0], 0x17, "IDR 应为 keyframe+H264");
        assert_eq!(idr_frame.data[1], 0x01, "IDR 应为 AVC NALU");
        assert_eq!(idr_frame.frame_type, FrameType::KeyFrame);
    }

    /// 测试：IDR 关键帧正确分类
    #[test]
    fn test_idr_emitted_as_keyframe() {
        let mut depacketizer = RtpDepacketizer::new();
        let idr = vec![0x65, 0x88, 0x84, 0x00, 0x40];
        let rtp = make_rtp(1, 90000, true, idr);
        let frames = depacketizer.push_rtp(&rtp);

        assert!(!frames.is_empty());
        let frame = frames.last().unwrap();
        assert_eq!(frame.frame_type, FrameType::KeyFrame);
        assert_eq!(frame.data[0], 0x17);
    }

    /// 测试：non-IDR P 帧正确分类
    #[test]
    fn test_pframe_emitted_as_interframe() {
        let mut depacketizer = RtpDepacketizer::new();
        // non-IDR slice（type=1, ref_idc=2 → 0x41）
        let nalu = vec![0x41, 0x9A, 0x24, 0x6C];
        let rtp = make_rtp(1, 180000, true, nalu);
        let frames = depacketizer.push_rtp(&rtp);

        assert!(!frames.is_empty());
        let frame = frames.last().unwrap();
        assert_eq!(frame.frame_type, FrameType::InterFrame);
        assert_eq!(frame.data[0], 0x27, "P 帧应为 inter+H264");
    }

    /// 测试：AAC 解包正确提取音频数据，输出 FLV 音频帧格式
    #[test]
    fn test_aac_depacketized_correctly() {
        let aac_data = vec![0x21, 0x10, 0x05, 0x00, 0x00];
        let payload = make_aac_payload(&aac_data);
        let rtp = make_rtp(1, 1024, true, payload);

        let frame = depacketize_aac(&rtp).expect("应返回 AAC 帧");
        assert_eq!(frame.media_type, MediaType::Audio);
        assert_eq!(frame.audio_codec, AudioCodec::Aac);
        // FLV 音频帧格式：[0xAF(声音信息), 0x01(AAC raw), ...AAC 数据]
        assert_eq!(frame.data[0], 0xAF, "声音信息字节：AAC 44100Hz 16bit stereo");
        assert_eq!(frame.data[1], 0x01, "AAC packet type = raw data");
        assert_eq!(&frame.data[2..], aac_data.as_slice(), "AAC 数据应保持不变");
    }

    /// 测试：空 RTP 负载返回空帧列表
    #[test]
    fn test_empty_payload_returns_no_frames() {
        let mut depacketizer = RtpDepacketizer::new();
        let rtp = make_rtp(1, 90000, true, vec![]);
        let frames = depacketizer.push_rtp(&rtp);
        assert!(frames.is_empty(), "空负载应返回空帧列表");
    }

    /// 测试：FU-A start 分片累积但不输出
    #[test]
    fn test_fu_a_start_without_end_accumulates() {
        let mut depacketizer = RtpDepacketizer::new();
        let frag = vec![0xAA, 0xBB];
        let rtp = make_rtp(
            1,
            90000,
            false,
            make_fu_a_payload(3, 5, true, false, &frag),
        );
        let frames = depacketizer.push_rtp(&rtp);
        assert!(frames.is_empty(), "只有 start 分片时不应输出帧");
    }

    /// 测试：收到中间分片但没有 start 应被丢弃
    #[test]
    fn test_fu_a_middle_without_start_discarded() {
        let mut depacketizer = RtpDepacketizer::new();
        let frag = vec![0xAA];
        let rtp = make_rtp(
            1,
            90000,
            false,
            make_fu_a_payload(3, 5, false, false, &frag),
        );
        let frames = depacketizer.push_rtp(&rtp);
        assert!(frames.is_empty(), "没有 start 的中间分片应被丢弃");
    }

    /// 测试：连续 IDR 帧不会重复发送 seq_header
    #[test]
    fn test_seq_header_emitted_only_once() {
        let mut depacketizer = RtpDepacketizer::new();

        let sps = vec![0x67, 0x42, 0xC0];
        let pps = vec![0x68, 0xCE, 0x38];
        let idr = vec![0x65, 0x88, 0x84];

        // 发送 SPS + PPS
        depacketizer.push_rtp(&make_rtp(1, 0, false, sps));
        depacketizer.push_rtp(&make_rtp(2, 0, false, pps));

        // 第一个 IDR：应输出 seq_header + IDR（2 帧）
        let frames1 = depacketizer.push_rtp(&make_rtp(3, 90000, true, idr.clone()));
        assert_eq!(frames1.len(), 2, "首个 IDR 应输出 seq_header + IDR");

        // 第二个 IDR：只输出 IDR（1 帧）
        let frames2 = depacketizer.push_rtp(&make_rtp(4, 180000, true, idr));
        assert_eq!(frames2.len(), 1, "后续 IDR 不应重复输出 seq_header");
    }

    /// 测试：新的 SPS 到达后重置 seq_header_emitted 标记
    #[test]
    fn test_new_sps_resets_seq_header_flag() {
        let mut depacketizer = RtpDepacketizer::new();

        let sps = vec![0x67, 0x42, 0xC0];
        let pps = vec![0x68, 0xCE, 0x38];
        let idr = vec![0x65, 0x88, 0x84];

        // 发送 SPS + PPS + IDR
        depacketizer.push_rtp(&make_rtp(1, 0, false, sps.clone()));
        depacketizer.push_rtp(&make_rtp(2, 0, false, pps.clone()));
        let f1 = depacketizer.push_rtp(&make_rtp(3, 90000, true, idr.clone()));
        assert_eq!(f1.len(), 2);

        // 新的 SPS → 重置标记
        let new_sps = vec![0x67, 0x4D, 0x00];
        depacketizer.push_rtp(&make_rtp(4, 0, false, new_sps));
        // 新的 PPS
        depacketizer.push_rtp(&make_rtp(5, 0, false, pps));

        // 新的 IDR → 应再次输出 seq_header
        let f2 = depacketizer.push_rtp(&make_rtp(6, 180000, true, idr));
        assert_eq!(f2.len(), 2, "SPS 更新后应重新输出 seq_header");
    }

    /// 测试：AAC 空负载返回 None
    #[test]
    fn test_aac_empty_payload_returns_none() {
        let rtp = make_rtp(1, 0, true, vec![]);
        assert!(depacketize_aac(&rtp).is_none());
    }

    /// 测试：AAC 负载太短返回 None
    #[test]
    fn test_aac_payload_too_short_returns_none() {
        let rtp = make_rtp(1, 0, true, vec![0x00, 0x10]);
        assert!(depacketize_aac(&rtp).is_none());
    }

    /// 测试：时间戳转换正确（90kHz → ms），归一化后首帧为 0
    #[test]
    fn test_video_timestamp_conversion_correct() {
        let mut depacketizer = RtpDepacketizer::new();
        let nalu = vec![0x65, 0x01]; // IDR
        // 首帧：RTP ts=90000，归一化后 ts=0，0/90=0ms
        let rtp = make_rtp(1, 90000, true, nalu.clone());
        let frames = depacketizer.push_rtp(&rtp);
        assert_eq!(frames.last().unwrap().timestamp_ms, 0);
        // 第二帧：RTP ts=99000，归一化后 ts=9000，9000/90=100ms
        let rtp2 = make_rtp(2, 99000, true, nalu);
        let frames2 = depacketizer.push_rtp(&rtp2);
        assert_eq!(frames2.last().unwrap().timestamp_ms, 100);
    }

    /// 测试：完整 FU-A 重组后数据与原始 NALU 一致（大 NALU 场景）
    #[test]
    fn test_fu_a_large_nalu_reassembly_matches_original() {
        let mut depacketizer = RtpDepacketizer::new();

        // 构造 3000 字节的原始 NALU（IDR, type=5, ref_idc=3）
        let mut original_nalu = vec![0x65];
        original_nalu.extend_from_slice(&[0xAB; 2999]);

        // 模拟 MTU=1400 的 FU-A 分片
        let nri = 3;
        let ntype = 5;
        let mtu = 1400;
        let fu_payload_max = mtu - 2; // 1398
        let mut seq = 0u16;
        let timestamp = 90000u32;
        let mut offset = 1; // 跳过 NALU header

        while offset < original_nalu.len() {
            let end_pos = std::cmp::min(offset + fu_payload_max, original_nalu.len());
            let is_first = offset == 1;
            let is_last = end_pos == original_nalu.len();
            let fragment = &original_nalu[offset..end_pos];

            let rtp = make_rtp(
                seq,
                timestamp,
                is_last,
                make_fu_a_payload(nri, ntype, is_first, is_last, fragment),
            );
            let frames = depacketizer.push_rtp(&rtp);

            if is_last {
                assert!(!frames.is_empty(), "最后一个分片应输出帧");
                let frame = frames.last().unwrap();
                // 提取重组后的 NALU
                let avcc_data = &frame.data[5..];
                let nalu_len = u32::from_be_bytes([
                    avcc_data[0],
                    avcc_data[1],
                    avcc_data[2],
                    avcc_data[3],
                ]) as usize;
                let reassembled = &avcc_data[4..4 + nalu_len];
                assert_eq!(
                    reassembled,
                    original_nalu.as_slice(),
                    "重组后的 NALU 应与原始一致"
                );
            } else {
                assert!(frames.is_empty(), "中间分片不应输出帧");
            }

            seq = seq.wrapping_add(1);
            offset = end_pos;
        }
    }

    /// 测试：set_sps_pps 预设 SPS/PPS 到解包器
    #[test]
    fn test_set_sps_pps_presets_pending() {
        let mut dep = RtpDepacketizer::new();
        let sps = vec![0x67, 0x42, 0xC0];
        let pps = vec![0x68, 0xCE, 0x38];
        dep.set_sps_pps(sps.clone(), pps.clone());
        assert_eq!(dep.pending_sps, Some(sps), "pending_sps 应被预设");
        assert_eq!(dep.pending_pps, Some(pps), "pending_pps 应被预设");
        assert!(!dep.seq_header_emitted, "seq_header_emitted 应被重置为 false");
    }

    /// 测试：set_sps_pps 后 IDR 帧触发 seq_header 输出
    #[test]
    fn test_set_sps_pps_then_idr_emits_seq_header() {
        let mut dep = RtpDepacketizer::new();

        // 预设 SPS/PPS（模拟从 SDP 获取）
        let sps = vec![0x67, 0x42, 0xC0, 0x1E, 0xD9, 0x00, 0xA0, 0x47, 0xFE, 0x88];
        let pps = vec![0x68, 0xCE, 0x38, 0x80];
        dep.set_sps_pps(sps, pps);

        // 发送 IDR（应输出 seq_header + IDR 两帧）
        let idr = vec![0x65, 0x88, 0x84, 0x00, 0x40];
        let rtp = make_rtp(1, 90000, true, idr);
        let frames = dep.push_rtp(&rtp);

        assert_eq!(frames.len(), 2, "应输出 seq_header + IDR 两帧");
        assert_eq!(frames[0].data[1], 0x00, "第一帧应为 seq_header");
        assert_eq!(frames[1].data[1], 0x01, "第二帧应为 AVC NALU");
    }

    // ── 多 NALU 合并测试 ────────────────────────────────────

    /// 测试：多个相同时间戳的 NALU 合并为一个 AVFrame
    #[test]
    fn test_multiple_nalus_same_timestamp_grouped_into_one_frame() {
        let mut dep = RtpDepacketizer::new();
        // 预设 SPS/PPS 以避免 seq_header 干扰
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let ts = 90000u32;

        // 第一个 non-IDR NALU，marker=false — 不应输出帧
        let nalu1 = vec![0x41, 0x9A, 0x24];
        let rtp1 = make_rtp(1, ts, false, nalu1);
        let frames1 = dep.push_rtp(&rtp1);
        assert!(
            frames1.is_empty(),
            "第一个 NALU（无 marker）不应输出帧"
        );

        // 第二个 non-IDR NALU，相同时间戳，marker=false — 继续累积
        let nalu2 = vec![0x41, 0x9B, 0x25];
        let rtp2 = make_rtp(2, ts, false, nalu2);
        let frames2 = dep.push_rtp(&rtp2);
        assert!(
            frames2.is_empty(),
            "第二个 NALU（无 marker）不应输出帧"
        );

        // 第三个 non-IDR NALU，相同时间戳，marker=true — 输出合并帧
        let nalu3 = vec![0x41, 0x9C, 0x26];
        let rtp3 = make_rtp(3, ts, true, nalu3);
        let frames3 = dep.push_rtp(&rtp3);
        assert_eq!(frames3.len(), 1, "marker=true 时应输出 1 个合并帧");

        // 验证帧包含所有 3 个 NALU（AVCC 格式）
        let frame = &frames3[0];
        assert_eq!(frame.data[0], 0x27, "应为 inter+H264");
        assert_eq!(frame.data[1], 0x01, "应为 AVC NALU");

        // 解析 AVCC 区域中的 NALU
        let avcc_data = &frame.data[5..];
        let parsed_nalus = crate::codec::h264::split_avcc(avcc_data);
        assert_eq!(parsed_nalus.len(), 3, "应包含 3 个 NALU");
    }

    /// 测试：时间戳跳变时先输出已累积的 NALU
    #[test]
    fn test_timestamp_change_flushes_pending_nalus() {
        let mut dep = RtpDepacketizer::new();
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let ts1 = 90000u32;
        let nalu1 = vec![0x41, 0x9A];
        let rtp1 = make_rtp(1, ts1, false, nalu1);
        let _ = dep.push_rtp(&rtp1);

        // 新时间戳 — 应先刷新之前累积的 NALU
        // 首次遇到 slice NALU 时会先输出 seq_header
        let ts2 = 90360u32; // +40ms（90kHz × 40ms ≈ 3600 ticks）
        let nalu2 = vec![0x41, 0x9B];
        let rtp2 = make_rtp(2, ts2, true, nalu2);
        let frames = dep.push_rtp(&rtp2);

        // 应得到 3 帧：seq_header + 刷新的旧帧 + 新帧
        assert_eq!(frames.len(), 3, "应先输出 seq_header，再刷新旧帧并输出新帧");
        assert_eq!(frames[0].data[1], 0x00, "第一帧应为 seq_header");
        assert_eq!(frames[1].data[0], 0x27, "第二帧应为 inter+H264（旧帧）");
        assert_eq!(frames[2].data[0], 0x27, "第三帧应为 inter+H264（新帧）");
    }

    /// 测试：多 NALU 帧中包含 IDR 时正确标记为关键帧
    #[test]
    fn test_multi_nalu_with_idr_marked_as_keyframe() {
        let mut dep = RtpDepacketizer::new();
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let ts = 90000u32;

        // IDR NALU + non-IDR NALU 合并
        let idr_nalu = vec![0x65, 0x88, 0x84];
        let rtp1 = make_rtp(1, ts, false, idr_nalu);
        let _ = dep.push_rtp(&rtp1);

        let slice_nalu = vec![0x65, 0x01, 0x02]; // IDR 多 slice
        let rtp2 = make_rtp(2, ts, true, slice_nalu);
        let frames = dep.push_rtp(&rtp2);

        assert_eq!(frames.len(), 1);
        assert_eq!(
            frames[0].frame_type,
            FrameType::KeyFrame,
            "包含 IDR 的合并帧应为关键帧"
        );
        assert_eq!(frames[0].data[0], 0x17, "应为 keyframe+H264");
    }

    /// 测试：SPS 到达时先刷新已累积的 NALU
    #[test]
    fn test_sps_flushes_pending_nalus() {
        let mut dep = RtpDepacketizer::new();
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let ts = 90000u32;
        let nalu = vec![0x41, 0x9A];
        let rtp1 = make_rtp(1, ts, false, nalu);
        let _ = dep.push_rtp(&rtp1);

        // SPS 到达 — 应先输出累积的帧
        let new_sps = vec![0x67, 0x4D, 0x00];
        let rtp2 = make_rtp(2, 0, false, new_sps);
        let frames = dep.push_rtp(&rtp2);

        assert_eq!(frames.len(), 1, "SPS 到达时应先刷新累积的帧");
        assert_eq!(frames[0].data[0], 0x27, "应为 inter+H264");
    }

    /// 测试：flush() 方法在无累积 NALU 时返回 None
    #[test]
    fn test_flush_empty_returns_none() {
        let mut dep = RtpDepacketizer::new();
        assert!(dep.flush().is_none(), "无累积 NALU 时 flush 应返回 None");
    }

    /// 测试：flush() 输出累积的 NALU 并清空状态
    #[test]
    fn test_flush_outputs_and_clears_pending() {
        let mut dep = RtpDepacketizer::new();
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let ts = 90000u32;
        let nalu = vec![0x41, 0x9A, 0x24];
        let rtp = make_rtp(1, ts, false, nalu);
        let _ = dep.push_rtp(&rtp);

        let frame = dep.flush().expect("应有累积的帧");
        assert_eq!(frame.data[0], 0x27);
        assert!(dep.pending_nalus.is_empty(), "flush 后应清空 pending_nalus");

        // 再次 flush 应返回 None
        assert!(dep.flush().is_none());
    }

    /// 测试：单个 NALU + marker=true 仍然正常工作（向后兼容）
    #[test]
    fn test_single_nalu_with_marker_still_works() {
        let mut dep = RtpDepacketizer::new();
        dep.set_sps_pps(vec![0x67, 0x42], vec![0x68, 0xCE]);

        let nalu = vec![0x41, 0x9A, 0x24];
        let rtp = make_rtp(1, 180000, true, nalu.clone());
        let frames = dep.push_rtp(&rtp);

        assert_eq!(frames.len(), 1, "单个 NALU + marker 应输出 1 帧");
        // 验证 AVCC 解析后只有一个 NALU
        let avcc_data = &frames[0].data[5..];
        let parsed = crate::codec::h264::split_avcc(avcc_data);
        assert_eq!(parsed.len(), 1, "应只包含 1 个 NALU");
        assert_eq!(parsed[0], nalu.as_slice(), "NALU 数据应一致");
    }

    /// 测试：多 NALU IDR 帧正确触发 seq_header 输出
    #[test]
    fn test_multi_nalu_idr_emits_seq_header() {
        let mut dep = RtpDepacketizer::new();

        let sps = vec![0x67, 0x42, 0xC0];
        let pps = vec![0x68, 0xCE, 0x38];
        dep.push_rtp(&make_rtp(1, 0, false, sps));
        dep.push_rtp(&make_rtp(2, 0, false, pps));

        // 两个 IDR NALU 组成一个访问单元
        let idr1 = vec![0x65, 0x88, 0x84];
        let idr2 = vec![0x65, 0x01, 0x02];
        // 第一个 IDR 到达时输出 seq_header（因为 pending_nalus 为空且是 IDR）
        let frames1 = dep.push_rtp(&make_rtp(3, 90000, false, idr1));
        assert_eq!(frames1.len(), 1, "第一个 IDR 应触发 seq_header");
        assert_eq!(frames1[0].data[1], 0x00, "应为 seq_header");

        // 第二个 IDR（marker=true）输出合并帧
        let frames2 = dep.push_rtp(&make_rtp(4, 90000, true, idr2));
        assert_eq!(frames2.len(), 1, "应输出合并 IDR 帧");
        assert_eq!(frames2[0].data[0], 0x17, "合并 IDR 应为 keyframe+H264");

        // 验证合并帧包含 2 个 NALU
        let avcc_data = &frames2[0].data[5..];
        let parsed = crate::codec::h264::split_avcc(avcc_data);
        assert_eq!(parsed.len(), 2, "应包含 2 个 IDR NALU");
    }
}