wedb_embed 0.1.1

use crate::error::{Error, Result};
use std::str;

/// ZADD 选项标志（对标 Apache Kvrocks ZSetFlags）
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ZAdd {
    Nx,
    Xx,
    Gt,
    Lt,
    Ch,
    Incr,
}

/// 聚合函数类型（对标 Apache Kvrocks AggregateMethod）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Aggregate {
    #[default]
    Sum,
    Min,
    Max,
}

impl Aggregate {
    #[inline]
    pub fn parse(s: &str) -> Self {
        if s.eq_ignore_ascii_case("MIN") {
            Self::Min
        } else if s.eq_ignore_ascii_case("MAX") {
            Self::Max
        } else {
            Self::Sum
        }
    }

    #[inline]
    pub fn apply(&self, current: f64, new_val: f64) -> f64 {
        let res = match self {
            Self::Sum => current + new_val,
            Self::Min => current.min(new_val),
            Self::Max => current.max(new_val),
        };
        if res.is_nan() { 0.0 } else { res }
    }
}

/// 分数范围规格（对标 Apache Kvrocks RangeScoreSpec）
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RangeScoreSpec {
    pub min: f64,
    pub max: f64,
    pub minex: bool,
    pub maxex: bool,
    pub offset: usize,
    pub count: Option<usize>,
}

impl Default for RangeScoreSpec {
    #[inline]
    fn default() -> Self {
        Self {
            min: f64::NEG_INFINITY,
            max: f64::INFINITY,
            minex: false,
            maxex: false,
            offset: 0,
            count: None,
        }
    }
}

impl RangeScoreSpec {
    #[inline]
    pub fn new(min: f64, max: f64) -> Self {
        Self {
            min,
            max,
            ..Default::default()
        }
    }

    #[inline]
    pub fn with_limit(min: f64, max: f64, offset: usize, count: usize) -> Self {
        Self {
            min,
            max,
            minex: false,
            maxex: false,
            offset,
            count: Some(count),
        }
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.min > self.max || (self.min == self.max && (self.minex || self.maxex))
    }

    #[inline]
    pub fn check(&self, score: f64) -> bool {
        let min_ok = if self.minex {
            score > self.min
        } else {
            score >= self.min
        };
        let max_ok = if self.maxex {
            score < self.max
        } else {
            score <= self.max
        };
        min_ok && max_ok
    }

    /// 从 Redis 分数边界字符串构造 RangeScoreSpec
    pub fn from_bounds(
        min_bound: &str,
        max_bound: &str,
        offset: usize,
        count: Option<usize>,
    ) -> Result<Self> {
        let (min, minex) = Self::parse_bound(min_bound)?;
        let (max, maxex) = Self::parse_bound(max_bound)?;
        Ok(Self {
            min,
            max,
            minex,
            maxex,
            offset,
            count,
        })
    }

    /// 解析 Redis 风格的分数边界字符串（例如 "(1.5", "[10", "10", "-inf", "+inf", "(-inf" 等）
    pub fn parse_bound(s: &str) -> Result<(f64, bool)> {
        let s = s.trim();
        if s.is_empty() {
            return Err(Error::invalid_data("ERR min or max is not a float"));
        }

        let (val_str, is_exclusive) = if let Some(rest) = s.strip_prefix('(') {
            (rest.trim(), true)
        } else if let Some(rest) = s.strip_prefix('[') {
            (rest.trim(), false)
        } else {
            (s, false)
        };

        if val_str.eq_ignore_ascii_case("-inf") || val_str.eq_ignore_ascii_case("-infinity") {
            return Ok((f64::NEG_INFINITY, is_exclusive));
        }
        if val_str.eq_ignore_ascii_case("+inf")
            || val_str.eq_ignore_ascii_case("+infinity")
            || val_str.eq_ignore_ascii_case("inf")
            || val_str.eq_ignore_ascii_case("infinity")
        {
            return Ok((f64::INFINITY, is_exclusive));
        }

        let val = val_str
            .parse::<f64>()
            .map_err(|_| Error::invalid_data("ERR min or max is not a float"))?;
        if val.is_nan() {
            return Err(Error::invalid_data("ERR min or max is not a float"));
        }
        Ok((val, is_exclusive))
    }
}

/// 字典序范围规格（对标 Apache Kvrocks RangeLexSpec，统一用于 ZSet + Hash）
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct RangeLexSpec {
    pub min: Vec<u8>,
    pub max: Vec<u8>,
    pub minex: bool,
    pub maxex: bool,
    pub min_infinite: bool,
    pub max_infinite: bool,
    pub offset: usize,
    pub count: Option<usize>,
    pub reversed: bool,
}

pub use crate::error::ERR_WRONG_TYPE;

