rusty_common/

utils.rs

//! Common utility functions

use crate::SmartString;
use rust_decimal::Decimal;
use std::str::FromStr;
// Re-export f32x8 for external users of simd_nan_safe functions
#[allow(unused_imports)]
use wide::f32x8;

/// Parse decimal value from string, returning zero on error
#[must_use]
pub fn parse_decimal_safe(s: &str) -> Decimal {
    Decimal::from_str(s).unwrap_or(Decimal::ZERO)
}

/// Parse optional decimal value from string
#[must_use]
pub fn parse_decimal_option(s: Option<&str>) -> Option<Decimal> {
    s.and_then(|val| Decimal::from_str(val).ok())
}

/// Format decimal for API submission (removing trailing zeros)
#[must_use]
pub fn format_decimal(value: Decimal) -> SmartString {
    let s = value.to_string();
    if s.contains('.') {
        s.trim_end_matches('0').trim_end_matches('.').into()
    } else {
        s.into()
    }
}

/// Generate a unique order ID
#[must_use]
pub fn generate_order_id() -> SmartString {
    uuid::Uuid::new_v4().to_string().into()
}

/// Normalize trading symbol (e.g., "BTC-USDT" -> "BTCUSDT")
#[must_use]
pub fn normalize_symbol(symbol: &str) -> SmartString {
    symbol.replace(['-', '_', '/'], "").to_uppercase().into()
}

/// Parse symbol into base and quote currencies
#[must_use]
pub fn parse_symbol_pair(symbol: &str) -> Option<(SmartString, SmartString)> {
    // Try different separators
    if let Some(pos) = symbol.find('-') {
        let (base, quote) = symbol.split_at(pos);
        return Some((base.into(), quote[1..].into()));
    }

    if let Some(pos) = symbol.find('_') {
        let (base, quote) = symbol.split_at(pos);
        return Some((base.into(), quote[1..].into()));
    }

    if let Some(pos) = symbol.find('/') {
        let (base, quote) = symbol.split_at(pos);
        return Some((base.into(), quote[1..].into()));
    }

    // Try to parse common patterns (e.g., BTCUSDT)
    if let Some(base) = symbol.strip_suffix("USDT") {
        return Some((base.into(), "USDT".into()));
    }

    if let Some(base) = symbol.strip_suffix("BTC") {
        return Some((base.into(), "BTC".into()));
    }

    if let Some(base) = symbol.strip_suffix("ETH") {
        return Some((base.into(), "ETH".into()));
    }

    None
}

/// Convert basis points to decimal (1 bp = 0.01%)
#[must_use]
pub fn bp_to_decimal(bp: i32) -> Decimal {
    Decimal::from(bp) / Decimal::from(10000)
}

/// Convert decimal to basis points
#[must_use]
pub fn decimal_to_bp(value: Decimal) -> i32 {
    use rust_decimal::prelude::ToPrimitive;
    (value * Decimal::from(10000)).round().to_i32().unwrap_or(0)
}

/// SmartString ID generation helpers to reduce duplication across exchange adapters
pub mod id_generation {
    use crate::SmartString;
    use uuid::Uuid;

    /// Generate an execution report ID with a prefix and suffix
    #[inline]
    #[must_use]
    pub fn generate_report_id(prefix: &str, suffix: &str) -> SmartString {
        let mut id = SmartString::new();
        id.push_str(prefix);
        id.push('_');
        id.push_str(suffix);
        id
    }

    /// Generate an execution report ID with just a prefix and a new UUID
    #[inline]
    #[must_use]
    pub fn generate_report_id_with_uuid(prefix: &str) -> SmartString {
        let uuid_str = Uuid::new_v4().to_string();
        generate_report_id(prefix, &uuid_str)
    }

    /// Generate a multi-part ID with a separator
    #[inline]
    #[must_use]
    pub fn generate_multi_part_id(parts: &[&str], separator: char) -> SmartString {
        let mut id = SmartString::new();

        for (i, part) in parts.iter().enumerate() {
            if i > 0 {
                id.push(separator);
            }
            id.push_str(part);
        }
        id
    }

