gy_r_number 0.1.0

use num_bigint::BigInt;
use num_rational::BigRational;
use num_traits::{Bounded, FromPrimitive, One, Signed, ToPrimitive, Zero};
use std::error::Error;
use std::fmt;
use std::ops::{Add, Div, Mul, Neg, Sub};
use std::str::FromStr;

// 后备值策略枚举
#[derive(Debug, Clone, PartialEq)]
pub enum FallbackValue<T> {
    /// 使用零值
    Zero,
    /// 使用类型最小值
    Min,
    /// 使用类型最大值
    Max,
    /// 饱和转换：超出上界用最大值，超出下界用最小值
    Saturating,
    /// 用户自定义值
    Custom(T),
    /// 截断转换：保留能表示的部分
    Truncate,
}

impl<T> FallbackValue<T>
where
    T: Bounded + Zero + Copy + PartialOrd + ToPrimitive + FromPrimitive,
{
    /// 根据策略获取后备值
    pub fn get_value(&self, original_value: Option<f64>) -> T {
        match self {
            FallbackValue::Zero => T::zero(),
            FallbackValue::Min => T::min_value(),
            FallbackValue::Max => T::max_value(),
            FallbackValue::Custom(value) => *value,
            FallbackValue::Saturating => {
                if let Some(orig) = original_value {
                    let min_f64 = T::min_value().to_f64().unwrap_or(f64::NEG_INFINITY);
                    let max_f64 = T::max_value().to_f64().unwrap_or(f64::INFINITY);

                    if orig < min_f64 {
                        T::min_value()
                    } else if orig > max_f64 {
                        T::max_value()
                    } else {
                        T::zero() // 如果在范围内但转换失败，使用零值
                    }
                } else {
                    T::zero()
                }
            }
            FallbackValue::Truncate => {
                if let Some(orig) = original_value {
                    // 尝试截断转换
                    if let Some(truncated) = T::from_f64(orig.trunc()) {
                        truncated
                    } else {
                        T::zero()
                    }
                } else {
                    T::zero()
                }
            }
        }
    }

    /// 获取策略描述
    pub fn description(&self) -> String {
        match self {
            FallbackValue::Zero => "零值".to_string(),
            FallbackValue::Min => "类型最小值".to_string(),
            FallbackValue::Max => "类型最大值".to_string(),
            FallbackValue::Saturating => "饱和转换".to_string(),
            FallbackValue::Custom(value) => format!(
                "自定义值 {}",
                value
                    .to_f64()
                    .map(|v| v.to_string())
                    .unwrap_or("N/A".to_string())
            ),
            FallbackValue::Truncate => "截断转换".to_string(),
        }
    }
}

// 自定义错误类型
#[derive(Debug, Clone, PartialEq)]
pub enum NumberError {
    PrecisionLoss {
        original: String,
        converted: String,
        target_type: String,
    },
    OutOfRange {
        value: String,
        target_type: String,
        min: String,
        max: String,
    },
    InvalidConversion {
        from_type: String,
        to_type: String,
        reason: String,
    },
    DivisionByZero,
    InvalidOperation(String),
}

impl fmt::Display for NumberError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            NumberError::PrecisionLoss {
                original,
                converted,
                target_type,
            } => {
                write!(
                    f,
                    "精度丢失: 原始值 {} 转换为 {} 类型后变成 {}",
                    original, target_type, converted
                )
            }
            NumberError::OutOfRange {
                value,
                target_type,
                min,
                max,
            } => {
                write!(
                    f,
                    "超出范围: 值 {} 超出 {} 类型范围 [{}, {}]",
                    value, target_type, min, max
                )
            }
            NumberError::InvalidConversion {
                from_type,
                to_type,
                reason,
            } => {
                write!(
                    f,
                    "无效转换: 无法从 {} 转换为 {} - {}",
                    from_type, to_type, reason
                )
            }
            NumberError::DivisionByZero => {
                write!(f, "除零错误: 不能除以零")
            }
            NumberError::InvalidOperation(msg) => {
                write!(f, "无效操作: {}", msg)
            }
        }
    }
}

