wedb_embed 0.1.0

use crate::meta::{KeyMeta, RedisType};
use serde::{Deserialize, Serialize};

/// 有序整型集合结构元数据（对标 Apache Kvrocks SortedintMetadata 26字节 / 紧凑25字节）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct SortedintMeta {
    pub base: KeyMeta,
}

impl Default for SortedintMeta {
    #[inline]
    fn default() -> Self {
        Self::new_with_version(0, 0)
    }
}

impl SortedintMeta {
    pub const ENCODED_SIZE: usize = KeyMeta::ENCODED_SIZE;
    pub const KVROCKS_ENCODED_SIZE: usize = KeyMeta::KVROCKS_COMPLEX_ENCODED_SIZE;

    #[inline]
    pub fn new(expire_at: u64, version: u64, size: u64) -> Self {
        Self {
            base: KeyMeta::new(RedisType::SortedInt, expire_at, version, size),
        }
    }

    #[inline]
    pub fn new_with_version(expire_at: u64, size: u64) -> Self {
        Self {
            base: KeyMeta::new_with_version(RedisType::SortedInt, expire_at, size),
        }
    }

    #[inline]
    pub fn size(&self) -> u64 {
        self.base.size
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.base.size == 0
    }

    #[inline]
    pub fn is_expired(&self, now_ms: u64) -> bool {
        self.base.is_expired(now_ms)
    }

    #[inline]
    pub fn encode(&self) -> [u8; Self::ENCODED_SIZE] {
        self.base.encode()
    }

    #[inline]
    pub fn encode_kvrocks(&self) -> Vec<u8> {
        self.base.encode_kvrocks()
    }

    #[inline]
    pub fn decode(bytes: &[u8]) -> Option<Self> {
        let base = KeyMeta::decode(bytes)?;
        if base.rtype == RedisType::SortedInt {
            Some(Self { base })
        } else {
            None
        }
    }
}

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

    #[test]
    fn test_sortedint_meta_roundtrip() {
        let meta = SortedintMeta::new(1700000000000, 101, 55);
        let enc = meta.encode();
        assert_eq!(enc.len(), SortedintMeta::ENCODED_SIZE);

        let dec = SortedintMeta::decode(&enc).expect("decode standard failed");
        assert_eq!(dec.base.rtype, RedisType::SortedInt);
        assert_eq!(dec.base.expire_at, 1700000000000);
        assert_eq!(dec.base.version, 101);
        assert_eq!(dec.base.size, 55);

        let kv_enc = meta.encode_kvrocks();
        assert_eq!(kv_enc.len(), SortedintMeta::KVROCKS_ENCODED_SIZE);
        let kv_dec = SortedintMeta::decode(&kv_enc).expect("decode kvrocks failed");
        assert_eq!(kv_dec.base.rtype, RedisType::SortedInt);
        assert_eq!(kv_dec.base.expire_at, 1700000000000);
        assert_eq!(kv_dec.base.version, 101);
        assert_eq!(kv_dec.base.size, 55);

        let def = SortedintMeta::default();
        assert_eq!(def.base.rtype, RedisType::SortedInt);
        assert_eq!(def.base.size, 0);
        assert!(def.is_empty());
    }
}