    /// Generate a standard execution report ID for acknowledgments
    #[inline]
    #[must_use]
    pub fn generate_ack_id(order_id: &str) -> SmartString {
        generate_report_id("ack", order_id)
    }

    /// Generate a standard execution report ID for rejections
    #[inline]
    #[must_use]
    pub fn generate_rejection_id(order_id: &str) -> SmartString {
        generate_report_id("rej", order_id)
    }

    /// Generate a standard execution report ID for cancellations
    #[inline]
    #[must_use]
    pub fn generate_cancel_id(order_id: &str) -> SmartString {
        generate_report_id("cancel", order_id)
    }

    /// Generate a standard execution report ID for fills
    #[inline]
    #[must_use]
    pub fn generate_fill_id(order_id: &str) -> SmartString {
        generate_report_id("fill", order_id)
    }

    /// Generate a standard execution report ID for modifications
    #[inline]
    #[must_use]
    pub fn generate_modify_id(order_id: &str) -> SmartString {
        generate_report_id("modify", order_id)
    }

    /// Generate an exchange-specific report ID
    #[inline]
    #[must_use]
    pub fn generate_exchange_report_id(exchange: &str, suffix: &str) -> SmartString {
        generate_report_id(exchange, suffix)
    }

    /// Generate a WebSocket-specific report ID
    #[inline]
    #[must_use]
    pub fn generate_ws_report_id(operation: &str, suffix: &str) -> SmartString {
        let mut id = SmartString::new();
        id.push_str("ws_");
        id.push_str(operation);
        id.push('_');
        id.push_str(suffix);
        id
    }

    /// Generate an exchange-specific order ID for WebSocket operations
    #[inline]
    #[must_use]
    pub fn generate_exchange_order_id(exchange: &str) -> SmartString {
        let uuid_str = Uuid::new_v4().to_string();
        generate_report_id(&format!("{exchange}_order"), &uuid_str)
    }

    /// Generate a batch operation ID with an index
    #[inline]
    #[must_use]
    pub fn generate_batch_id(prefix: &str, index: usize) -> SmartString {
        let uuid_str = Uuid::new_v4().to_string();
        let index_str = index.to_string();
        generate_multi_part_id(&[prefix, "batch", &uuid_str, &index_str], '_')
    }

    /// Generate a timestamp-based ID for WebSocket operations
    #[inline]
    #[must_use]
    pub fn generate_ws_timestamp_id(operation: &str, timestamp_ns: u64) -> SmartString {
        let timestamp_str = timestamp_ns.to_string();
        generate_ws_report_id(operation, &timestamp_str)
    }

    /// Generate an acknowledgment ID (standardized)
    #[inline]
    #[must_use]
    pub fn generate_acknowledgment_id(order_id: &str) -> SmartString {
        generate_report_id("ack", order_id)
    }

    /// Generate an execution ID
    #[inline]
    #[must_use]
    pub fn generate_execution_id(order_id: &str) -> SmartString {
        generate_report_id("exec", order_id)
    }

    /// Generate an exchange-specific request ID with counter
    #[inline]
    #[must_use]
    pub fn generate_exchange_request_id(
        _exchange: &str,
        operation: &str,
        counter: u64,
    ) -> SmartString {
        let counter_str = counter.to_string();
        generate_multi_part_id(&[operation, &counter_str], '_')
    }

    /// Generate a UUID-based ID
    #[inline]
    #[must_use]
    pub fn generate_uuid_id() -> SmartString {
        Uuid::new_v4().to_string().into()
    }

    /// Generate a client order ID with prefix
    #[inline]
    #[must_use]
    pub fn generate_client_order_id(suffix: &str) -> SmartString {
        generate_report_id("order", suffix)
    }

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

        #[test]
        fn test_generate_report_id() {
            let id = generate_report_id("test", "123");
            assert_eq!(id, "test_123");
        }