impl Error for NumberError {}

// Result 类型别名
pub type NumberResult<T> = Result<T, NumberError>;

// 转换结果，包含值和可能使用的后备策略
#[derive(Debug, Clone, PartialEq)]
pub struct ConversionResult<T> {
    pub value: T,
    pub used_fallback: Option<String>,
    pub had_error: bool,
    pub original_error: Option<NumberError>,
}

impl<T> ConversionResult<T> {
    pub fn success(value: T) -> Self {
        ConversionResult {
            value,
            used_fallback: None,
            had_error: false,
            original_error: None,
        }
    }

    pub fn with_fallback(value: T, fallback_desc: String, error: NumberError) -> Self {
        ConversionResult {
            value,
            used_fallback: Some(fallback_desc),
            had_error: true,
            original_error: Some(error),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Number {
    // 大整数 - 支持任意大小
    BigInteger(BigInt),
    // 大有理数 - 支持任意精度的分数
    BigRational(BigRational),
    // 浮点数 - 用于特殊值和快速运算
    Float(f64),
    // 特殊值
    NaN,
    PositiveInfinity,
    NegativeInfinity,
}

impl Number {
    // 泛型构造函数 - 支持任意数字类型
    pub fn new<T>(value: T) -> Self
    where
        T: ToPrimitive + Clone,
    {
        if let Some(f64_val) = value.to_f64() {
            if f64_val.is_nan() {
                Number::NaN
            } else if f64_val.is_infinite() {
                if f64_val.is_sign_positive() {
                    Number::PositiveInfinity
                } else {
                    Number::NegativeInfinity
                }
            } else if f64_val.fract() == 0.0 {
                // 如果是整数，使用 BigInt
                if let Some(big_int) = BigInt::from_f64(f64_val) {
                    Number::BigInteger(big_int)
                } else {
                    Number::Float(f64_val)
                }
            } else {
                // 如果是小数，尝试转换为精确的有理数
                Number::from_decimal_string(&f64_val.to_string())
            }
        } else {
            Number::NaN
        }
    }

    // 泛型整数构造函数
    pub fn from_integer<T>(value: T) -> Self
    where
        T: ToPrimitive + Clone,
    {
        if let Some(i64_val) = value.to_i64() {
            Number::BigInteger(BigInt::from(i64_val))
        } else if let Some(f64_val) = value.to_f64() {
            if let Some(big_int) = BigInt::from_f64(f64_val) {
                Number::BigInteger(big_int)
            } else {
                Number::NaN
            }
        } else {
            Number::NaN
        }
    }

    // 泛型浮点数构造函数
    pub fn from_float<T>(value: T) -> Self
    where
        T: ToPrimitive,
    {
        if let Some(f64_val) = value.to_f64() {
            Number::new(f64_val)
        } else {
            Number::NaN
        }
    }

    // 从字符串创建精确的有理数
    fn from_decimal_string(s: &str) -> Self {
        if let Ok(rational) = s.parse::<BigRational>() {
            Number::BigRational(rational)
        } else if let Ok(float) = s.parse::<f64>() {
            Number::Float(float)
        } else {
            Number::NaN
        }
    }

    // 创建大整数
    pub fn from_big_int(value: BigInt) -> Self {
        Number::BigInteger(value)
    }

    // 创建任意精度有理数
    pub fn from_rational(numerator: BigInt, denominator: BigInt) -> Self {
        if denominator.is_zero() {
            Number::NaN
        } else {
            Number::BigRational(BigRational::new(numerator, denominator))
        }
    }

    // 从字符串创建大整数
    pub fn from_big_int_str(s: &str, radix: u32) -> Self {
        match BigInt::parse_bytes(s.as_bytes(), radix) {
            Some(big_int) => Number::BigInteger(big_int),
            None => Number::NaN,
        }
    }

    pub fn from_int(value: i64) -> Self {
        Number::BigInteger(BigInt::from(value))
    }

    // 静态方法，类似 JS 的 Number.parseInt，支持任意大小
    pub fn parse_int(s: &str, radix: Option<u32>) -> Self {
        let radix = radix.unwrap_or(10);
        if let Some(big_int) = BigInt::parse_bytes(s.trim().as_bytes(), radix) {
            Number::BigInteger(big_int)
        } else {
            Number::NaN
        }
    }

    // 静态方法，类似 JS 的 Number.parseFloat，支持任意精度
    pub fn parse_float(s: &str) -> Self {
        Number::from_decimal_string(s.trim())
    }

    // 判断是否为 NaN
    pub fn is_nan(&self) -> bool {
        matches!(self, Number::NaN)
    }

    // 判断是否为无穷大
    pub fn is_infinite(&self) -> bool {
        matches!(self, Number::PositiveInfinity | Number::NegativeInfinity)
    }

    // 判断是否为有限数
    pub fn is_finite(&self) -> bool {
        !self.is_nan() && !self.is_infinite()
    }

    // 判断是否为整数
    pub fn is_integer(&self) -> bool {
        match self {
            Number::BigInteger(_) => true,
            Number::BigRational(r) => r.denom() == &BigInt::one(),
            Number::Float(f) => f.fract() == 0.0,
            _ => false,
        }
    }

    // 获取类型名称
    fn get_type_name(&self) -> &'static str {
        match self {
            Number::BigInteger(_) => "BigInteger",
            Number::BigRational(_) => "BigRational",
            Number::Float(_) => "Float",
            Number::NaN => "NaN",
            Number::PositiveInfinity => "PositiveInfinity",
            Number::NegativeInfinity => "NegativeInfinity",
        }
    }

    // 检查精度丢失的泛型转换方法
    pub fn try_to<T>(&self) -> NumberResult<T>
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy,
    {
        let type_name = std::any::type_name::<T>();

        match self {
            Number::BigInteger(i) => {
                // 先尝试直接转换
                if let Some(result) = T::from_i64(i.to_i64().unwrap_or(i64::MAX)) {
                    // 检查是否有精度丢失
                    let back_converted = Number::new(result);
                    if back_converted == *self {
                        Ok(result)
                    } else {
                        Err(NumberError::PrecisionLoss {
                            original: self.to_string(),
                            converted: result.to_string(),
                            target_type: type_name.to_string(),
                        })
                    }
                } else {
                    // 尝试浮点数转换
                    if let Some(f64_val) = i.to_f64() {
                        if let Some(result) = T::from_f64(f64_val) {
                            Err(NumberError::PrecisionLoss {
                                original: self.to_string(),
                                converted: result.to_string(),
                                target_type: type_name.to_string(),
                            })
                        } else {
                            Err(NumberError::OutOfRange {
                                value: self.to_string(),
                                target_type: type_name.to_string(),
                                min: "类型最小值".to_string(),
                                max: "类型最大值".to_string(),
                            })
                        }
                    } else {
                        Err(NumberError::OutOfRange {
                            value: self.to_string(),
                            target_type: type_name.to_string(),
                            min: "类型最小值".to_string(),
                            max: "类型最大值".to_string(),
                        })
                    }
                }
            }
            Number::BigRational(r) => {
                if let Some(f64_val) = r.to_f64() {
                    if let Some(result) = T::from_f64(f64_val) {
                        // 总是认为有理数转浮点数有精度丢失
                        Err(NumberError::PrecisionLoss {
                            original: self.to_fraction_string(),
                            converted: result.to_string(),
                            target_type: type_name.to_string(),
                        })
                    } else {
                        Err(NumberError::OutOfRange {
                            value: self.to_string(),
                            target_type: type_name.to_string(),
                            min: "类型最小值".to_string(),
                            max: "类型最大值".to_string(),
                        })
                    }
                } else {
                    Err(NumberError::InvalidConversion {
                        from_type: self.get_type_name().to_string(),
                        to_type: type_name.to_string(),
                        reason: "无法转换为浮点数".to_string(),
                    })
                }
            }
            Number::Float(f) => {
                if let Some(result) = T::from_f64(*f) {
                    Ok(result)
                } else {
                    Err(NumberError::OutOfRange {
                        value: self.to_string(),
                        target_type: type_name.to_string(),
                        min: "类型最小值".to_string(),
                        max: "类型最大值".to_string(),
                    })
                }
            }
            Number::NaN => {
                if let Some(result) = T::from_f64(f64::NAN) {
                    Ok(result)
                } else {
                    Err(NumberError::InvalidConversion {
                        from_type: "NaN".to_string(),
                        to_type: type_name.to_string(),
                        reason: "目标类型不支持 NaN".to_string(),
                    })
                }
            }
            Number::PositiveInfinity => {
                if let Some(result) = T::from_f64(f64::INFINITY) {
                    Ok(result)
                } else {
                    Err(NumberError::InvalidConversion {
                        from_type: "PositiveInfinity".to_string(),
                        to_type: type_name.to_string(),
                        reason: "目标类型不支持无穷大".to_string(),
                    })
                }
            }
            Number::NegativeInfinity => {
                if let Some(result) = T::from_f64(f64::NEG_INFINITY) {
                    Ok(result)
                } else {
                    Err(NumberError::InvalidConversion {
                        from_type: "NegativeInfinity".to_string(),
                        to_type: type_name.to_string(),
                        reason: "目标类型不支持负无穷大".to_string(),
                    })
                }
            }
        }
    }

    // 泛型转换方法 - 转换为任意数字类型（保持向后兼容）
    pub fn to<T>(&self) -> Option<T>
    where
        T: FromPrimitive,
    {
        match self {
            Number::BigInteger(i) => {
                if let Some(i64_val) = i.to_i64() {
                    T::from_i64(i64_val)
                } else if let Some(f64_val) = i.to_f64() {
                    T::from_f64(f64_val)
                } else {
                    None
                }
            }
            Number::BigRational(r) => {
                if let Some(f64_val) = r.to_f64() {
                    T::from_f64(f64_val)
                } else {
                    None
                }
            }
            Number::Float(f) => T::from_f64(*f),
            Number::NaN => T::from_f64(f64::NAN),
            Number::PositiveInfinity => T::from_f64(f64::INFINITY),
            Number::NegativeInfinity => T::from_f64(f64::NEG_INFINITY),
        }
    }

    // 使用指定后备策略的转换方法
    pub fn convert_with_fallback<T>(&self, fallback: FallbackValue<T>) -> ConversionResult<T>
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        match self.try_to::<T>() {
            Ok(value) => ConversionResult::success(value),
            Err(error) => {
                let fallback_value = fallback.get_value(Some(self.to_f64()));
                ConversionResult::with_fallback(fallback_value, fallback.description(), error)
            }
        }
    }

    // 强制解包 - 使用指定的后备策略
    pub fn unwrap_with_strategy<T>(&self, fallback: FallbackValue<T>) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.convert_with_fallback(fallback).value
    }

