zenith-ebpf 0.1.0

//! BPF Map 管理
//!
//! 提供 BPF Map 操作封装

use crate::error::MapError;
use libbpf_rs::{MapCore, MapFlags};
use std::rc::Rc;

/// BPF Map 管理器
///
/// 封装 BPF Map 的操作，使用 `Rc<Map>` 共享 Map 引用——`libbpf_rs::Map`
/// 本身非 `Send`/`Sync`（libbpf 内部指针非线程安全），只能单线程持有；
/// 用 `Rc` 让"单线程共享"由类型系统精确表达（顺带免掉原子计数开销）。
/// 类型自动阻止跨线程 move，线程安全由编译器保证，无需人工约定。
pub struct BpfMaps<'obj> {
    /// XSKMAP：AF_XDP Socket 重定向目标
    pub xsk_map: Rc<libbpf_rs::Map<'obj>>,
    /// STATS_MAP：per-CPU 统计计数
    pub stats_map: Rc<libbpf_rs::Map<'obj>>,
    /// CONFIG_MAP：运行时配置（MTU、协议白名单、Fail-Closed）
    pub config_map: Rc<libbpf_rs::Map<'obj>>,
    /// EXPECTATION_MAP：协议预期配置（端口白名单/分片策略/TTL）
    pub expectation_map: Rc<libbpf_rs::Map<'obj>>,
}

impl<'obj> BpfMaps<'obj> {
    /// 从已加载的 libbpf Object 获取所有 Map
    ///
    /// # 参数
    /// * `obj` - 已加载的 libbpf Object 引用
    ///
    /// # 返回
    /// * `Result<Self, MapError>` - Map 管理器实例
    pub fn from_object(obj: &'obj libbpf_rs::Object) -> Result<Self, MapError> {
        // 收集所有 maps
        let mut xsk_map = None;
        let mut stats_map = None;
        let mut config_map = None;
        let mut expectation_map = None;

        for map in obj.maps() {
            // name 是 [i8; 16] 数组，需要转换为字符串
            let name = map.info().map(|i| {
                let bytes = i.info.name.iter()
                    .take_while(|&&b| b != 0)
                    .map(|&b| b as u8)
                    .collect::<Vec<_>>();
                String::from_utf8_lossy(&bytes).to_string()
            }).unwrap_or_default();
            
            match name.as_str() {
                "xsk_map" => xsk_map = Some(Rc::new(map)),
                "stats_map" => stats_map = Some(Rc::new(map)),
                "config_map" => config_map = Some(Rc::new(map)),
                "expectation_map" => expectation_map = Some(Rc::new(map)),
                _ => {}
            }
        }

        Ok(Self {
            xsk_map: xsk_map.ok_or_else(|| MapError::NotFound("xsk_map".to_string()))?,
            stats_map: stats_map.ok_or_else(|| MapError::NotFound("stats_map".to_string()))?,
            config_map: config_map.ok_or_else(|| MapError::NotFound("config_map".to_string()))?,
            expectation_map: expectation_map
                .ok_or_else(|| MapError::NotFound("expectation_map".to_string()))?,
        })
    }

    // ==================== XSKMAP 操作 ====================

