wedb_embed 0.1.2

/// 距离计算单位（对标 Kvrocks DistanceUnit）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, bitcode::Encode, bitcode::Decode)]
pub enum DistanceUnit {
  #[default]
  Meters,
  Kilometers,
  Miles,
  Feet,
}

impl DistanceUnit {
  /// 米与各单位的转换系数（编译期常量函数）
  #[inline]
  pub const fn conversion_factor(&self) -> f64 {
    match self {
      Self::Meters => 1.0,
      Self::Kilometers => 1000.0,
      Self::Miles => 1609.34,
      Self::Feet => 0.3048,
    }
  }

  /// 解析距离单位字符串（零内存分配）
  #[inline]
  pub fn parse(s: &str) -> Option<Self> {
    if s.eq_ignore_ascii_case("m") {
      Some(Self::Meters)
    } else if s.eq_ignore_ascii_case("km") {
      Some(Self::Kilometers)
    } else if s.eq_ignore_ascii_case("mi") {
      Some(Self::Miles)
    } else if s.eq_ignore_ascii_case("ft") {
      Some(Self::Feet)
    } else {
      None
    }
  }

  /// 转换为米
  #[inline]
  pub const fn to_meters(&self, dist: f64) -> f64 {
    dist * self.conversion_factor()
  }

  /// 从米转换为当前单位数值
  #[inline]
  pub const fn from_meters(&self, meters: f64) -> f64 {
    meters / self.conversion_factor()
  }
}

/// 空间结果排序方式（对标 Kvrocks DistanceSort）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, bitcode::Encode, bitcode::Decode)]
pub enum DistanceSort {
  #[default]
  None,
  Asc,
  Desc,
}

impl DistanceSort {
  /// 解析排序方式字符串（零内存分配）
  #[inline]
  pub fn parse(s: &str) -> Option<Self> {
    if s.eq_ignore_ascii_case("asc") {
      Some(Self::Asc)
    } else if s.eq_ignore_ascii_case("desc") {
      Some(Self::Desc)
    } else {
      None
    }
  }
}

/// 空间查询原点类型（对标 Kvrocks OriginPointType）
#[derive(Debug, Clone, PartialEq, bitcode::Encode, bitcode::Decode)]
pub enum OriginPoint {
  Coord { lon: f64, lat: f64 },
  Member(String),
}

impl OriginPoint {
  #[inline]
  pub const fn coord(lon: f64, lat: f64) -> Self {
    Self::Coord { lon, lat }
  }

  #[inline]
  pub fn member(m: impl Into<String>) -> Self {
    Self::Member(m.into())
  }
}

/// 地理点详细信息（对标 Kvrocks GeoPoint）
#[derive(Debug, Clone, PartialEq, Default, bitcode::Encode, bitcode::Decode)]
pub struct GeoPoint {
  pub longitude: f64,
  pub latitude: f64,
  pub member: String,
  pub dist: f64,
  pub score: f64,
}

/// Geohash 比特结构（对标 Kvrocks GeoHashBits）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct GeoHashBits {
  pub bits: u64,
  pub step: u8,
}

impl GeoHashBits {
  #[inline]
  pub const fn is_zero(&self) -> bool {
    self.bits == 0 && self.step == 0
  }
}

/// 经纬度范围（对标 Kvrocks GeoHashRange）
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct GeoHashRange {
  pub min: f64,
  pub max: f64,
}

impl GeoHashRange {
  #[inline]
  pub const fn is_zero(&self) -> bool {
    self.min == 0.0 && self.max == 0.0
  }
}

/// Geohash 区域结构（对标 Kvrocks GeoHashArea）
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct GeoHashArea {
  pub hash: GeoHashBits,
  pub longitude: GeoHashRange,
  pub latitude: GeoHashRange,
}

/// 8 邻居区域结构（对标 Kvrocks GeoHashNeighbors）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct GeoHashNeighbors {
  pub north: GeoHashBits,
  pub east: GeoHashBits,
  pub west: GeoHashBits,
  pub south: GeoHashBits,
  pub north_east: GeoHashBits,
  pub south_east: GeoHashBits,
  pub north_west: GeoHashBits,
  pub south_west: GeoHashBits,
}

impl GeoHashNeighbors {
  /// 转换为 8 邻居固定数组
  #[inline]
  pub const fn to_array(&self) -> [GeoHashBits; 8] {
    [
      self.north,
      self.south,
      self.east,
      self.west,
      self.north_east,
      self.north_west,
      self.south_east,
      self.south_west,
    ]
  }
}

/// 空间地理范围查询辅助结构（对标 Kvrocks GeoHashRadius）
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct GeoHashRadius {
  pub hash: GeoHashBits,
  pub area: GeoHashArea,
  pub neighbors: GeoHashNeighbors,
}

/// 空间查询形状类型（对标 Kvrocks GeoShapeType）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum GeoShapeType {
  #[default]
  None,
  Circular,
  Rectangular,
}

/// 空间查询几何形状（对标 Kvrocks GeoShape）
#[derive(Debug, Clone, PartialEq)]
pub struct GeoShape {
  pub shape_type: GeoShapeType,
  pub center_lon: f64,
  pub center_lat: f64,
  pub radius: f64,
  pub width: f64,
  pub height: f64,
  pub conversion: f64,
  pub bounds: [f64; 4], // [min_lon, min_lat, max_lon, max_lat]
}

/// 空间地理范围检索选项（对标 Kvrocks Geo::Radius / Search）
#[derive(Debug, Clone, PartialEq, Default, bitcode::Encode, bitcode::Decode)]
pub struct GeoRadiusOption {
  pub with_coord: bool,
  pub with_dist: bool,
  pub with_hash: bool,
  pub count: Option<usize>,
  pub any: bool,
  pub sort: DistanceSort,
  pub store_key: Option<String>,
  pub store_dist_key: Option<String>,
  pub unit: DistanceUnit,
}

/// Geo 搜索选项（对标 Redis 6.2+ GEOSEARCH）
#[derive(Debug, Clone, PartialEq, Default, bitcode::Encode, bitcode::Decode)]
pub struct GeoSearch {
  pub with_coord: bool,
  pub with_dist: bool,
  pub with_hash: bool,
  pub count: Option<usize>,
  pub any: bool,
  pub asc: bool,
  pub sort: DistanceSort,
  pub unit: DistanceUnit,
}

/// GeoSearchStore 选项（对标 Redis 6.2+ GEOSEARCHSTORE）
#[derive(Debug, Clone, PartialEq, Default, bitcode::Encode, bitcode::Decode)]
pub struct GeoSearchStoreOption {
  pub count: Option<usize>,
  pub any: bool,
  pub sort: DistanceSort,
  pub store_dist: bool,
  pub unit: DistanceUnit,
}