    // 强制解包 - 即使有精度丢失也返回值（使用零值作为后备）
    pub fn unwrap_or_lossy<T>(&self) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.unwrap_with_strategy(FallbackValue::Zero)
    }

    // 饱和转换 - 超出范围时使用边界值
    pub fn unwrap_saturating<T>(&self) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.unwrap_with_strategy(FallbackValue::Saturating)
    }

    // 截断转换 - 去掉小数部分
    pub fn unwrap_truncating<T>(&self) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.unwrap_with_strategy(FallbackValue::Truncate)
    }

    // 使用自定义后备值的转换
    pub fn unwrap_or<T>(&self, default_value: T) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.unwrap_with_strategy(FallbackValue::Custom(default_value))
    }

    // 带错误信息的强制解包 - 支持不同策略
    pub fn unwrap_with_warning<T>(&self, fallback: FallbackValue<T>) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        let result = self.convert_with_fallback(fallback);

        if result.had_error {
            if let Some(error) = &result.original_error {
                println!("⚠️  转换警告: {}", error);
            }
            if let Some(fallback_desc) = &result.used_fallback {
                println!("🔧 使用后备策略: {} -> {}", fallback_desc, result.value);
            }
        } else {
            println!("✅ 转换成功: {} -> {}", self, result.value);
        }

        result.value
    }

    // 默认的带警告转换（使用零值后备）
    pub fn unwrap_with_default_warning<T>(&self) -> T
    where
        T: FromPrimitive + ToPrimitive + fmt::Display + Copy + Bounded + Zero + PartialOrd,
    {
        self.unwrap_with_warning(FallbackValue::Zero)
    }

    // 安全转换 - 如果转换失败返回默认值
    pub fn to_safe<T>(&self) -> T
    where
        T: FromPrimitive + Default,
    {
        self.to::<T>().unwrap_or_else(|| T::default())
    }

    // 带错误检查的除法
    pub fn try_div(&self, other: &Number) -> NumberResult<Number> {
        match other {
            Number::BigInteger(b) if b.is_zero() => Err(NumberError::DivisionByZero),
            Number::BigRational(r) if r.is_zero() => Err(NumberError::DivisionByZero),
            Number::Float(f) if *f == 0.0 => Err(NumberError::DivisionByZero),
            _ => Ok(self / other), // 现在可以直接使用引用运算符
        }
    }

    // 转换为 f64（可能丢失精度）
    pub fn to_f64(&self) -> f64 {
        match self {
            Number::BigInteger(i) => i.to_f64().unwrap_or(f64::INFINITY),
            Number::BigRational(r) => r.to_f64().unwrap_or(f64::NAN),
            Number::Float(f) => *f,
            Number::NaN => f64::NAN,
            Number::PositiveInfinity => f64::INFINITY,
            Number::NegativeInfinity => f64::NEG_INFINITY,
        }
    }

    // 获取内存使用情况（字节数的估计）
    pub fn memory_size(&self) -> usize {
        match self {
            Number::BigInteger(i) => {
                // BigInt 内部使用 Vec<u32>，每个 u32 是 4 字节
                i.to_u32_digits().1.len() * 4
            }
            Number::BigRational(r) => {
                // 分子和分母的大小之和
                let num_size = r.numer().to_u32_digits().1.len() * 4;
                let den_size = r.denom().to_u32_digits().1.len() * 4;
                num_size + den_size
            }
            Number::Float(_) => 8, // f64 是 8 字节
            _ => 0,                // 特殊值不占用额外内存
        }
    }

    // 转换为字符串
    pub fn to_string(&self) -> String {
        match self {
            Number::BigInteger(i) => i.to_string(),
            Number::BigRational(r) => {
                if r.denom() == &BigInt::one() {
                    r.numer().to_string()
                } else {
                    // 尝试转换为小数表示
                    if let Some(f) = r.to_f64() {
                        f.to_string()
                    } else {
                        format!("{}/{}", r.numer(), r.denom())
                    }
                }
            }
            Number::Float(f) => f.to_string(),
            Number::NaN => "NaN".to_string(),
            Number::PositiveInfinity => "Infinity".to_string(),
            Number::NegativeInfinity => "-Infinity".to_string(),
        }
    }

    // 获取精确的分数表示
    pub fn to_fraction_string(&self) -> String {
        match self {
            Number::BigInteger(i) => format!("{}/1", i),
            Number::BigRational(r) => format!("{}/{}", r.numer(), r.denom()),
            _ => self.to_string(),
        }
    }

    // 取绝对值
    pub fn abs(&self) -> Self {
        match self {
            Number::BigInteger(i) => Number::BigInteger(i.abs()),
            Number::BigRational(r) => Number::BigRational(r.abs()),
            Number::Float(f) => Number::Float(f.abs()),
            Number::NaN => Number::NaN,
            Number::PositiveInfinity => Number::PositiveInfinity,
            Number::NegativeInfinity => Number::PositiveInfinity,
        }
    }

    // 向上取整
    pub fn ceil(&self) -> Self {
        match self {
            Number::BigInteger(i) => Number::BigInteger(i.clone()),
            Number::BigRational(r) => Number::BigInteger(r.ceil().to_integer()),
            Number::Float(f) => Number::new(f.ceil()),
            Number::NaN => Number::NaN,
            Number::PositiveInfinity => Number::PositiveInfinity,
            Number::NegativeInfinity => Number::NegativeInfinity,
        }
    }

    // 向下取整
    pub fn floor(&self) -> Self {
        match self {
            Number::BigInteger(i) => Number::BigInteger(i.clone()),
            Number::BigRational(r) => Number::BigInteger(r.floor().to_integer()),
            Number::Float(f) => Number::new(f.floor()),
            Number::NaN => Number::NaN,
            Number::PositiveInfinity => Number::PositiveInfinity,
            Number::NegativeInfinity => Number::NegativeInfinity,
        }
    }

    // 四舍五入
    pub fn round(&self) -> Self {
        match self {
            Number::BigInteger(i) => Number::BigInteger(i.clone()),
            Number::BigRational(r) => Number::BigInteger(r.round().to_integer()),
            Number::Float(f) => Number::new(f.round()),
            Number::NaN => Number::NaN,
            Number::PositiveInfinity => Number::PositiveInfinity,
            Number::NegativeInfinity => Number::NegativeInfinity,
        }
    }

    // 幂运算（支持大数）
    pub fn pow(&self, exponent: &Number) -> Self {
        match (self, exponent) {
            (Number::BigInteger(base), Number::BigInteger(exp)) => {
                if let Some(exp_u32) = exp.to_u32() {
                    Number::BigInteger(base.pow(exp_u32))
                } else {
                    // 指数太大，转换为浮点数计算
                    let base_f64 = self.to_f64();
                    let exp_f64 = exponent.to_f64();
                    Number::new(base_f64.powf(exp_f64))
                }
            }
            _ => {
                let base_f64 = self.to_f64();
                let exp_f64 = exponent.to_f64();
                Number::new(base_f64.powf(exp_f64))
            }
        }
    }

    // 平方根
    pub fn sqrt(&self) -> Self {
        Number::new(self.to_f64().sqrt())
    }
}

