uninum 0.1.1

//! Tests for remainder (modulo) operations

use uninum::{Number, num};

/// Tests basic remainder operations
#[test]
fn test_basic_remainder() {
    // Integer remainder
    assert_eq!(Number::from(17u64) % Number::from(5u64), Number::from(2u64));
    assert_eq!(
        Number::from(-17i64) % Number::from(5i64),
        Number::from(-2i64)
    );
    assert_eq!(
        Number::from(17i64) % Number::from(-5i64),
        Number::from(2i64)
    );
    assert_eq!(
        Number::from(-17i64) % Number::from(-5i64),
        Number::from(-2i64)
    );
    assert_eq!(Number::from(31u64) % Number::from(3u64), Number::from(1u64));

    // Float remainder
    let a = num!(17.5);
    let b = num!(5.0);
    assert_eq!(&a % &b, num!(2.5));

    // Mixed type remainder
    assert_eq!(Number::from(17u64) % num!(5.0), num!(2.0));
}

/// Tests the remainder with primitives
#[test]
fn test_remainder_with_primitives() {
    let num = Number::from(10u64);

    // Remainder with various primitive types
    assert_eq!(&num % 3, Number::from(1u64));
    assert_eq!(33 % &num, Number::from(3u64));
    assert_eq!(&num % 3u32, Number::from(1u64));
    assert_eq!(&num % 4i32, Number::from(2u64));
    assert_eq!(&num % 3.0f64, num!(1.0));
}

/// Tests reference semantics for remainder
#[test]
fn test_remainder_reference_semantics() {
    let a = Number::from(17u64);
    let b = Number::from(5u64);

    // All combinations of references and values
    assert_eq!(&a % &b, Number::from(2u64));
    assert_eq!(&a % b.clone(), Number::from(2u64));
    assert_eq!(a.clone() % &b, Number::from(2u64));
    assert_eq!(a.clone() % b.clone(), Number::from(2u64));

    // Verify originals are still usable
    assert_eq!(a, Number::from(17u64));
    assert_eq!(b, Number::from(5u64));
}

/// Tests remainder by zero behavior
#[test]
fn test_remainder_by_zero() {
    // Remainder by zero = NaN
    assert!((Number::from(10u64) % Number::from(0u64)).is_nan());
    assert!((Number::from(-10i64) % Number::from(0i64)).is_nan());
    assert!((num!(10.0) % num!(0.0)).is_nan());
}

/// Tests remainder with special float values
#[test]
fn test_remainder_special_floats() {
    let inf = num!(f64::INFINITY);
    let neg_inf = num!(f64::NEG_INFINITY);
    let nan = num!(f64::NAN);
    let normal = Number::from(42u64);

    // Test special float % normal
    let result = &inf % &normal;
    assert!(result.is_nan()); // inf % x = NaN

    let result = &neg_inf % &normal;
    assert!(result.is_nan()); // -inf % x = NaN

    let result = &nan % &normal;
    assert!(result.is_nan());

    // Test normal % special float
    let result = &normal % &inf;
    assert_eq!(result, Number::from(42u64)); // 42 % inf = 42

    let result = &normal % &neg_inf;
    assert_eq!(result, Number::from(42u64)); // 42 % -inf = 42

    let result = &normal % &nan;
    assert!(result.is_nan());

    // Additional NaN/Infinity tests
    assert!((num!(f64::NAN) % num!(5.0)).is_nan());
    assert!((num!(10.0) % num!(f64::NAN)).is_nan());
    assert!((num!(f64::INFINITY) % num!(5.0)).is_nan());
    assert!((num!(f64::NEG_INFINITY) % num!(5.0)).is_nan());
}