    /// 更新 XSK 映射（队列 → XSK fd）
    pub fn update_xsk(&self, queue_id: u32, xsk_fd: u32) -> Result<(), MapError> {
        let key = &queue_id.to_ne_bytes();
        let value = &xsk_fd.to_ne_bytes();
        self.xsk_map
            .update(key, value, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to update xsk_map: {}", e)))
    }

    /// 删除 XSK 映射
    pub fn delete_xsk(&self, queue_id: u32) -> Result<(), MapError> {
        let key = &queue_id.to_ne_bytes();
        self.xsk_map
            .delete(key)
            .map_err(|e| MapError::Libbpf(format!("Failed to delete from xsk_map: {}", e)))
    }

    /// 查找 XSK fd
    pub fn lookup_xsk(&self, queue_id: u32) -> Result<Option<u32>, MapError> {
        let key = &queue_id.to_ne_bytes();
        let value = self
            .xsk_map
            .lookup(key, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to lookup xsk_map: {}", e)))?;

        match value {
            Some(v) => {
                let arr: [u8; 4] = v.as_slice().try_into().map_err(|_| {
                    MapError::SizeMismatch {
                        expected: 4,
                        actual: v.len(),
                    }
                })?;
                Ok(Some(u32::from_ne_bytes(arr)))
            }
            None => Ok(None),
        }
    }

    // ==================== STATS_MAP 操作 ====================
    //
    // 重要：STATS_MAP 为 `BPF_MAP_TYPE_PERCPU_ARRAY`，其语义是内核侧
    // （BPF 程序）按 CPU 槽原子累加。用户态不应通过 `lookup` + `update`
    // 对其做 read-modify-write：用户态没有 CPU 亲和性，`update` 会把
    // 整个 per-CPU 缓冲一次性写回，覆盖 lookup 与 update 之间其它 CPU
    // 上内核已经完成的累加，造成计数丢失。
    //
    // 因此用户态只允许 READ——通过下面的 [`BpfMaps::lookup_stat`] 汇总
    // 全部 CPU 槽取和。统计递增（`__sync_fetch_and_add` 等原子操作）必须
    // 由内核侧 BPF 程序完成。曾经存在的 `increment_stat` 已据此移除。

    /// 查找统计值（全部 CPU 槽 checked 求和）
    ///
    /// 任一步溢出 fail-closed 返回 [`MapError::CounterOverflow`]。
    pub fn lookup_stat(&self, stat_id: u32) -> Result<Option<u64>, MapError> {
        let key = &stat_id.to_ne_bytes();
        let value = self
            .stats_map
            .lookup(key, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to lookup stats_map: {}", e)))?;

        match value {
            Some(v) => {
                if v.len() < 8 || v.len() % 8 != 0 {
                    return Ok(None);
                }
                // per-CPU 全槽 checked 求和，溢出 fail-closed
                let mut total: u64 = 0;
                for chunk in v.chunks_exact(8) {
                    let n = u64::from_ne_bytes(chunk.try_into().map_err(|_| {
                        MapError::SizeMismatch {
                            expected: 8,
                            actual: chunk.len(),
                        }
                    })?);
                    total = total.checked_add(n).ok_or(MapError::CounterOverflow)?;
                }
                Ok(Some(total))
            }
            None => Ok(None),
        }
    }

    // ==================== CONFIG_MAP 操作 ====================

    /// 配置键：MTU（与 xdp_common.h 中 CONFIG_KEY_* 对应）
    pub const CONFIG_KEY_MTU: u32 = 0;
    /// 配置键：协议白名单位图。
    pub const CONFIG_KEY_PROTO_WHITELIST: u32 = 1;
    /// 配置键：Fail-Closed 模式开关。
    pub const CONFIG_KEY_FAIL_CLOSED: u32 = 2;
    /// 配置键：白名单显式启用（0=默认回退，1=用户态完全控制）。
    ///
    /// 与内核侧 `xdp_common.h` 的 `CONFIG_KEY_WHITELIST_ENABLED` 严格对应（NET-014）。
    pub const CONFIG_KEY_WHITELIST_ENABLED: u32 = 3;
    /// 配置键：协议预期配置（端口白名单/分片策略/TTL 检查）
    pub const CONFIG_KEY_EXPECTATION: u32 = 10;
    // 注：A/B Map 热更新方案已废止（AGENT.md §3.1.4），Bank 切换由用户态
    // bpf_link update_prog 原子替换承担，内核侧不再存在 BANK_MAGIC 配置键。

    /// 更新配置项（u64 值）
    pub fn update_config(&self, key: u32, value: u64) -> Result<(), MapError> {
        let key_bytes = &key.to_ne_bytes();
        let val_bytes = &value.to_ne_bytes();
        self.config_map
            .update(key_bytes, val_bytes, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to update config_map: {}", e)))
    }

    /// 查找配置项（u64 值）
    pub fn lookup_config(&self, key: u32) -> Result<Option<u64>, MapError> {
        let key_bytes = &key.to_ne_bytes();
        let value = self
            .config_map
            .lookup(key_bytes, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to lookup config_map: {}", e)))?;

        match value {
            Some(v) => {
                if v.len() < 8 {
                    return Ok(None);
                }
                // 长度已校验 >= 8，转换失败视为数据损坏，fail-closed 返回 Err
                let arr: [u8; 8] = v[..8].try_into().map_err(|_| MapError::SizeMismatch {
                    expected: 8,
                    actual: v.len(),
                })?;
                Ok(Some(u64::from_ne_bytes(arr)))
            }
            None => Ok(None),
        }
    }

    /// 设置 MTU 阈值
    pub fn set_mtu(&self, mtu: u32) -> Result<(), MapError> {
        self.update_config(Self::CONFIG_KEY_MTU, mtu as u64)
    }

    /// 获取 MTU 阈值
    pub fn get_mtu(&self) -> Result<Option<u32>, MapError> {
        self.lookup_config(Self::CONFIG_KEY_MTU)
            .map(|v| v.map(|val| val as u32))
    }

    /// 设置协议白名单位图（位掩码，bit N = L4 协议号）
    ///
    /// 位图语义与内核侧 `xdp_common.h` 的 `proto_whitelist_allowed()` 一致：
    /// - 位图为 0 时内核回退到 [`Self::DEFAULT_PROTO_WHITELIST`]
    /// - 协议号 >= 64 超出位图表示范围，内核一律视为不在白名单
    pub fn set_proto_whitelist(&self, bitmap: u64) -> Result<(), MapError> {
        self.update_config(Self::CONFIG_KEY_PROTO_WHITELIST, bitmap)
    }

    /// 读取当前协议白名单位图（未配置返回 `None`，内核侧将使用默认值）
    pub fn get_proto_whitelist(&self) -> Result<Option<u64>, MapError> {
        self.lookup_config(Self::CONFIG_KEY_PROTO_WHITELIST)
    }

    /// 按协议号列表设置协议白名单（便捷封装）
    ///
    /// 协议号 >= 64 无法在位图中表示，fail-closed 返回 `Err`。
    pub fn set_proto_whitelist_for(&self, protocols: &[u8]) -> Result<(), MapError> {
        let bitmap = Self::proto_whitelist_bitmap(protocols)?;
        self.set_proto_whitelist(bitmap)
    }

    /// 由协议号列表构建白名单位图（bit N = 协议号）
    ///
    /// 协议号 >= 64 超出 u64 位图表示范围，返回 `MapError::UnsupportedOperation`。
    pub fn proto_whitelist_bitmap(protocols: &[u8]) -> Result<u64, MapError> {
        let mut bitmap: u64 = 0;
        for &proto in protocols {
            if proto >= 64 {
                return Err(MapError::UnsupportedOperation(format!(
                    "协议号 {} 超出白名单位图表示范围（>= 64）",
                    proto
                )));
            }
            bitmap |= 1u64 << proto;
        }
        Ok(bitmap)
    }

    /// 设置 Fail-Closed 模式
    pub fn set_fail_closed(&self, enabled: bool) -> Result<(), MapError> {
        self.update_config(Self::CONFIG_KEY_FAIL_CLOSED, enabled as u64)
    }

    /// 获取 Fail-Closed 模式状态
    pub fn get_fail_closed(&self) -> Result<bool, MapError> {
        self.lookup_config(Self::CONFIG_KEY_FAIL_CLOSED)
            .map(|v| v.is_some_and(|val| val != 0))
    }

    /// 设置白名单显式启用（NET-014）
    ///
    /// 默认（false/未配置）时内核侧 `proto_whitelist_allowed()` 在
    /// `CONFIG_KEY_PROTO_WHITELIST` 位图为 0 时回退到
    /// [`Self::DEFAULT_PROTO_WHITELIST`]（兼容旧行为）。
    /// 显式启用（true）后，用户态完全控制位图：空列表（位图=0）即拒绝所有
    /// 协议（fail-closed，不再回退默认白名单）。
    pub fn set_whitelist_enabled(&self, enabled: bool) -> Result<(), MapError> {
        self.update_config(Self::CONFIG_KEY_WHITELIST_ENABLED, enabled as u64)
    }

    /// 读取白名单显式启用状态
    ///
    /// 未配置（None）视为返回 `false`（默认回退语义）。
    pub fn get_whitelist_enabled(&self) -> Result<bool, MapError> {
        self.lookup_config(Self::CONFIG_KEY_WHITELIST_ENABLED)
            .map(|v| v.is_some_and(|val| val != 0))
    }

    /// 协议号：TCP（linux/in.h，单一来源见 zenith_foundation::net）
    pub const IPPROTO_TCP: u8 = zenith_foundation::net::IPPROTO_TCP;
    /// 协议号：UDP（linux/in.h，单一来源见 zenith_foundation::net）
    pub const IPPROTO_UDP: u8 = zenith_foundation::net::IPPROTO_UDP;
    /// 协议号：ICMP（linux/in.h，单一来源见 zenith_foundation::net）
    pub const IPPROTO_ICMP: u8 = zenith_foundation::net::IPPROTO_ICMP;
    /// 协议号：ICMPv6（linux/in6.h，单一来源见 zenith_foundation::net）
    pub const IPPROTO_ICMPV6: u8 = zenith_foundation::net::IPPROTO_ICMPV6;

    /// 默认协议白名单位图：放行 TCP / UDP / ICMP / ICMPv6
    ///
    /// **单一权威来源**：`zenith_foundation::net::DEFAULT_PROTO_WHITELIST`（NET-013 修复）。
    /// 与内核侧 `xdp_common.h` 的 `DEFAULT_PROTO_WHITELIST` 严格一致。
    /// 注：ICMPv6 协议号 58 超出 32 位，位图必须使用 u64。
    pub const DEFAULT_PROTO_WHITELIST: u64 = zenith_foundation::net::DEFAULT_PROTO_WHITELIST;

    // ==================== EXPECTATION_MAP 操作 ====================

    /// 设置协议预期配置（写入 EXPECTATION_MAP，key=0）
    ///
    /// 将 [`ExpectationConfig`] 序列化为原生字节序写入专用 BPF map。
    /// 内核侧 XDP 程序读取后执行端口白名单/TTL/分片策略检查。
    ///
    /// 注：使用独立 Map 而非 config_map，因为 config_map 的 value_size=8
    /// （u64），无法容纳 80 字节的 ExpectationConfig。
    pub fn update_expectation(&self, config: &ExpectationConfig) -> Result<(), MapError> {
        let key_bytes = &0u32.to_ne_bytes();
        let val_bytes = config.to_bytes();
        self.expectation_map
            .update(key_bytes, &val_bytes, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to update expectation_map: {}", e)))
    }

    /// 读取协议预期配置
    ///
    /// 从专用 EXPECTATION_MAP 读取原始字节并反序列化为 [`ExpectationConfig`]。
    /// 未配置或数据损坏时返回 `None`。
    pub fn lookup_expectation(&self) -> Result<Option<ExpectationConfig>, MapError> {
        let key_bytes = &0u32.to_ne_bytes();
        let value = self
            .expectation_map
            .lookup(key_bytes, MapFlags::ANY)
            .map_err(|e| MapError::Libbpf(format!("Failed to lookup expectation_map: {}", e)))?;
        match value {
            Some(v) => Ok(ExpectationConfig::from_bytes(&v)),
            None => Ok(None),
        }
    }
}

/// XDP 协议预期配置 (写入 BPF map, 内核态读取)
///
/// 布局与 `xdp_common.h` 中 `struct expectation_config` 严格一致（repr(C)）。
/// 用户态通过 [`BpfMaps::update_expectation`] 写入，内核态 XDP 程序读取后
/// 执行端口白名单/TTL/分片策略检查。
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct ExpectationConfig {
    /// 允许的 IP 协议号位图 (bit N = 协议号 N)
    pub allowed_protocols: u64,
    /// 分片策略: 0=不限制 1=丢弃重叠分片 2=丢弃所有分片
    pub fragment_policy: u8,
    /// 最小 TTL (低于此值的包丢弃, 0=不检查)
    pub min_ttl: u8,
    /// 结构对齐填充
    pub _pad: [u8; 2],
    /// TCP 端口白名单条目数 (0 = 不检查 TCP 端口)
    pub tcp_port_count: u16,
    /// TCP 端口白名单 (固定 16 槽)
    pub tcp_ports: [u16; 16],
    /// UDP 端口白名单条目数 (0 = 不检查 UDP 端口)
    pub udp_port_count: u16,
    /// UDP 端口白名单 (固定 16 槽)
    pub udp_ports: [u16; 16],
}

impl ExpectationConfig {
    /// 序列化字节长度
    pub const SIZE: usize = 80;

    /// 创建默认配置（全部放行）
    ///
    /// `allowed_protocols` 使用单一权威来源 `zenith_foundation::net::DEFAULT_PROTO_WHITELIST`
    /// （TCP/UDP/ICMP/ICMPv6，NET-013 修复：此前漏放 ICMP）。
    pub fn default_allow_all() -> Self {
        Self {
            allowed_protocols: zenith_foundation::net::DEFAULT_PROTO_WHITELIST,
            fragment_policy: 0,
            min_ttl: 0,
            _pad: [0, 0],
            tcp_port_count: 0,
            tcp_ports: [0; 16],
            udp_port_count: 0,
            udp_ports: [0; 16],
        }
    }

    /// 序列化为原生字节序字节数组
    pub fn to_bytes(&self) -> [u8; Self::SIZE] {
        let mut buf = [0u8; Self::SIZE];
        buf[0..8].copy_from_slice(&self.allowed_protocols.to_ne_bytes());
        buf[8] = self.fragment_policy;
        buf[9] = self.min_ttl;
        // _pad at [10..12] already zero（与 C struct expectation_config 对齐）
        buf[12..14].copy_from_slice(&self.tcp_port_count.to_ne_bytes());
        for (i, &port) in self.tcp_ports.iter().enumerate() {
            let offset = 14 + i * 2;
            buf[offset..offset + 2].copy_from_slice(&port.to_ne_bytes());
        }
        let udp_count_offset = 14 + 16 * 2; // = 46
        buf[udp_count_offset..udp_count_offset + 2]
            .copy_from_slice(&self.udp_port_count.to_ne_bytes());
        for (i, &port) in self.udp_ports.iter().enumerate() {
            let offset = udp_count_offset + 2 + i * 2;
            buf[offset..offset + 2].copy_from_slice(&port.to_ne_bytes());
        }
        buf
    }

    /// 从原生字节序字节数组反序列化
    ///
    /// 数据长度不足或损坏时返回 `None`（fail-closed）。
    pub fn from_bytes(buf: &[u8]) -> Option<Self> {
        if buf.len() < Self::SIZE {
            return None;
        }
        let allowed_protocols = u64::from_ne_bytes(buf[0..8].try_into().ok()?);
        let fragment_policy = buf[8];
        let min_ttl = buf[9];
        let tcp_port_count = u16::from_ne_bytes(buf[12..14].try_into().ok()?);
        let mut tcp_ports = [0u16; 16];
        for i in 0..16 {
            let offset = 14 + i * 2;
            tcp_ports[i] = u16::from_ne_bytes(buf[offset..offset + 2].try_into().ok()?);
        }
        let udp_count_offset = 46;
        let udp_port_count = u16::from_ne_bytes(
            buf[udp_count_offset..udp_count_offset + 2].try_into().ok()?,
        );
        let mut udp_ports = [0u16; 16];
        for i in 0..16 {
            let offset = udp_count_offset + 2 + i * 2;
            udp_ports[i] = u16::from_ne_bytes(buf[offset..offset + 2].try_into().ok()?);
        }
        Some(Self {
            allowed_protocols,
            fragment_policy,
            min_ttl,
            _pad: [0, 0],
            tcp_port_count,
            tcp_ports,
            udp_port_count,
            udp_ports,
        })
    }
}

impl Default for ExpectationConfig {
    fn default() -> Self {
        Self::default_allow_all()
    }
}

impl<'obj> std::fmt::Debug for BpfMaps<'obj> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let get_name = |map: &Rc<libbpf_rs::Map<'_>>| -> String {
            map.info()
                .map(|i| {
                    let bytes = i.info.name.iter()
                        .take_while(|&&b| b != 0)
                        .map(|&b| b as u8)
                        .collect::<Vec<_>>();
                    String::from_utf8_lossy(&bytes).to_string()
                })
                .unwrap_or_else(|_| "unknown".to_string())
        };

        f.debug_struct("BpfMaps")
            .field("xsk_map", &get_name(&self.xsk_map))
            .field("stats_map", &get_name(&self.stats_map))
            .field("config_map", &get_name(&self.config_map))
            .field("expectation_map", &get_name(&self.expectation_map))
            .finish()
    }
}

/// 统计项 ID 枚举
///
/// 与内核侧 `bpf/include/xdp_common.h` 的 `STATS_*` 常量严格一一对应，
/// `repr(u32)` 判别值即 STATS_MAP 的键：
///
/// | 枚举变体      | 值 | 内核常量               | 语义                     |
/// |---------------|----|------------------------|--------------------------|
/// | `RxPackets`   | 0  | `STATS_RX_PACKETS`     | 收到数据包总数           |
/// | `RxValid`     | 1  | `STATS_RX_VALID`       | 有效数据包数             |
/// | `DropShort`   | 2  | `STATS_RX_DROP_SHORT`  | 因包过短丢弃             |
/// | `DropBadEth`  | 3  | `STATS_RX_DROP_BAD_ETH`| 以太网头异常丢弃         |
/// | `DropBadIp`   | 4  | `STATS_RX_DROP_BAD_IP` | IP 头异常丢弃            |
/// | `DropNoXsk`   | 5  | `STATS_RX_DROP_NO_XSK` | 无对应 XSK 映射丢弃      |
/// | `Redirected`  | 6  | `STATS_REDIRECTED`     | 成功重定向到 XSK 的包数  |
/// | `DropProto`   | 7  | `STATS_RX_DROP_PROTO`  | 协议不在白名单丢弃       |
///
/// 历史教训：旧布局（TxPackets=1/RxBytes=2/...）与内核键全部错位，
/// 监控面板上除 RxPackets=0 外读到的全是语义错误的计数器。
/// 本枚举是 STATS_MAP 键的唯一权威来源，禁止散落的裸数字键。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum StatId {
    /// 收到数据包总数（内核 `STATS_RX_PACKETS`）
    RxPackets = 0,
    /// 有效数据包数（内核 `STATS_RX_VALID`）
    RxValid = 1,
    /// 因包过短丢弃（内核 `STATS_RX_DROP_SHORT`）
    DropShort = 2,
    /// 以太网头异常丢弃（内核 `STATS_RX_DROP_BAD_ETH`）
    DropBadEth = 3,
    /// IP 头异常丢弃（内核 `STATS_RX_DROP_BAD_IP`）
    DropBadIp = 4,
    /// 无对应 XSK 映射丢弃（内核 `STATS_RX_DROP_NO_XSK`）
    DropNoXsk = 5,
    /// 成功重定向到 XSK 的包数（内核 `STATS_REDIRECTED`）
    Redirected = 6,
    /// 协议不在白名单丢弃（内核 `STATS_RX_DROP_PROTO`）
    DropProto = 7,
}

impl StatId {
    /// 将 `StatId` 转为 u32 编码，用于 BPF Map 的键索引
    pub fn as_u32(&self) -> u32 {
        *self as u32
    }

    /// 从 u32 编码反解 `StatId`，未知值返回 `None`
    pub fn from_u32(value: u32) -> Option<Self> {
        match value {
            0 => Some(Self::RxPackets),
            1 => Some(Self::RxValid),
            2 => Some(Self::DropShort),
            3 => Some(Self::DropBadEth),
            4 => Some(Self::DropBadIp),
            5 => Some(Self::DropNoXsk),
            6 => Some(Self::Redirected),
            7 => Some(Self::DropProto),
            _ => None,
        }
    }

    /// 返回统计项的稳定名称（监控/Prometheus 指标名），与内核语义对应
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::RxPackets => "rx_packets",
            Self::RxValid => "rx_valid",
            Self::DropShort => "drop_short",
            Self::DropBadEth => "drop_bad_eth",
            Self::DropBadIp => "drop_bad_ip",
            Self::DropNoXsk => "drop_no_xsk",
            Self::Redirected => "redirected",
            Self::DropProto => "drop_proto",
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// `StatId` 全部判别值必须与内核 `xdp_common.h` 的 `STATS_*` 常量数值相同
    #[test]
    fn test_stat_id_matches_kernel_layout() {
        // 内核侧（bpf/include/xdp_common.h:44-51）权威布局
        const KERNEL_STATS_RX_PACKETS: u32 = 0;
        const KERNEL_STATS_RX_VALID: u32 = 1;
        const KERNEL_STATS_RX_DROP_SHORT: u32 = 2;
        const KERNEL_STATS_RX_DROP_BAD_ETH: u32 = 3;
        const KERNEL_STATS_RX_DROP_BAD_IP: u32 = 4;
        const KERNEL_STATS_RX_DROP_NO_XSK: u32 = 5;
        const KERNEL_STATS_REDIRECTED: u32 = 6;
        const KERNEL_STATS_RX_DROP_PROTO: u32 = 7;

        assert_eq!(StatId::RxPackets.as_u32(), KERNEL_STATS_RX_PACKETS);
        assert_eq!(StatId::RxValid.as_u32(), KERNEL_STATS_RX_VALID);
        assert_eq!(StatId::DropShort.as_u32(), KERNEL_STATS_RX_DROP_SHORT);
        assert_eq!(StatId::DropBadEth.as_u32(), KERNEL_STATS_RX_DROP_BAD_ETH);
        assert_eq!(StatId::DropBadIp.as_u32(), KERNEL_STATS_RX_DROP_BAD_IP);
        assert_eq!(StatId::DropNoXsk.as_u32(), KERNEL_STATS_RX_DROP_NO_XSK);
        assert_eq!(StatId::Redirected.as_u32(), KERNEL_STATS_REDIRECTED);
        assert_eq!(StatId::DropProto.as_u32(), KERNEL_STATS_RX_DROP_PROTO);
    }

    #[test]
    fn test_stat_id_count() {
        let stats = [StatId::RxPackets,
            StatId::RxValid,
            StatId::DropShort,
            StatId::DropBadEth,
            StatId::DropBadIp,
            StatId::DropNoXsk,
            StatId::Redirected,
            StatId::DropProto];
        assert_eq!(stats.len(), 8);
    }

    #[test]
    fn test_stat_id_clone_copy() {
        let s1 = StatId::RxPackets;
        let s2 = s1;
        assert_eq!(s1, s2);
        assert_eq!(s1.as_u32(), s2.as_u32());
    }

    #[test]
    fn test_stat_id_debug() {
        let s = StatId::DropShort;
        let debug_str = format!("{:?}", s);
        assert!(!debug_str.is_empty());
    }

    #[test]
    fn test_stat_id_unique() {
        let stats = [
            StatId::RxPackets,
            StatId::RxValid,
            StatId::DropShort,
            StatId::DropBadEth,
            StatId::DropBadIp,
            StatId::DropNoXsk,
            StatId::Redirected,
            StatId::DropProto,
        ];
        for (i, a) in stats.iter().enumerate() {
            for (j, b) in stats.iter().enumerate() {
                if i != j {
                    assert_ne!(a, b);
                } else {
                    assert_eq!(a, b);
                }
            }
        }
    }

    #[test]
    fn test_stat_id_eq() {
        assert_eq!(StatId::RxPackets, StatId::RxPackets);
        assert_ne!(StatId::RxPackets, StatId::RxValid);
    }

    #[test]
    fn test_map_error_display() {
        use crate::error::MapError;

        let e = MapError::NotFound("test_map".to_string());
        assert!(format!("{}", e).contains("Map not found"));

        let e = MapError::SizeMismatch { expected: 8, actual: 4 };
        let msg = format!("{}", e);
        assert!(msg.contains("Size mismatch"));
        assert!(msg.contains("8"));
    }

    #[test]
    fn test_u32_byte_conversion() {
        let values: Vec<u32> = vec![0, 1, 255, 256, 65535, 65536, u32::MAX];
        for v in values {
            let bytes = v.to_ne_bytes();
            let back = u32::from_ne_bytes(bytes);
            assert_eq!(v, back);
        }
    }

    #[test]
    fn test_u64_byte_conversion() {
        let values: Vec<u64> = vec![0, 1, 255, 256, 65535, 65536, u64::MAX];
        for v in values {
            let bytes = v.to_ne_bytes();
            let back = u64::from_ne_bytes(bytes);
            assert_eq!(v, back);
        }
    }

    #[test]
    fn test_stat_id_as_u32_consistency() {
        let pairs = [
            (StatId::RxPackets, 0u32),
            (StatId::RxValid, 1u32),
            (StatId::DropShort, 2u32),
            (StatId::DropBadEth, 3u32),
            (StatId::DropBadIp, 4u32),
            (StatId::DropNoXsk, 5u32),
            (StatId::Redirected, 6u32),
            (StatId::DropProto, 7u32),
        ];
        for (stat_id, expected) in pairs.iter() {
            assert_eq!(stat_id.as_u32(), *expected);
        }
    }

    #[test]
    fn test_stat_id_ordering() {
        assert!(StatId::RxPackets.as_u32() < StatId::RxValid.as_u32());
        assert!(StatId::RxValid.as_u32() < StatId::DropShort.as_u32());
        assert!(StatId::DropProto.as_u32() > StatId::Redirected.as_u32());
    }

    #[test]
    fn test_map_error_is_error() {
        use crate::error::MapError;
        fn assert_error<T: std::error::Error>() {}
        assert_error::<MapError>();
    }

    #[test]
    fn test_stat_id_variants_coverage() {
        let all = [
            StatId::RxPackets,
            StatId::RxValid,
            StatId::DropShort,
            StatId::DropBadEth,
            StatId::DropBadIp,
            StatId::DropNoXsk,
            StatId::Redirected,
            StatId::DropProto,
        ];
        for (i, stat) in all.iter().enumerate() {
            assert_eq!(stat.as_u32(), i as u32);
        }
    }

    /// `as_str` 名称与内核语义一一对应
    #[test]
    fn test_stat_id_as_str_semantics() {
        assert_eq!(StatId::RxPackets.as_str(), "rx_packets");
        assert_eq!(StatId::RxValid.as_str(), "rx_valid");
        assert_eq!(StatId::DropShort.as_str(), "drop_short");
        assert_eq!(StatId::DropBadEth.as_str(), "drop_bad_eth");
        assert_eq!(StatId::DropBadIp.as_str(), "drop_bad_ip");
        assert_eq!(StatId::DropNoXsk.as_str(), "drop_no_xsk");
        assert_eq!(StatId::Redirected.as_str(), "redirected");
        assert_eq!(StatId::DropProto.as_str(), "drop_proto");
    }

    /// `from_u32` 与 `as_u32` 双向 roundtrip：0..=7 全部可往返，越界返回 None
    #[test]
    fn test_stat_id_from_u32_roundtrip() {
        let all = [
            StatId::RxPackets,
            StatId::RxValid,
            StatId::DropShort,
            StatId::DropBadEth,
            StatId::DropBadIp,
            StatId::DropNoXsk,
            StatId::Redirected,
            StatId::DropProto,
        ];
        for stat in all {
            // u32 → StatId → u32 必须恒等，且 as_str 稳定
            let back = StatId::from_u32(stat.as_u32());
            assert_eq!(back, Some(stat));
            assert!(!stat.as_str().is_empty());
        }
        // 越界值 fail-closed 返回 None
        assert_eq!(StatId::from_u32(8), None);
        assert_eq!(StatId::from_u32(u32::MAX), None);
    }

    /// 白名单位图构建：bit N = 协议号
    #[test]
    fn test_proto_whitelist_bitmap() {
        let bitmap = BpfMaps::proto_whitelist_bitmap(&[
            BpfMaps::IPPROTO_TCP,
            BpfMaps::IPPROTO_UDP,
            BpfMaps::IPPROTO_ICMP,
            BpfMaps::IPPROTO_ICMPV6,
        ]);
        assert!(bitmap.is_ok());
        let bitmap = bitmap.unwrap_or(0);
        assert_eq!(bitmap, BpfMaps::DEFAULT_PROTO_WHITELIST);
        // 逐位验证
        assert_ne!(bitmap & (1u64 << BpfMaps::IPPROTO_TCP), 0);
        assert_ne!(bitmap & (1u64 << BpfMaps::IPPROTO_UDP), 0);
        assert_ne!(bitmap & (1u64 << BpfMaps::IPPROTO_ICMP), 0);
        assert_ne!(bitmap & (1u64 << BpfMaps::IPPROTO_ICMPV6), 0);
        // 未列入的协议（如 GRE=47）不在白名单
        assert_eq!(bitmap & (1u64 << 47u8), 0);
    }

    /// 空协议列表 → 位图为 0（内核侧回退默认白名单）
    #[test]
    fn test_proto_whitelist_bitmap_empty() {
        let bitmap = BpfMaps::proto_whitelist_bitmap(&[]);
        assert_eq!(bitmap.ok(), Some(0u64));
    }

    /// 协议号 >= 64 超出位图范围，必须 fail-closed 返回 Err
    #[test]
    fn test_proto_whitelist_bitmap_overflow_fails() {
        let result = BpfMaps::proto_whitelist_bitmap(&[64]);
        assert!(result.is_err());
        let result = BpfMaps::proto_whitelist_bitmap(&[BpfMaps::IPPROTO_TCP, 255]);
        assert!(result.is_err());
    }

    /// 默认白名单必须与内核侧 xdp_common.h 的 DEFAULT_PROTO_WHITELIST 一致
    #[test]
    fn test_default_proto_whitelist_value() {
        // TCP(6) | UDP(17) | ICMP(1) | ICMPv6(58)
        let expected = (1u64 << 6) | (1u64 << 17) | (1u64 << 1) | (1u64 << 58);
        assert_eq!(BpfMaps::DEFAULT_PROTO_WHITELIST, expected);
    }

    /// NET-013：三套白名单默认值必须统一（ExpectationConfig 默认须含 ICMP）
    #[test]
    fn test_expectation_default_matches_unified_whitelist() {
        let cfg = ExpectationConfig::default_allow_all();
        assert_eq!(
            cfg.allowed_protocols,
            BpfMaps::DEFAULT_PROTO_WHITELIST,
            "ExpectationConfig 默认 allowed_protocols 必须与统一白名单一致（含 ICMP）"
        );
        // 与单一权威来源完全一致
        assert_eq!(cfg.allowed_protocols, zenith_foundation::net::DEFAULT_PROTO_WHITELIST);
    }

    /// NET-014：CONFIG_KEY_WHITELIST_ENABLED 必须与内核 xdp_common.h 一致（=3）
    #[test]
    fn test_whitelist_enabled_config_key_value() {
        assert_eq!(BpfMaps::CONFIG_KEY_WHITELIST_ENABLED, 3);
    }
}