// 实现 Display trait
impl fmt::Display for Number {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

// 实现加法
impl Add for Number {
    type Output = Number;

    fn add(self, other: Number) -> Number {
        match (&self, &other) {
            (Number::NaN, _) | (_, Number::NaN) => Number::NaN,
            (Number::PositiveInfinity, Number::NegativeInfinity)
            | (Number::NegativeInfinity, Number::PositiveInfinity) => Number::NaN,
            (Number::PositiveInfinity, _) | (_, Number::PositiveInfinity) => {
                Number::PositiveInfinity
            }
            (Number::NegativeInfinity, _) | (_, Number::NegativeInfinity) => {
                Number::NegativeInfinity
            }
            (Number::BigInteger(a), Number::BigInteger(b)) => Number::BigInteger(a + b),
            (Number::BigRational(a), Number::BigRational(b)) => Number::BigRational(a + b),
            (Number::BigInteger(a), Number::BigRational(b)) => {
                Number::BigRational(BigRational::from(a.clone()) + b)
            }
            (Number::BigRational(a), Number::BigInteger(b)) => {
                Number::BigRational(a + BigRational::from(b.clone()))
            }
            _ => Number::new(self.to_f64() + other.to_f64()),
        }
    }
}

// 实现减法
impl Sub for Number {
    type Output = Number;