        #[test]
        fn test_generate_ack_id() {
            let id = generate_ack_id("order123");
            assert_eq!(id, "ack_order123");
        }

        #[test]
        fn test_generate_rejection_id() {
            let id = generate_rejection_id("order456");
            assert_eq!(id, "rej_order456");
        }

        #[test]
        fn test_generate_multi_part_id() {
            let id = generate_multi_part_id(&["part1", "part2", "part3"], '-');
            assert_eq!(id, "part1-part2-part3");
        }

        #[test]
        fn test_generate_ws_report_id() {
            let id = generate_ws_report_id("place", "order123");
            assert_eq!(id, "ws_place_order123");
        }

        #[test]
        fn test_generate_exchange_report_id() {
            let id = generate_exchange_report_id("binance", "execution123");
            assert_eq!(id, "binance_execution123");
        }

        #[test]
        fn test_generate_batch_id() {
            let id = generate_batch_id("bybit", 0);
            assert!(id.starts_with("bybit_batch_"));
            assert!(id.ends_with("_0"));
        }

        #[test]
        fn test_generate_ws_timestamp_id() {
            let id = generate_ws_timestamp_id("error", 1234567890);
            assert_eq!(id, "ws_error_1234567890");
        }

        #[test]
        fn test_generate_acknowledgment_id() {
            let id = generate_acknowledgment_id("order123");
            assert_eq!(id, "ack_order123");
        }

        #[test]
        fn test_generate_execution_id() {
            let id = generate_execution_id("order456");
            assert_eq!(id, "exec_order456");
        }

        #[test]
        fn test_generate_exchange_request_id() {
            let id = generate_exchange_request_id("bybit", "cancel", 42);
            assert_eq!(id, "cancel_42");
        }

        #[test]
        fn test_generate_uuid_id() {
            let id = generate_uuid_id();
            // UUID should be 36 characters with dashes
            assert_eq!(id.len(), 36);
            assert!(id.contains('-'));
        }

        #[test]
        fn test_generate_client_order_id() {
            let id = generate_client_order_id("123");
            assert_eq!(id, "order_123");
        }
    }
}
/// SIMD NaN-safe operations submodule
pub mod simd_nan_safe {
    // NaN-safe SIMD operations using the wide crate
    //
    // This module provides safe SIMD operations that correctly handle NaN values
    // without performance penalties. All operations use hardware NaN propagation.

    use wide::{f32x8, f64x4};

    /// Safe division that returns NaN for invalid operations (0/0, x/0, NaN/x, x/NaN)
    #[inline(always)]
    #[must_use]
    pub fn safe_divide_f64x4(a: f64x4, b: f64x4) -> f64x4 {
        // Hardware automatically handles NaN propagation
        a / b
    }

    /// Safe division for f32x8
    #[inline(always)]
    #[must_use]
    pub fn safe_divide_f32x8(a: f32x8, b: f32x8) -> f32x8 {
        a / b
    }

    /// Check if any element in the vector is NaN
    #[inline(always)]
    pub fn has_nan_f64x4(v: f64x4) -> bool {
        v.is_nan().any()
    }

    /// Check if any element in f32x8 is NaN
    #[inline(always)]
    pub fn has_nan_f32x8(v: f32x8) -> bool {
        v.is_nan().any()
    }

    /// Replace NaN values with zero
    #[inline(always)]
    #[must_use]
    pub fn nan_to_zero_f64x4(v: f64x4) -> f64x4 {
        let mask = !v.is_nan();
        mask & v
    }

    /// Replace NaN values with zero for f32x8
    #[inline(always)]
    #[must_use]
    pub fn nan_to_zero_f32x8(v: f32x8) -> f32x8 {
        let mask = !v.is_nan();
        mask & v
    }

    /// Replace NaN values with a default value
    #[inline(always)]
    #[must_use]
    pub fn nan_to_default_f64x4(v: f64x4, default: f64) -> f64x4 {
        let mask = v.is_nan();
        let default_vec = f64x4::splat(default);
        (!mask & v) | (mask & default_vec)
    }