/// Tests remainder with exact results
#[test]
fn test_remainder_exact() {
    // Perfect divisibility
    assert_eq!(Number::from(20u64) % Number::from(4u64), Number::from(0u64));
    assert_eq!(
        Number::from(100u64) % Number::from(10u64),
        Number::from(0u64)
    );
    assert_eq!(
        Number::from(-20i64) % Number::from(4i64),
        Number::from(0i64)
    );

    // Float exact remainder
    assert_eq!(num!(20.0) % num!(4.0), num!(0.0));

    // Special exact cases
    assert_eq!(
        Number::from(100u64) % Number::from(1u64),
        Number::from(0u64)
    );
    assert_eq!(
        Number::from(-100i64) % Number::from(1i64),
        Number::from(0i64)
    );
    assert_eq!(
        Number::from(100i64) % Number::from(-1i64),
        Number::from(0i64)
    );
    assert_eq!(
        Number::from(-100i64) % Number::from(-1i64),
        Number::from(0i64)
    );

    // Self remainder (x % x = 0)
    assert_eq!(
        Number::from(42u64) % Number::from(42u64),
        Number::from(0u64)
    );
    assert_eq!(
        num!(std::f64::consts::PI) % num!(std::f64::consts::PI),
        num!(0.0)
    );

    // Float remainder with 1
    let result = num!(std::f64::consts::PI) % num!(1.0);
    let expected = num!(std::f64::consts::PI % 1.0);
    if let (Some(r), Some(e)) = (result.try_get_f64(), expected.try_get_f64()) {
        assert!((r - e).abs() < 1e-10);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Expected F64 or Decimal results");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Expected F64 result");
        }
    }
}

/// Tests remainder chains
#[test]
fn test_remainder_chains() {
    // Simple chain
    let result = Number::from(100u64) % Number::from(30u64) % Number::from(7u64);
    assert_eq!(result, Number::from(3u64)); // 100 % 30 = 10, 10 % 7 = 3

    // Chain with mixed types
    let result = Number::from(100u64) % Number::from(30u64) % num!(6.0);
    assert_eq!(result, num!(4.0)); // 100 % 30 = 10, 10 % 6.0 = 4.0

    // More complex chain
    let result =
        ((Number::from(100u64) % Number::from(30u64)) % Number::from(7u64)) % Number::from(3u64);
    assert_eq!(result, Number::from(0u64)); // 100 % 30 = 10, 10 % 7 = 3, 3 % 3 = 0

    // Chain with larger numbers
    let result = ((Number::from(1000000u64) % Number::from(1000u64)) % Number::from(100i64))
        % Number::from(10u64);
    assert_eq!(result, Number::from(0u64)); // 1000000 % 1000 = 0, 0 % 100 = 0,
    // 0 %
    // 10 = 0
}

/// Tests small integer type remainder
#[test]
fn test_small_type_remainder() {
    // U64 operations
    let a = Number::from(100u64);
    let b = Number::from(30u64);
    assert_eq!(&a % &b, Number::from(10u64));

    // I64 operations with sign
    let c = Number::from(-100i64);
    let d = Number::from(30i64);
    assert_eq!(&c % &d, Number::from(-10i64));

    // Mixed types
    assert_eq!(
        Number::from(100u64) % Number::from(30u64),
        Number::from(10u64)
    );
    assert_eq!(
        Number::from(-100i64) % Number::from(30i64),
        Number::from(-10i64)
    );
}

#[cfg(feature = "decimal")]
#[test]
fn test_remainder_with_decimal() {
    use rust_decimal::Decimal;

    // Test normal remainder
    let a = Number::from(Decimal::new(17, 0));
    let b = Number::from(Decimal::new(5, 0));
    let result = &a % &b;
    assert!(result.try_get_decimal().is_some());
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(**d, Decimal::new(2, 0));
    }

    // Test remainder by zero
    let zero = Number::from(Decimal::ZERO);
    let result = &a % &zero;
    assert!(result.is_nan());

    // Test remainder with decimal places
    let c = Number::from(Decimal::new(175, 1)); // 17.5
    let d = Number::from(Decimal::new(50, 1)); // 5.0
    let result = &c % &d;
    assert!(result.try_get_decimal().is_some());
    if let Some(d) = result.try_get_decimal() {
        assert_eq!(d.to_string(), "2.5");
    }
}

/// Tests edge cases with negative remainders
#[test]
fn test_negative_remainder_edge_cases() {
    // Rust follows truncated division (remainder has same sign as dividend)
    assert_eq!(Number::from(7i64) % Number::from(3i64), Number::from(1i64));
    assert_eq!(Number::from(7i64) % Number::from(-3i64), Number::from(1i64));
    assert_eq!(
        Number::from(-7i64) % Number::from(3i64),
        Number::from(-1i64)
    );
    assert_eq!(
        Number::from(-7i64) % Number::from(-3i64),
        Number::from(-1i64)
    );

    // Edge case: remainder with MIN values
    let min_i32 = Number::from(i64::from(i32::MIN));
    let neg_one = Number::from(-1i64);
    let result = &min_i32 % &neg_one;
    assert_eq!(result, Number::from(0i64)); // i32::MIN % -1 = 0
}