    fn sub(self, other: Number) -> Number {
        match (&self, &other) {
            (Number::NaN, _) | (_, Number::NaN) => Number::NaN,
            (Number::PositiveInfinity, Number::PositiveInfinity)
            | (Number::NegativeInfinity, Number::NegativeInfinity) => Number::NaN,
            (Number::PositiveInfinity, _) => Number::PositiveInfinity,
            (Number::NegativeInfinity, _) => Number::NegativeInfinity,
            (_, Number::PositiveInfinity) => Number::NegativeInfinity,
            (_, Number::NegativeInfinity) => Number::PositiveInfinity,
            (Number::BigInteger(a), Number::BigInteger(b)) => Number::BigInteger(a - b),
            (Number::BigRational(a), Number::BigRational(b)) => Number::BigRational(a - b),
            (Number::BigInteger(a), Number::BigRational(b)) => {
                Number::BigRational(BigRational::from(a.clone()) - b)
            }
            (Number::BigRational(a), Number::BigInteger(b)) => {
                Number::BigRational(a - BigRational::from(b.clone()))
            }
            _ => Number::new(self.to_f64() - other.to_f64()),
        }
    }
}

// 实现乘法
impl Mul for Number {
    type Output = Number;

    fn mul(self, other: Number) -> Number {
        match (&self, &other) {
            (Number::NaN, _) | (_, Number::NaN) => Number::NaN,
            (Number::BigInteger(a), Number::BigInteger(b)) => Number::BigInteger(a * b),
            (Number::BigRational(a), Number::BigRational(b)) => Number::BigRational(a * b),
            (Number::BigInteger(a), Number::BigRational(b)) => {
                Number::BigRational(BigRational::from(a.clone()) * b)
            }
            (Number::BigRational(a), Number::BigInteger(b)) => {
                Number::BigRational(a * BigRational::from(b.clone()))
            }
            _ => {
                let result = self.to_f64() * other.to_f64();
                Number::new(result)
            }
        }
    }
}

// 实现除法
impl Div for Number {
    type Output = Number;