    /// Replace NaN values with a default value for f32x8
    #[inline(always)]
    #[must_use]
    pub fn nan_to_default_f32x8(v: f32x8, default: f32) -> f32x8 {
        let mask = v.is_nan();
        let default_vec = f32x8::splat(default);
        (!mask & v) | (mask & default_vec)
    }

    /// Safe logarithm that returns NaN for negative values
    #[inline(always)]
    #[must_use]
    pub fn safe_log_f64x4(v: f64x4) -> f64x4 {
        // wide doesn't have log, so we need to use scalar operations
        // This is a temporary solution until wide adds transcendental functions
        let arr: [f64; 4] = v.into();
        f64x4::from([arr[0].ln(), arr[1].ln(), arr[2].ln(), arr[3].ln()])
    }

    /// Safe square root (returns NaN for negative values)
    #[inline(always)]
    #[must_use]
    pub fn safe_sqrt_f64x4(v: f64x4) -> f64x4 {
        v.sqrt() // Hardware handles NaN for negative inputs
    }

    /// Clamp values to a range, preserving NaN
    #[inline(always)]
    #[must_use]
    pub fn clamp_f64x4(v: f64x4, min: f64, max: f64) -> f64x4 {
        let min_vec = f64x4::splat(min);
        let max_vec = f64x4::splat(max);
        v.max(min_vec).min(max_vec) // NaN propagates through min/max
    }

    /// Calculate mean of non-NaN values
    #[inline(always)]
    #[must_use]
    pub fn mean_non_nan_f64x4(v: f64x4) -> f64 {
        let arr: [f64; 4] = v.into();
        let mut sum = 0.0;
        let mut count = 0;

        for val in arr.iter() {
            if !val.is_nan() {
                sum += val;
                count += 1;
            }
        }

        if count > 0 {
            sum / count as f64
        } else {
            f64::NAN
        }
    }

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

        #[test]
        fn test_safe_divide() {
            let a = f64x4::from([10.0, 20.0, 0.0, 30.0]);
            let b = f64x4::from([2.0, 0.0, 0.0, 5.0]);
            let result = safe_divide_f64x4(a, b);
            let arr: [f64; 4] = result.into();

            assert_eq!(arr[0], 5.0);
            assert!(arr[1].is_infinite()); // 20/0 = inf
            assert!(arr[2].is_nan()); // 0/0 = NaN
            assert_eq!(arr[3], 6.0);
        }

        #[test]
        fn test_nan_to_zero() {
            let v = f64x4::from([1.0, f64::NAN, 3.0, f64::NAN]);
            let result = nan_to_zero_f64x4(v);
            let arr: [f64; 4] = result.into();

            assert_eq!(arr[0], 1.0);
            assert_eq!(arr[1], 0.0);
            assert_eq!(arr[2], 3.0);
            assert_eq!(arr[3], 0.0);
        }

        #[test]
        fn test_nan_to_default() {
            let v = f64x4::from([1.0, f64::NAN, 3.0, f64::NAN]);
            let result = nan_to_default_f64x4(v, -1.0);
            let arr: [f64; 4] = result.into();

            assert_eq!(arr[0], 1.0);
            assert_eq!(arr[1], -1.0);
            assert_eq!(arr[2], 3.0);
            assert_eq!(arr[3], -1.0);
        }

        #[test]
        fn test_safe_sqrt() {
            let v = f64x4::from([4.0, -1.0, 16.0, 0.0]);
            let result = safe_sqrt_f64x4(v);
            let arr: [f64; 4] = result.into();

            assert_eq!(arr[0], 2.0);
            assert!(arr[1].is_nan()); // sqrt(-1) = NaN
            assert_eq!(arr[2], 4.0);
            assert_eq!(arr[3], 0.0);
        }