/// Tests integer overflow cases (MIN % -1 for all signed types)
#[test]
fn test_integer_overflow_cases() {
    // I64::MIN % -1 = 0 (special case to avoid overflow)
    assert_eq!(
        Number::from(i64::from(i32::MIN)) % Number::from(-1i64),
        Number::from(0i64)
    );

    // I64::MIN % -1 = 0
    assert_eq!(
        Number::from(i64::MIN) % Number::from(-1i64),
        Number::from(0i64)
    );

    // Also test with references
    let min_i32 = Number::from(i64::from(i32::MIN));
    let neg_one = Number::from(-1i64);
    assert_eq!(&min_i32 % &neg_one, Number::from(0i64));
}

/// Tests remainder with very large numbers
#[test]
fn test_remainder_large_numbers() {
    // Large U64 remainder
    let large = Number::from(u64::MAX - 1);
    let divisor = Number::from(100u64);
    let result = &large % &divisor;
    assert!(result.try_get_u64().is_some());

    // Very small remainder
    let a = Number::from(1000000001u64);
    let b = Number::from(1000000000u64);
    assert_eq!(&a % &b, Number::from(1u64));

    // Very large number modulo small number
    let large = Number::from(u64::MAX);
    let small = Number::from(10u64);
    let result = large % small;
    assert_eq!(result, Number::from(5u64)); // u64::MAX % 10 = 5

    // Very large float remainder
    let result = num!(1e10) % num!(3.0);
    if let Some(r) = result.try_get_f64() {
        assert!((r - 1.0).abs() < 1e-10);
    } else {
        #[cfg(feature = "decimal")]
        {
            if result.try_get_decimal().is_none() {
                panic!("Expected F64 or Decimal result");
            }
        }
        #[cfg(not(feature = "decimal"))]
        {
            panic!("Expected F64 result");
        }
    }
}

/// Tests float remainder precision
#[test]
fn test_float_remainder_precision() {
    // Test with values that might have precision issues
    let a = num!(10.3);
    let b = num!(3.1);
    let result = &a % &b;
    #[cfg(feature = "decimal")]
    assert!(result.try_get_f64().is_some() || result.try_get_decimal().is_some());
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_f64().is_some());
    if let Some(f) = result.try_get_f64() {
        // 10.3 % 3.1 should be approximately 1.0
        assert!((f - 1.0).abs() < 1e-10);
    }

    // Test with very small divisor
    let c = num!(1.0);
    let d = num!(0.3);
    let result = &c % &d;
    #[cfg(feature = "decimal")]
    assert!(result.try_get_f64().is_some() || result.try_get_decimal().is_some());
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_f64().is_some());
    if let Some(f) = result.try_get_f64() {
        // 1.0 % 0.3 should be approximately 0.1
        assert!((f - 0.1).abs() < 1e-10);
    }
}

/// Tests all numeric type combinations
#[test]
fn test_all_type_combinations() {
    // Create test values for each type
    let u32_val = Number::from(17u64);
    let i32_val = Number::from(-17i64);
    let u64_val = Number::from(17u64);
    let i64_val = Number::from(-17i64);
    let f64_val = num!(17.5);

    // Test unsigned with signed
    assert_eq!(&u32_val % Number::from(5i64), Number::from(2i64));
    assert_eq!(&u64_val % Number::from(5i64), Number::from(2i64));

    // Test signed with unsigned
    assert_eq!(&i32_val % Number::from(5u64), Number::from(-2i64));
    assert_eq!(&i64_val % Number::from(5u64), Number::from(-2i64));

    // Test integer with float
    assert_eq!(&i32_val % &f64_val, num!(-17.0));

    // Test float with integer
    assert_eq!(&f64_val % Number::from(5i64), num!(2.5));
}