    fn div(self, other: Number) -> Number {
        match (&self, &other) {
            (Number::NaN, _) | (_, Number::NaN) => Number::NaN,
            (_, Number::BigInteger(b)) if b.is_zero() => {
                if self.to_f64() > 0.0 {
                    Number::PositiveInfinity
                } else if self.to_f64() < 0.0 {
                    Number::NegativeInfinity
                } else {
                    Number::NaN
                }
            }
            (Number::BigInteger(a), Number::BigInteger(b)) => {
                Number::BigRational(BigRational::new(a.clone(), b.clone()))
            }
            (Number::BigRational(a), Number::BigRational(b)) => Number::BigRational(a / b),
            (Number::BigInteger(a), Number::BigRational(b)) => {
                Number::BigRational(BigRational::from(a.clone()) / b)
            }
            (Number::BigRational(a), Number::BigInteger(b)) => {
                Number::BigRational(a / BigRational::from(b.clone()))
            }
            _ => {
                let result = self.to_f64() / other.to_f64();
                Number::new(result)
            }
        }
    }
}

// 实现负号
impl Neg for Number {
    type Output = Number;

    fn neg(self) -> Number {
        match self {
            Number::BigInteger(i) => Number::BigInteger(-i),
            Number::BigRational(r) => Number::BigRational(-r),
            Number::Float(f) => Number::Float(-f),
            Number::NaN => Number::NaN,
            Number::PositiveInfinity => Number::NegativeInfinity,
            Number::NegativeInfinity => Number::PositiveInfinity,
        }
    }
}

// 添加对引用的负号支持
impl Neg for &Number {
    type Output = Number;