impl RangeLexSpec {
    #[inline]
    pub fn new(min: impl Into<Vec<u8>>, max: impl Into<Vec<u8>>) -> Self {
        Self {
            min: min.into(),
            max: max.into(),
            minex: false,
            maxex: false,
            min_infinite: false,
            max_infinite: false,
            offset: 0,
            count: None,
            reversed: false,
        }
    }

    #[inline]
    pub fn unbounded() -> Self {
        Self {
            min_infinite: true,
            max_infinite: true,
            ..Default::default()
        }
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        !self.min_infinite
            && !self.max_infinite
            && (self.min > self.max || (self.min == self.max && (self.minex || self.maxex)))
    }

    #[inline]
    pub fn check(&self, member: &[u8]) -> bool {
        let min_ok = if self.min_infinite {
            true
        } else if self.minex {
            member > self.min.as_slice()
        } else {
            member >= self.min.as_slice()
        };

        let max_ok = if self.max_infinite {
            true
        } else if self.maxex {
            member < self.max.as_slice()
        } else {
            member <= self.max.as_slice()
        };

        min_ok && max_ok
    }

    /// 从 Redis 边界字符串或字节切片构造 RangeLexSpec（严格校验 min 为 -/(/[，max 为 +/(/[）
    pub fn from_bounds(
        min_bound: &[u8],
        max_bound: &[u8],
        offset: usize,
        count: Option<usize>,
    ) -> Result<Self> {
        let (min, minex, min_infinite) = Self::parse_min_bound(min_bound)?;
        let (max, maxex, max_infinite) = Self::parse_max_bound(max_bound)?;
        Ok(Self {
            min,
            max,
            minex,
            maxex,
            min_infinite,
            max_infinite,
            offset,
            count,
            reversed: false,
        })
    }

    /// 解析 Redis 字典序下界（合法的 min 为 "-" 或以 '(' / '[' 开头）
    pub fn parse_min_bound(bound: &[u8]) -> Result<(Vec<u8>, bool, bool)> {
        if bound == b"-" {
            return Ok((Vec::new(), false, true));
        }
        if bound == b"+" {
            return Err(Error::invalid_data(
                "ERR min or max not valid string range item",
            ));
        }
        if let Some(rest) = bound.strip_prefix(b"(") {
            Ok((rest.to_vec(), true, false))
        } else if let Some(rest) = bound.strip_prefix(b"[") {
            Ok((rest.to_vec(), false, false))
        } else {
            Err(Error::invalid_data(
                "ERR min or max not valid string range item",
            ))
        }
    }

    /// 解析 Redis 字典序上界（合法的 max 为 "+" 或以 '(' / '[' 开头）
    pub fn parse_max_bound(bound: &[u8]) -> Result<(Vec<u8>, bool, bool)> {
        if bound == b"+" {
            return Ok((Vec::new(), false, true));
        }
        if bound == b"-" {
            return Err(Error::invalid_data(
                "ERR min or max not valid string range item",
            ));
        }
        if let Some(rest) = bound.strip_prefix(b"(") {
            Ok((rest.to_vec(), true, false))
        } else if let Some(rest) = bound.strip_prefix(b"[") {
            Ok((rest.to_vec(), false, false))
        } else {
            Err(Error::invalid_data(
                "ERR min or max not valid string range item",
            ))
        }
    }

    /// 通用解析 Redis 字典序边界（支持 "-", "+", "(abc", "[abc"）
    pub fn parse_bound(bound: &[u8]) -> Result<(Vec<u8>, bool, bool)> {
        if bound == b"-" {
            return Ok((Vec::new(), false, true));
        }
        if bound == b"+" {
            return Ok((Vec::new(), false, true));
        }
        if let Some(rest) = bound.strip_prefix(b"(") {
            Ok((rest.to_vec(), true, false))
        } else if let Some(rest) = bound.strip_prefix(b"[") {
            Ok((rest.to_vec(), false, false))
        } else {
            Err(Error::invalid_data(
                "ERR min or max not valid string range item",
            ))
        }
    }
}

/// 排名范围规格（对标 Apache Kvrocks RangeRankSpec）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct RangeRankSpec {
    pub start: i64,
    pub stop: i64,
    pub reversed: bool,
}

impl RangeRankSpec {
    #[inline]
    pub fn new(start: i64, stop: i64) -> Self {
        Self {
            start,
            stop,
            reversed: false,
        }
    }

    #[inline]
    pub fn rev(start: i64, stop: i64) -> Self {
        Self {
            start,
            stop,
            reversed: true,
        }
    }
}

/// 统一 ZRANGE 选项配置（对标 Redis 6.2+ ZRANGE 全参选项）
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ZRangeSpec {
    pub by_score: bool,
    pub by_lex: bool,
    pub rev: bool,
    pub with_scores: bool,
    pub offset: usize,
    pub count: Option<usize>,
}

pub type ZRange = ZRangeSpec;