/// Tests extended primitive type combinations
#[test]
fn test_extended_primitive_combinations() {
    let num = Number::from(17u64);

    // Test with all unsigned primitive types
    assert_eq!(&num % 5u32, Number::from(2u64));
    assert_eq!(&num % 5u64, Number::from(2u64));
    // usize always converts to U64 (even on 32-bit platforms)
    #[cfg(feature = "decimal")]
    {
        use rust_decimal::Decimal;
        let result = &num % 5usize;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(2, 0));
        }
    }
    #[cfg(not(feature = "decimal"))]
    assert_eq!(&num % 5usize, Number::from(2u64));

    // Test with all signed primitive types
    assert_eq!(&num % 5i32, Number::from(2u64));
    assert_eq!(&num % 5i64, Number::from(2i64));
    // isize always converts to I64 (even on 32-bit platforms)
    #[cfg(feature = "decimal")]
    {
        use rust_decimal::Decimal;
        let result = &num % 5isize;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(2, 0));
        }
    }
    #[cfg(not(feature = "decimal"))]
    assert_eq!(&num % 5isize, Number::from(2i64));

    // Test with float primitives
    assert_eq!(&num % 5.0f64, num!(2.0));

    // Test reverse operations (primitive % Number)
    assert_eq!(33u32 % &num, Number::from(16u64));
    assert_eq!(33u64 % &num, Number::from(16u64));
    assert_eq!(33i32 % &num, Number::from(16u64));
    assert_eq!(-33i32 % &num, Number::from(-16i64));
    assert_eq!(33.5f64 % &num, num!(16.5));

    // Test usize/isize reverse operations (always use 64-bit variants)
    #[cfg(feature = "decimal")]
    {
        use rust_decimal::Decimal;
        let result = 33usize % &num;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(16, 0));
        }
        let result = 33isize % &num;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(16, 0));
        }
    }
    #[cfg(not(feature = "decimal"))]
    {
        assert_eq!(33usize % &num, Number::from(16u64));
        assert_eq!(33isize % &num, Number::from(16i64));
    }
}

/// Tests remainder with usize and isize
/// usize/isize always convert to U64/I64 for consistent behavior across
/// platforms
#[test]
fn test_usize_isize_remainder() {
    // Test Number % usize/isize
    let num = Number::from(100u64);
    #[cfg(feature = "decimal")]
    {
        use rust_decimal::Decimal;
        let result = &num % 30usize;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(10, 0));
        } else if let Some(n) = result.try_get_u64() {
            assert_eq!(n, 10);
        } else {
            panic!("Unexpected result type: {result:?}");
        }
        let result = &num % 30isize;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(10, 0));
        } else if let Some(n) = result.try_get_u64() {
            assert_eq!(n, 10);
        } else {
            panic!("Unexpected result type: {result:?}");
        }
    }
    #[cfg(not(feature = "decimal"))]
    {
        assert_eq!(&num % 30usize, Number::from(10u64));
        assert_eq!(&num % 30isize, Number::from(10i64));
    }

    // Test usize/isize % Number
    let divisor = Number::from(30u64);
    #[cfg(feature = "decimal")]
    {
        use rust_decimal::Decimal;
        let result = 100usize % &divisor;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(10, 0));
        } else if let Some(n) = result.try_get_u64() {
            assert_eq!(n, 10);
        } else {
            panic!("Unexpected result type: {result:?}");
        }
        let result = 100isize % &divisor;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(10, 0));
        } else if let Some(n) = result.try_get_i64() {
            assert_eq!(n, 10);
        } else {
            panic!("Unexpected result type: {result:?}");
        }
        let result = -100isize % &divisor;
        if let Some(d) = result.try_get_decimal() {
            assert_eq!(**d, Decimal::new(-10, 0));
        } else if let Some(n) = result.try_get_i64() {
            assert_eq!(n, -10);
        } else {
            panic!("Unexpected result type: {result:?}");
        }
    }
    #[cfg(not(feature = "decimal"))]
    {
        assert_eq!(100usize % &divisor, Number::from(10u64));
        assert_eq!(100isize % &divisor, Number::from(10i64));
        assert_eq!(-100isize % &divisor, Number::from(-10i64));
    }

    // Edge cases with platform-specific sizes
    // usize always converts to U64, regardless of platform
    let large_usize = usize::MAX / 2;
    let result = large_usize % Number::from(1000u64);
    // Result may be U64 or Decimal depending on internal promotion logic
    #[cfg(feature = "decimal")]
    assert!(result.try_get_u64().is_some() || result.try_get_decimal().is_some());
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_u64().is_some());

    let large_isize = isize::MAX / 2;
    let result = large_isize % Number::from(1000i64);
    // Result may be I64 or Decimal depending on internal promotion logic
    #[cfg(feature = "decimal")]
    assert!(result.try_get_i64().is_some() || result.try_get_decimal().is_some());
    #[cfg(not(feature = "decimal"))]
    assert!(result.try_get_i64().is_some());
}