    fn neg(self) -> Number {
        -self.clone()
    }
}

// 添加对引用的加法支持
impl Add<&Number> for Number {
    type Output = Number;

    fn add(self, other: &Number) -> Number {
        self + other.clone()
    }
}

impl Add<Number> for &Number {
    type Output = Number;

    fn add(self, other: Number) -> Number {
        self.clone() + other
    }
}

impl Add<&Number> for &Number {
    type Output = Number;

    fn add(self, other: &Number) -> Number {
        self.clone() + other.clone()
    }
}

// 添加对引用的减法支持
impl Sub<&Number> for Number {
    type Output = Number;

    fn sub(self, other: &Number) -> Number {
        self - other.clone()
    }
}

impl Sub<Number> for &Number {
    type Output = Number;

    fn sub(self, other: Number) -> Number {
        self.clone() - other
    }
}

impl Sub<&Number> for &Number {
    type Output = Number;

    fn sub(self, other: &Number) -> Number {
        self.clone() - other.clone()
    }
}

// 添加对引用的乘法支持
impl Mul<&Number> for Number {
    type Output = Number;

    fn mul(self, other: &Number) -> Number {
        self * other.clone()
    }
}

impl Mul<Number> for &Number {
    type Output = Number;

    fn mul(self, other: Number) -> Number {
        self.clone() * other
    }
}

impl Mul<&Number> for &Number {
    type Output = Number;