        #[test]
        fn test_mean_non_nan() {
            let v = f64x4::from([10.0, f64::NAN, 20.0, 30.0]);
            let result = mean_non_nan_f64x4(v);
            assert_eq!(result, 20.0); // (10 + 20 + 30) / 3

            let all_nan = f64x4::from([f64::NAN; 4]);
            let result_nan = mean_non_nan_f64x4(all_nan);
            assert!(result_nan.is_nan());
        }
    }
}

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

    #[test]
    fn test_f32x8_available_at_module_level() {
        // This test demonstrates the need for f32x8 to be available at the module level
        // for external users who want to use simd_nan_safe functions
        use super::simd_nan_safe::*;

        // This should work without needing to import f32x8 separately
        let a = f32x8::from([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]);
        let b = f32x8::from([2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0]);

        let result = safe_divide_f32x8(a, b);
        let expected = f32x8::from([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);

        let result_array: [f32; 8] = result.into();
        let expected_array: [f32; 8] = expected.into();

        for i in 0..8 {
            assert!((result_array[i] - expected_array[i]).abs() < f32::EPSILON);
        }
    }

    #[test]
    fn test_smartstring_from_literal_conversions() {
        // Test that .into() works for string literals
        let s1: SmartString = "test".into();
        assert_eq!(s1, "test");

        // Test that SmartString::from() also works
        let s2 = SmartString::from("test");
        assert_eq!(s2, "test");

        // Both should produce the same result
        assert_eq!(s1, s2);

        // Test with longer strings
        let long: SmartString = "this is a longer string that might use heap allocation".into();
        assert_eq!(
            long,
            "this is a longer string that might use heap allocation"
        );
    }

    #[test]
    fn test_to_string_into_conversions() {
        #[derive(Debug)]
        struct TestStruct {
            value: i32,
        }

        impl std::fmt::Display for TestStruct {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "TestStruct({})", self.value)
            }
        }

        let test = TestStruct { value: 42 };

        // Test .to_string().into() pattern
        let s1: SmartString = test.to_string().into();
        assert_eq!(s1, "TestStruct(42)");

        // Test direct .into() doesn't work for Display types
        // let s2: SmartString = test.into(); // This should not compile

        // But we can use format! macro
        let s3: SmartString = format!("{test}").into();
        assert_eq!(s3, "TestStruct(42)");
    }

    #[test]
    fn test_parse_symbol_pair() {
        assert_eq!(
            parse_symbol_pair("BTC-USDT"),
            Some(("BTC".into(), "USDT".into()))
        );
        assert_eq!(
            parse_symbol_pair("ETH_BTC"),
            Some(("ETH".into(), "BTC".into()))
        );
        assert_eq!(
            parse_symbol_pair("BTC/USD"),
            Some(("BTC".into(), "USD".into()))
        );
        assert_eq!(
            parse_symbol_pair("BTCUSDT"),
            Some(("BTC".into(), "USDT".into()))
        );
        assert_eq!(
            parse_symbol_pair("ETHBTC"),
            Some(("ETH".into(), "BTC".into()))
        );
    }

    #[test]
    fn test_format_decimal() {
        assert_eq!(format_decimal(Decimal::from_str("1.00000").unwrap()), "1");
        assert_eq!(format_decimal(Decimal::from_str("1.50000").unwrap()), "1.5");
        assert_eq!(
            format_decimal(Decimal::from_str("1.12345").unwrap()),
            "1.12345"
        );
    }

    #[test]
    fn test_overflow_checks_configuration() {
        // This test documents the overflow checks configuration and ensures
        // we're handling financial calculations safely
        //
        // Development: overflow-checks = true (catch bugs early)
        // Release: overflow-checks = false (HFT performance)

        // Test basic arithmetic that should work in both profiles
        let result = 100i64 + 200i64;
        assert_eq!(result, 300i64);

        // Test wrapping arithmetic that explicitly handles overflow
        let safe_result = i64::MAX.wrapping_add(1);
        assert_eq!(safe_result, i64::MIN); // Expected wrap-around behavior

        // Test that we use rust_decimal for financial calculations
        let financial_calc = Decimal::from_str("999999999999999999.99").unwrap();
        let result = financial_calc + Decimal::from_str("0.01").unwrap();
        assert!(result > financial_calc);
    }
}