/// Tests remainder consistency across types
#[test]
fn test_remainder_type_consistency() {
    // Same mathematical operation should give consistent results
    let divisor = 7;

    // All these should give remainder 3
    assert_eq!(
        Number::from(17u64) % Number::from(u64::from(divisor as u32)),
        Number::from(3u64)
    );
    assert_eq!(
        Number::from(17u64) % Number::from(divisor as u64),
        Number::from(3u64)
    );
    assert_eq!(
        Number::from(17i64) % Number::from(i64::from(divisor)),
        Number::from(3i64)
    );
    assert_eq!(
        Number::from(17i64) % Number::from(divisor as i64),
        Number::from(3i64)
    );
    assert_eq!(num!(17.0) % num!(divisor as f64), num!(3.0));
}

/// Tests remainder combined with power operations
#[test]
fn test_remainder_with_pow() {
    // Test combining remainder and pow: (2^5) % 7 = 32 % 7 = 4
    let result = Number::from(2u64).pow(&Number::from(5u64)) % Number::from(7u64);
    assert_eq!(result, Number::from(4u64));

    // Test with larger numbers: (3^10) % 100
    let result = Number::from(3u64).pow(&Number::from(10u64)) % Number::from(100u64);
    assert_eq!(result, Number::from(49u64)); // 59049 % 100 = 49

    // Test with negative base: ((-2)^5) % 7 = -32 % 7 = -4
    let result = Number::from(-2i64).pow(&Number::from(5u64)) % Number::from(7i64);
    assert_eq!(result, Number::from(-4i64));

    // Test pow of remainder result: (17 % 5)^3 = 2^3 = 8
    let result = (Number::from(17u64) % Number::from(5u64)).pow(&Number::from(3u64));
    assert_eq!(result, Number::from(8u64));

    // Test with negative numbers: ((-17) % 5)^2 = (-2)^2 = 4
    let result = (Number::from(-17i64) % Number::from(5i64)).pow(&Number::from(2u64));
    assert_eq!(result, Number::from(4i64));
}

/// Tests platform-independent usize/isize conversion behavior
#[test]
fn test_usize_isize_platform_independence() {
    // Verify that usize always converts to U64 and isize to I64
    // This ensures consistent behavior across 32-bit and 64-bit platforms

    // Test usize conversion
    let usize_num = Number::from(42usize);
    assert_eq!(usize_num.try_get_u64(), Some(42));

    // Test isize conversion
    let isize_num = Number::from(-42isize);
    assert_eq!(isize_num.try_get_i64(), Some(-42));

    // Test with platform-specific max values
    let usize_max = Number::from(usize::MAX);
    assert!(usize_max.try_get_u64().is_some());
    if let Some(val) = usize_max.try_get_u64() {
        assert_eq!(val, usize::MAX as u64);
    }

    let isize_max = Number::from(isize::MAX);
    assert!(isize_max.try_get_i64().is_some());
    if let Some(val) = isize_max.try_get_i64() {
        assert_eq!(val, isize::MAX as i64);
    }

    let isize_min = Number::from(isize::MIN);
    assert!(isize_min.try_get_i64().is_some());
    if let Some(val) = isize_min.try_get_i64() {
        assert_eq!(val, isize::MIN as i64);
    }
}

/// Tests remainder with zero for all types
#[test]
fn test_remainder_by_zero_all_types() {
    // All types should return NaN when dividing by zero
    assert!((Number::from(10u64) % Number::from(0u64)).is_nan());
    assert!((Number::from(10u64) % Number::from(0u64)).is_nan());
    assert!((Number::from(10i64) % Number::from(0i64)).is_nan());
    assert!((Number::from(10i64) % Number::from(0i64)).is_nan());
    assert!((num!(10.0) % num!(0.0)).is_nan());
}