    fn mul(self, other: &Number) -> Number {
        self.clone() * other.clone()
    }
}

// 添加对引用的除法支持
impl Div<&Number> for Number {
    type Output = Number;

    fn div(self, other: &Number) -> Number {
        self / other.clone()
    }
}

impl Div<Number> for &Number {
    type Output = Number;

    fn div(self, other: Number) -> Number {
        self.clone() / other
    }
}

impl Div<&Number> for &Number {
    type Output = Number;

    fn div(self, other: &Number) -> Number {
        self.clone() / other.clone()
    }
}

// 从字符串解析
impl FromStr for Number {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Number::parse_float(s))
    }
}

// 从各种数字类型转换 - 为每个类型单独实现
impl From<i8> for Number {
    fn from(value: i8) -> Self {
        Number::new(value)
    }
}

impl From<i16> for Number {
    fn from(value: i16) -> Self {
        Number::new(value)
    }
}

impl From<i32> for Number {
    fn from(value: i32) -> Self {
        Number::new(value)
    }
}

impl From<i64> for Number {
    fn from(value: i64) -> Self {
        Number::new(value)
    }
}

impl From<i128> for Number {
    fn from(value: i128) -> Self {
        Number::new(value)
    }
}

impl From<u8> for Number {
    fn from(value: u8) -> Self {
        Number::new(value)
    }
}

impl From<u16> for Number {
    fn from(value: u16) -> Self {
        Number::new(value)
    }
}

impl From<u32> for Number {
    fn from(value: u32) -> Self {
        Number::new(value)
    }
}

impl From<u64> for Number {
    fn from(value: u64) -> Self {
        Number::new(value)
    }
}

impl From<u128> for Number {
    fn from(value: u128) -> Self {
        Number::new(value)
    }
}

impl From<f32> for Number {
    fn from(value: f32) -> Self {
        Number::new(value)
    }
}

impl From<f64> for Number {
    fn from(value: f64) -> Self {
        Number::new(value)
    }
}

impl From<isize> for Number {
    fn from(value: isize) -> Self {
        Number::new(value)
    }
}

impl From<usize> for Number {
    fn from(value: usize) -> Self {
        Number::new(value)
    }
}

impl From<BigInt> for Number {
    fn from(value: BigInt) -> Self {
        Number::BigInteger(value)
    }
}

impl From<BigRational> for Number {
    fn from(value: BigRational) -> Self {
        Number::BigRational(value)
    }
}