//! 通用实用工具，仅供内部使用。

/// 处理不封字节的辅助方法。
pub(crate) trait ByteSlice {
    /// 以小端顺序读取 8 个字节作为 64 位整数。
    fn read_u64(&self) -> u64;

    /// 以小端顺序将 64 位整数写入 8 个字节。
    fn write_u64(&mut self, value: u64);

    /// 计算一个切片与另一个切片的偏移量。
    fn offset_from(&self, other: &Self) -> isize;

    /// 从字节中迭代解析和消费数字。
    /// 返回相同的字节，消耗的数字被省略。
    ///
    fn parse_digits(&self, func: impl FnMut(u8)) -> &Self;
}

impl ByteSlice for [u8] {
    #[inline(always)] // 内联这对于删除绑定检查至关重要
    fn read_u64(&self) -> u64 {
        let mut tmp = [0; 8];
        tmp.copy_from_slice(&self[..8]);
        u64::from_le_bytes(tmp)
    }

    #[inline(always)] // 内联这对于删除绑定检查至关重要
    fn write_u64(&mut self, value: u64) {
        self[..8].copy_from_slice(&value.to_le_bytes())
    }

    #[inline]
    fn offset_from(&self, other: &Self) -> isize {
        other.len() as isize - self.len() as isize
    }

    #[inline]
    fn parse_digits(&self, mut func: impl FnMut(u8)) -> &Self {
        let mut s = self;

        // FIXME: 这里还不能使用 s.split_first()，
        // see https://github.com/rust-lang/rust/issues/109328
        while let [c, s_next @ ..] = s {
            let c = c.wrapping_sub(b'0');
            if c < 10 {
                func(c);
                s = s_next;
            } else {
                break;
            }
        }

        s
    }
}

/// 判断 8 个字节是否都是十进制数字。
/// 这与加载字节的顺序无关。
pub(crate) fn is_8digits(v: u64) -> bool {
    let a = v.wrapping_add(0x4646_4646_4646_4646);
    let b = v.wrapping_sub(0x3030_3030_3030_3030);
    (a | b) & 0x8080_8080_8080_8080 == 0
}

/// 自定义的 64 位浮点类型，表示 `f * 2^e`。
/// e 是有偏差的，因此它被直接移入指数位。
#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
pub struct BiasedFp {
    /// 有效数字。
    pub f: u64,
    /// 有偏差的二进制指数。
    pub e: i32,
}

impl BiasedFp {
    #[inline]
    pub const fn zero_pow2(e: i32) -> Self {
        Self { f: 0, e }
    }
}