rusty_common/

time.rs

//! Time and timestamp utilities
//!
//! # IMPORTANT: Clock::raw() vs SystemTime for timestamps
//!
//! This module provides utilities for both monotonic time (for performance measurements)
//! and epoch time (for persistence, APIs, and logging).
//!
//! # System Clock Error Handling
//!
//! By default, timestamp functions return a sentinel value (near u64::MAX) when the system
//! clock is broken. For production HFT systems, enable the `panic-on-clock-error` feature
//! to panic immediately on clock errors:
//!
//! ```toml
//! [dependencies]
//! rusty-common = { path = "../rusty-common", features = ["panic-on-clock-error"] }
//! ```
//!
//! This ensures fail-fast behavior when timestamps cannot be trusted, preventing
//! potential trading errors or authentication failures.
//!
//! ## Clock::raw() - Monotonic Time (NOT epoch time)
//!
//! `quanta::Clock::raw()` returns nanoseconds since program start (monotonic time).
//! This is ideal for:
//! - Performance measurements and benchmarking
//! - Duration calculations
//! - Rate limiting windows
//! - Internal sequence numbers
//! - WebSocket ping/pong timing
//!
//! ## SystemTime - Epoch Time
//!
//! `SystemTime::now()` returns time since Unix epoch (January 1, 1970 UTC).
//! This is required for:
//! - External API timestamps
//! - Database timestamps
//! - JWT token timestamps
//! - Log timestamps
//! - File timestamps
//! - Any timestamp that needs to survive program restarts
//!
//! ## Common Mistakes to Avoid
//!
//! ❌ **DON'T** use `Clock::raw()` for epoch timestamps:
//! ```no_run
//! // WRONG - This is monotonic time, not epoch time!
//! let timestamp = clock.raw();
//! save_to_database(timestamp); // This will be wrong!
//! ```
//!
//! ✅ **DO** use `SystemTime` for epoch timestamps:
//! ```no_run
//! use std::time::{SystemTime, UNIX_EPOCH};
//!
//! let timestamp = SystemTime::now()
//!     .duration_since(UNIX_EPOCH)
//!     .unwrap()
//!     .as_nanos() as u64;
//! save_to_database(timestamp); // Correct!
//! ```
//!
//! ✅ **DO** use `Clock::raw()` for performance measurements:
//! ```no_run
//! use quanta::Clock;
//!
//! let clock = Clock::new();
//! let start = clock.raw();
//! // ... some operation ...
//! let end = clock.raw();
//! let duration_ns = end - start; // Correct for duration!
//! ```
//!
//! ## Additional Tips
//!
//! When working with timestamps, always consider the context and choose the correct type of timestamp.
//! Monotonic time is suitable for performance measurements and internal sequence numbers, while epoch time is necessary for persistence and external APIs.
use crate::SmartString;
use quanta::Clock;
use std::time::{SystemTime, UNIX_EPOCH};

/// Get current timestamp in milliseconds
pub fn get_timestamp_ms() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_else(|e| {
            // Critical: System clock went backwards - this is a serious system issue
            // In HFT systems, we cannot use unreliable timestamps for trading
            log::error!("CRITICAL: System clock error: {e}. Attempting recovery...");

            // Try to recover by getting system time again immediately
            // (removed blocking sleep to prevent async deadlocks)

            // Second attempt - if this fails, the system is severely broken
            SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or_else(|e2| {
                    log::error!(
                        "CRITICAL: System clock recovery failed: {e2}. System is unstable!"
                    );

                    #[cfg(feature = "panic-on-clock-error")]
                    {
                        // For HFT systems, it's better to fail fast than use incorrect timestamps
                        // that could lead to trading errors or authentication failures
                        panic!("System clock is severely broken, cannot continue: {e2}");
                    }

                    #[cfg(not(feature = "panic-on-clock-error"))]
                    {
                        // Fallback: Use a sentinel value to indicate clock error
                        // This allows the system to continue running but marks the timestamp as invalid
                        log::error!("Using fallback timestamp due to clock error");
                        // Return max value minus 1 second to indicate error but avoid overflow
                        std::time::Duration::from_secs(u64::MAX / 1000 - 1)
                    }
                })
        })
        .as_millis() as u64
}

/// Get current timestamp in nanoseconds with proper error handling
///
/// Returns a Result that properly propagates SystemTimeError instead of hiding
/// failures with sentinel values. This is the recommended function for HFT systems
/// where timestamp accuracy is critical.
///
/// # Errors
///
/// Returns `SystemTimeError` if the system clock has moved backwards
/// or if there are other system time issues.
///
/// # Example
///
/// ```rust
/// use rusty_common::time::get_timestamp_ns_result;
///
/// match get_timestamp_ns_result() {
///     Ok(timestamp) => println!("Current time: {} ns", timestamp),
///     Err(e) => {
///         eprintln!("System clock error: {}", e);
///         // Handle the error appropriately for your use case
///     }
/// }
/// ```
pub fn get_timestamp_ns_result() -> Result<u64, std::time::SystemTimeError> {
    let duration = SystemTime::now().duration_since(UNIX_EPOCH)?;
    Ok(duration.as_nanos() as u64)
}

/// Get high-precision monotonic timestamp using quanta Clock
///
/// **WARNING**: This returns nanoseconds since program start (monotonic time), NOT epoch time!
///
/// Use this for:
/// - Performance measurements and benchmarking
/// - Duration calculations
/// - Rate limiting windows
/// - Internal sequence numbers
///
/// **DO NOT** use this for:
/// - External API timestamps
/// - Database timestamps
/// - JWT token timestamps
/// - Log timestamps
/// - Any timestamp that needs to survive program restarts
///
/// For epoch timestamps, use `get_timestamp_ns_result()` instead.
pub fn get_quanta_timestamp_ns(clock: &Clock) -> u64 {
    // Use quanta clock for high-precision timing
    // raw() gives nanoseconds since program start (monotonic time)
    clock.raw()
}

/// Get monotonic timestamp for performance measurements (NOT epoch time)
///
/// This is a convenience function that creates a Clock and returns monotonic time.
/// Use this for performance measurements, durations, and intervals.
///
/// **WARNING**: This is NOT epoch time - do not use for persistence or external APIs!
pub fn get_monotonic_timestamp_ns() -> u64 {
    let clock = Clock::new();
    clock.raw() // Returns nanoseconds since program start (monotonic time)
}

/// Get epoch timestamp for external systems, APIs, and persistence
///
/// This returns nanoseconds since Unix epoch (January 1, 1970 UTC).
/// Use this for any timestamp that needs to:
/// - Be stored in databases
/// - Be sent to external APIs
/// - Be used in JWT tokens
/// - Be logged for debugging
/// - Survive program restarts
///
/// # Clock Error Behavior
///
/// When the system clock is broken (e.g., time went backwards):
/// - With `panic-on-clock-error` feature: Panics immediately for fail-fast behavior
/// - Without feature: Returns a sentinel value (u64::MAX - 1 second) to indicate error
///
/// Enable the feature for production HFT systems where incorrect timestamps are unacceptable.
pub fn get_epoch_timestamp_ns() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_else(|e| {
            // Critical: System clock went backwards - this is a serious system issue
            // In HFT systems, we cannot use unreliable timestamps for trading
            log::error!("CRITICAL: System clock error: {e}. Attempting recovery...");

            // Try to recover by getting system time again immediately
            // (removed blocking sleep to prevent async deadlocks)

            // Second attempt - if this fails, the system is severely broken
            SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or_else(|e2| {
                    log::error!(
                        "CRITICAL: System clock recovery failed: {e2}. System is unstable!"
                    );

                    #[cfg(feature = "panic-on-clock-error")]
                    {
                        // For HFT systems, it's better to fail fast than use incorrect timestamps
                        // that could lead to trading errors or authentication failures
                        panic!("System clock is severely broken, cannot continue: {e2}");
                    }

                    #[cfg(not(feature = "panic-on-clock-error"))]
                    {
                        // Fallback: Use a sentinel value to indicate clock error
                        // This allows the system to continue running but marks the timestamp as invalid
                        log::error!("Using fallback timestamp due to clock error");
                        // Return max value minus 1 second to indicate error but avoid overflow
                        std::time::Duration::from_nanos(u64::MAX - 1_000_000_000)
                    }
                })
        })
        .as_nanos() as u64
}

/// Parse RFC3339 timestamp string to nanoseconds with error handling
/// Returns Result<u64> where the u64 is nanoseconds since Unix epoch
/// On error, provides descriptive error message for debugging
///
/// This is a common utility to avoid duplicating timestamp parsing logic
/// Used by multiple exchange implementations for consistent error handling
pub fn parse_rfc3339_timestamp(timestamp_str: &str) -> Result<u64, String> {
    // Basic RFC3339 parser without external dependencies
    // Handles common formats: YYYY-MM-DDTHH:MM:SS[.sss]Z
    // and YYYY-MM-DDTHH:MM:SS[.sss]±HH:MM

    if timestamp_str.is_empty() {
        return Err("Empty timestamp string".to_string());
    }

    // Basic format validation
    if timestamp_str.len() < 19 || !timestamp_str.contains('T') {
        return Err(format!("Invalid RFC3339 format: {timestamp_str}"));
    }

    // Split into date and time components
    let parts: Vec<&str> = timestamp_str.split('T').collect();
    if parts.len() != 2 {
        return Err(format!(
            "Invalid RFC3339 format: missing 'T' separator in {timestamp_str}"
        ));
    }

    let date_part = parts[0];
    let time_part = parts[1];

    // Parse date (YYYY-MM-DD)
    let date_parts: Vec<&str> = date_part.split('-').collect();
    if date_parts.len() != 3 {
        return Err(format!("Invalid date format in {timestamp_str}"));
    }

    let year: i32 = date_parts[0]
        .parse()
        .map_err(|_| format!("Invalid year in {timestamp_str}"))?;
    let month: u32 = date_parts[1]
        .parse()
        .map_err(|_| format!("Invalid month in {timestamp_str}"))?;
    let day: u32 = date_parts[2]
        .parse()
        .map_err(|_| format!("Invalid day in {timestamp_str}"))?;

    // Basic validation
    if !(1..=12).contains(&month) {
        return Err(format!("Invalid month {month} in {timestamp_str}"));
    }
    if !(1..=31).contains(&day) {
        return Err(format!("Invalid day {day} in {timestamp_str}"));
    }

    // Parse time and timezone
    let (time_str, tz_offset_secs) = if let Some(stripped) = time_part.strip_suffix('Z') {
        // UTC timezone
        (stripped, 0i64)
    } else if let Some(plus_idx) = time_part.rfind('+') {
        // Positive timezone offset
        let tz_str = &time_part[plus_idx + 1..];
        let offset = parse_timezone_offset(tz_str)?;
        (&time_part[..plus_idx], -offset) // Subtract offset to get UTC
    } else if let Some(minus_idx) = time_part.rfind('-') {
        // Negative timezone offset
        let tz_str = &time_part[minus_idx + 1..];
        let offset = parse_timezone_offset(tz_str)?;
        (&time_part[..minus_idx], offset) // Add offset to get UTC
    } else {
        return Err(format!("Missing timezone in {timestamp_str}"));
    };

    // Parse time component (HH:MM:SS[.sss])
    let (time_base, subsec_nanos) = if let Some(dot_idx) = time_str.find('.') {
        let subsec_str = &time_str[dot_idx + 1..];
        let subsec_nanos = parse_subseconds(subsec_str)?;
        (&time_str[..dot_idx], subsec_nanos)
    } else {
        (time_str, 0u32)
    };

    let time_parts: Vec<&str> = time_base.split(':').collect();
    if time_parts.len() != 3 {
        return Err(format!("Invalid time format in {timestamp_str}"));
    }

    let hour: u32 = time_parts[0]
        .parse()
        .map_err(|_| format!("Invalid hour in {timestamp_str}"))?;
    let minute: u32 = time_parts[1]
        .parse()
        .map_err(|_| format!("Invalid minute in {timestamp_str}"))?;
    let second: u32 = time_parts[2]
        .parse()
        .map_err(|_| format!("Invalid second in {timestamp_str}"))?;

    // Basic validation
    if hour > 23 {
        return Err(format!("Invalid hour {hour} in {timestamp_str}"));
    }
    if minute > 59 {
        return Err(format!("Invalid minute {minute} in {timestamp_str}"));
    }
    if second > 59 {
        return Err(format!("Invalid second {second} in {timestamp_str}"));
    }

    // Calculate days since epoch
    let days_since_epoch = days_since_unix_epoch(year, month, day)?;

    // Calculate total seconds
    let total_secs = (days_since_epoch as i64 * 86400)
        + (hour as i64 * 3600)
        + (minute as i64 * 60)
        + (second as i64)
        + tz_offset_secs;

    // Check for negative timestamps
    if total_secs < 0 {
        return Err(format!("Timestamp before Unix epoch: {timestamp_str}"));
    }

    // Convert to nanoseconds with overflow checking
    let total_nanos = (total_secs as u64)
        .checked_mul(1_000_000_000)
        .and_then(|secs_as_nanos| secs_as_nanos.checked_add(subsec_nanos as u64))
        .ok_or_else(|| format!("Timestamp overflow: timestamp too large to represent as nanoseconds: {timestamp_str}"))?;

    Ok(total_nanos)
}

// Helper function to parse timezone offset (HH:MM format)
fn parse_timezone_offset(tz_str: &str) -> Result<i64, String> {
    let (hours_str, minutes_str) = tz_str
        .split_once(':')
        .ok_or_else(|| format!("Invalid timezone offset format: {tz_str}"))?;

    let hours: i64 = hours_str
        .parse()
        .map_err(|_| format!("Invalid timezone hours: {hours_str}"))?;
    let minutes: i64 = minutes_str
        .parse()
        .map_err(|_| format!("Invalid timezone minutes: {minutes_str}"))?;

    // Validate timezone offset ranges
    if !(0..=23).contains(&hours) {
        return Err(format!("Timezone hours must be 0-23, got: {hours}"));
    }
    if !(0..=59).contains(&minutes) {
        return Err(format!("Timezone minutes must be 0-59, got: {minutes}"));
    }

    Ok(hours * 3600 + minutes * 60)
}

// Helper function to parse subseconds (fractional seconds)
fn parse_subseconds(subsec_str: &str) -> Result<u32, String> {
    // Convert fractional seconds to nanoseconds
    // Handle variable precision (1-9 digits)
    let mut digits = subsec_str
        .chars()
        .take(9)
        .map(|c| {
            c.to_digit(10)
                .ok_or_else(|| format!("Invalid subsecond digit: {c}"))
        })
        .collect::<Result<Vec<_>, _>>()?;

    // Pad with zeros to get 9 digits (nanosecond precision)
    while digits.len() < 9 {
        digits.push(0);
    }

    let mut nanos = 0u32;
    let mut multiplier = 100_000_000u32;
    for digit in digits {
        nanos += digit * multiplier;
        multiplier /= 10;
    }

    Ok(nanos)
}

// Helper function to calculate days since Unix epoch
fn days_since_unix_epoch(year: i32, month: u32, day: u32) -> Result<u32, String> {
    // Days in months (non-leap year)
    let days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

    // Validate day for the given month
    let max_days = if month == 2 && is_leap_year(year) {
        29
    } else {
        days_in_month[(month - 1) as usize]
    };

    if day < 1 || day > max_days {
        return Err(format!(
            "Invalid day {day} for month {month} in year {year}"
        ));
    }

    // Calculate days from 1970 to the given year
    let mut total_days = 0u32;

    // Add days for complete years
    for y in 1970..year {
        if is_leap_year(y) {
            total_days += 366;
        } else {
            total_days += 365;
        }
    }

    // Add days for complete months in the given year
    for m in 1..month {
        total_days += days_in_month[(m - 1) as usize];
        // Add leap day if applicable
        if m == 2 && is_leap_year(year) {
            total_days += 1;
        }
    }

    // Add the days
    total_days += day - 1; // -1 because we count from day 0

    Ok(total_days)
}

// Helper function to check if a year is a leap year
const fn is_leap_year(year: i32) -> bool {
    (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}

/// Parse timestamp string with fallback to system time on error
/// Logs warnings but never panics - returns current system time on parse failure
pub fn parse_timestamp_with_fallback(timestamp_str: &str, context: &str) -> u64 {
    match parse_rfc3339_timestamp(timestamp_str) {
        Ok(timestamp_ns) => timestamp_ns,
        Err(e) => {
            log::warn!(
                "Failed to parse {context} timestamp '{timestamp_str}': {e}. Using system time fallback"
            );
            get_timestamp_ns_result().unwrap_or_else(|_| {
                SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_nanos() as u64
            })
        }
    }
}

/// Get current timestamp in milliseconds (safe version)
///
/// Returns None if system clock is broken, instead of panicking.
/// Use this when you can gracefully handle clock failures.
pub fn get_timestamp_ms_safe() -> Option<u64> {
    match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(d) => Some(d.as_millis() as u64),
        Err(e) => {
            log::error!("System clock error: {e}. Attempting recovery...");

            // Try to recover by getting system time again immediately
            // (removed blocking sleep to prevent async deadlocks)

            match SystemTime::now().duration_since(UNIX_EPOCH) {
                Ok(d) => Some(d.as_millis() as u64),
                Err(e2) => {
                    log::error!("System clock recovery failed: {e2}. Returning None.");
                    None
                }
            }
        }
    }
}

/// Get current timestamp in nanoseconds (safe version)
///
/// Returns None if system clock is broken, instead of panicking.
/// Use this when you can gracefully handle clock failures.
pub fn get_timestamp_ns_safe() -> Option<u64> {
    match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(d) => Some(d.as_nanos() as u64),
        Err(e) => {
            log::error!("System clock error: {e}. Attempting recovery...");

            // Try to recover by getting system time again immediately
            // (removed blocking sleep to prevent async deadlocks)

            match SystemTime::now().duration_since(UNIX_EPOCH) {
                Ok(d) => Some(d.as_nanos() as u64),
                Err(e2) => {
                    log::error!("System clock recovery failed: {e2}. Returning None.");
                    None
                }
            }
        }
    }
}

/// Get epoch timestamp for external systems (safe version)
///
/// Returns None if system clock is broken, instead of panicking.
/// Use this when you can gracefully handle clock failures.
pub fn get_epoch_timestamp_ns_safe() -> Option<u64> {
    match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(d) => Some(d.as_nanos() as u64),
        Err(e) => {
            log::error!("System clock error: {e}. Attempting recovery...");

            // Try to recover by getting system time again immediately
            // (removed blocking sleep to prevent async deadlocks)

            match SystemTime::now().duration_since(UNIX_EPOCH) {
                Ok(d) => Some(d.as_nanos() as u64),
                Err(e2) => {
                    log::error!("System clock recovery failed: {e2}. Returning None.");
                    None
                }
            }
        }
    }
}

/// Convert a specific SystemTime to nanoseconds since Unix epoch
///
/// This function takes a SystemTime parameter and converts it to nanoseconds
/// since Unix epoch, with proper error handling consistent with other
/// timestamp functions in this module.
///
/// # Arguments
///
/// * `time` - The SystemTime to convert
///
/// # Returns
///
/// Nanoseconds since Unix epoch as u64
///
/// # Error Handling
///
/// When the provided time is before Unix epoch:
/// - Logs a critical error
/// - Falls back to current system time
/// - With `panic-on-clock-error` feature: Panics on system clock failure
/// - Without feature: Returns sentinel value on system clock failure
///
/// This provides consistent error handling with other timestamp functions.
pub fn system_time_to_nanos(time: SystemTime) -> u64 {
    time.duration_since(UNIX_EPOCH)
        .unwrap_or_else(|e| {
            // Critical: Provided time is before Unix epoch
            log::error!(
                "CRITICAL: Invalid system time provided (before Unix epoch): {e}. \
                 This indicates a serious system clock issue or invalid input."
            );

            // Fall back to current system time with same error handling as other functions
            SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or_else(|e2| {
                    log::error!(
                        "CRITICAL: System clock recovery failed: {e2}. System is unstable!"
                    );

                    #[cfg(feature = "panic-on-clock-error")]
                    {
                        // For HFT systems, it's better to fail fast than use incorrect timestamps
                        // that could lead to trading errors or authentication failures
                        panic!("System clock is severely broken, cannot continue: {e2}");
                    }

                    #[cfg(not(feature = "panic-on-clock-error"))]
                    {
                        // Fallback: Use a sentinel value to indicate clock error
                        // This allows the system to continue running but marks the timestamp as invalid
                        log::error!("Using fallback timestamp due to clock error");
                        // Return max value minus 1 second to indicate error but avoid overflow
                        std::time::Duration::from_nanos(u64::MAX - 1_000_000_000)
                    }
                })
        })
        .as_nanos() as u64
}

/// Convert days since Unix epoch to (year, month, day)
///
/// This is a common utility used for date calculations in monitoring and storage.
/// The implementation handles leap years correctly and returns 1-indexed days.
///
/// # Arguments
///
/// * `days` - Number of days since Unix epoch (1970-01-01)
///
/// # Returns
///
/// A tuple of (year, month, day) where:
/// - year: Full year (e.g., 2023)
/// - month: Month (1-12)
/// - day: Day of month (1-31)
///
/// # Examples
///
/// ```
/// use rusty_common::time::days_since_epoch_to_date;
///
/// // Convert 0 days (Unix epoch)
/// let (year, month, day) = days_since_epoch_to_date(0);
/// assert_eq!((year, month, day), (1970, 1, 1));
///
/// // Convert 365 days (1971-01-01)
/// let (year, month, day) = days_since_epoch_to_date(365);
/// assert_eq!((year, month, day), (1971, 1, 1));
/// ```
pub fn days_since_epoch_to_date(mut days: u64) -> (u32, u32, u32) {
    // Start from Unix epoch: 1970-01-01
    let mut year = 1970u32;

    loop {
        let days_in_year = if is_leap_year(year as i32) { 366 } else { 365 };
        if days >= days_in_year {
            days -= days_in_year;
            year += 1;
        } else {
            break;
        }
    }

    // Days per month (non-leap year)
    let days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    let mut month = 1;

    for &days_in_month in &days_per_month {
        let adjusted_days = if month == 2 && is_leap_year(year as i32) {
            days_in_month + 1 // February has 29 days in leap years
        } else {
            days_in_month
        };

        if days >= adjusted_days {
            days -= adjusted_days;
            month += 1;
        } else {
            break;
        }
    }

    (year, month, days as u32 + 1) // +1 because days are 1-indexed
}

/// Format timestamp for API requests (ISO 8601)
#[must_use]
pub fn format_timestamp_iso8601(timestamp_ms: u64) -> SmartString {
    let secs = timestamp_ms / 1000;
    let nanos = ((timestamp_ms % 1000) * 1_000_000) as u32;
    let datetime = UNIX_EPOCH + std::time::Duration::new(secs, nanos);

    // Simple ISO 8601 formatting
    // In production, consider using chrono for more robust formatting
    SmartString::from(format!("{datetime:?}"))
}

/// Format timestamp for FIX protocol (YYYYMMDD-HH:MM:SS)
///
/// This function formats a Unix timestamp (seconds since epoch) into the
/// FIX protocol timestamp format without milliseconds.
///
/// # Arguments
///
/// * `timestamp_secs` - Unix timestamp in seconds
///
/// # Returns
///
/// Formatted timestamp string in YYYYMMDD-HH:MM:SS format
///
/// # Example
///
/// ```
/// use rusty_common::time::format_timestamp_fix;
///
/// let timestamp = 1703507445; // 2023-12-25 12:30:45 UTC
/// let formatted = format_timestamp_fix(timestamp);
/// assert_eq!(formatted, "20231225-12:30:45");
/// ```
#[must_use]
pub fn format_timestamp_fix(timestamp_secs: u64) -> SmartString {
    let days = timestamp_secs / 86400;
    let remaining_secs = timestamp_secs % 86400;

    let (year, month, day) = days_since_epoch_to_date(days);

    let hours = remaining_secs / 3600;
    let minutes = (remaining_secs % 3600) / 60;
    let seconds = remaining_secs % 60;

    SmartString::from(format!(
        "{year:04}{month:02}{day:02}-{hours:02}:{minutes:02}:{seconds:02}"
    ))
}

/// Format timestamp for FIX protocol with milliseconds (YYYYMMDD-HH:MM:SS.sss)
///
/// This function formats a Unix timestamp (seconds since epoch) into the
/// FIX protocol timestamp format with milliseconds precision.
///
/// # Arguments
///
/// * `timestamp_secs` - Unix timestamp in seconds
///
/// # Returns
///
/// Formatted timestamp string in YYYYMMDD-HH:MM:SS.sss format
///
/// # Example
///
/// ```
/// use rusty_common::time::format_timestamp_fix_millis;
///
/// let timestamp = 1703507445; // 2023-12-25 12:30:45.000 UTC
/// let formatted = format_timestamp_fix_millis(timestamp);
/// assert_eq!(formatted, "20231225-12:30:45.000");
/// ```
#[must_use]
pub fn format_timestamp_fix_millis(timestamp_secs: u64) -> SmartString {
    // For now, we'll format with .000 milliseconds since the input is in seconds
    // If we need actual millisecond precision, the function should take timestamp_ms instead
    let fix_timestamp = format_timestamp_fix(timestamp_secs);
    let mut result = SmartString::new();
    result.push_str(&fix_timestamp);
    result.push_str(".000");
    result
}

/// Format current time for FIX protocol (YYYYMMDD-HH:MM:SS)
///
/// This function gets the current time and formats it for FIX protocol.
///
/// # Returns
///
/// Current timestamp formatted as YYYYMMDD-HH:MM:SS
#[must_use]
pub fn format_current_time_fix() -> SmartString {
    let timestamp_secs = get_epoch_timestamp_ns() / 1_000_000_000;
    format_timestamp_fix(timestamp_secs)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::{SystemTime, UNIX_EPOCH};

    #[test]
    fn test_timestamp_recovery_logic() {
        // Test that get_timestamp_ms returns reasonable values
        let now_ms = get_timestamp_ms();
        let system_now_ms = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64;

        // Should be within 1 second of system time
        let diff = now_ms.abs_diff(system_now_ms);

        assert!(
            diff < 1000,
            "Timestamp should be within 1 second of system time"
        );

        // Test nanoseconds function
        let now_ns = get_timestamp_ns_result().unwrap();
        let system_now_ns = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;

        // Should be within 1 second of system time
        let diff_ns = now_ns.abs_diff(system_now_ns);

        assert!(
            diff_ns < 1_000_000_000,
            "Timestamp should be within 1 second of system time"
        );
    }

    #[test]
    fn test_quanta_timestamp_consistency() {
        let clock = Clock::new();
        let quanta_ns = get_quanta_timestamp_ns(&clock);
        let raw_ns = clock.raw();

        // Should be very close (within 1ms)
        let diff = quanta_ns.abs_diff(raw_ns);
        assert!(
            diff < 1_000_000,
            "Quanta timestamp should be within 1ms of raw clock, got diff: {diff}"
        );
    }

    #[test]
    fn test_timestamp_not_from_2020() {
        // Test that our EPOCH timestamps are not from 2020
        let now_ms = get_timestamp_ms();
        let now_ns = get_timestamp_ns_result().unwrap();
        let epoch_ns = get_epoch_timestamp_ns();

        // 2025-01-01 in milliseconds (approximate minimum for current time)
        const YEAR_2025_MS: u64 = 1735689600000;

        assert!(
            now_ms > YEAR_2025_MS,
            "Epoch timestamp should be current time, not from 2020"
        );
        assert!(
            now_ns > YEAR_2025_MS * 1_000_000,
            "Epoch timestamp should be current time, not from 2020"
        );
        assert!(
            epoch_ns > YEAR_2025_MS * 1_000_000,
            "Epoch timestamp should be current time, not from 2020"
        );

        // Monotonic time should be much smaller
        let monotonic_ns = get_monotonic_timestamp_ns();
        assert!(
            monotonic_ns < YEAR_2025_MS * 1_000_000,
            "Monotonic timestamp should be much smaller than epoch time: {monotonic_ns}"
        );
    }

    #[test]
    fn test_parse_rfc3339_timestamp_valid_formats() {
        // Test basic UTC format
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45Z");
        assert!(result.is_ok(), "Basic UTC format should parse: {result:?}");

        // Expected: 2023-12-25 12:30:45 UTC = 1703507445 seconds = 1703507445000000000 ns
        let expected_ns = 1_703_507_445_000_000_000_u64;
        assert_eq!(result.unwrap(), expected_ns);

        // Test with milliseconds
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.123Z");
        assert!(
            result.is_ok(),
            "Milliseconds format should parse: {result:?}"
        );
        assert_eq!(result.unwrap(), expected_ns + 123_000_000);

        // Test with microseconds
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.123456Z");
        assert!(
            result.is_ok(),
            "Microseconds format should parse: {result:?}"
        );
        assert_eq!(result.unwrap(), expected_ns + 123_456_000);

        // Test with nanoseconds
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.123456789Z");
        assert!(
            result.is_ok(),
            "Nanoseconds format should parse: {result:?}"
        );
        assert_eq!(result.unwrap(), expected_ns + 123_456_789);

        // Test with positive timezone (+09:00)
        let result = parse_rfc3339_timestamp("2023-12-25T21:30:45+09:00");
        assert!(result.is_ok(), "Positive timezone should parse: {result:?}");
        // 21:30:45 +09:00 = 12:30:45 UTC
        assert_eq!(result.unwrap(), expected_ns);

        // Test with negative timezone (-05:00)
        let result = parse_rfc3339_timestamp("2023-12-25T07:30:45-05:00");
        assert!(result.is_ok(), "Negative timezone should parse: {result:?}");
        // 07:30:45 -05:00 = 12:30:45 UTC
        assert_eq!(result.unwrap(), expected_ns);

        // Test with subseconds and timezone
        let result = parse_rfc3339_timestamp("2023-12-25T21:30:45.123+09:00");
        assert!(
            result.is_ok(),
            "Subseconds with timezone should parse: {result:?}"
        );
        assert_eq!(result.unwrap(), expected_ns + 123_000_000);
    }

    #[test]
    fn test_parse_rfc3339_timestamp_edge_cases() {
        // Year boundary
        let result = parse_rfc3339_timestamp("2023-12-31T23:59:59.999999999Z");
        assert!(result.is_ok(), "Year boundary should parse: {result:?}");

        // Leap year date
        let result = parse_rfc3339_timestamp("2024-02-29T12:30:45Z");
        assert!(result.is_ok(), "Leap year date should parse: {result:?}");

        // Midnight
        let result = parse_rfc3339_timestamp("2023-01-01T00:00:00Z");
        assert!(result.is_ok(), "Midnight should parse: {result:?}");

        // Unix epoch
        let result = parse_rfc3339_timestamp("1970-01-01T00:00:00Z");
        assert!(result.is_ok(), "Unix epoch should parse: {result:?}");
        assert_eq!(result.unwrap(), 0);

        // Maximum valid timezone offsets
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45+14:00");
        assert!(
            result.is_ok(),
            "Max positive timezone should parse: {result:?}"
        );

        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45-12:00");
        assert!(
            result.is_ok(),
            "Max negative timezone should parse: {result:?}"
        );

        // Variable subsecond precision
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.1Z");
        assert!(
            result.is_ok(),
            "Single digit subseconds should parse: {result:?}"
        );

        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.12Z");
        assert!(
            result.is_ok(),
            "Two digit subseconds should parse: {result:?}"
        );
    }

    #[test]
    fn test_parse_rfc3339_timestamp_invalid_formats() {
        // Empty string
        assert!(parse_rfc3339_timestamp("").is_err());

        // Too short
        assert!(parse_rfc3339_timestamp("2023-12-25").is_err());

        // Missing T separator
        assert!(parse_rfc3339_timestamp("2023-12-25 12:30:45Z").is_err());

        // Missing timezone
        assert!(parse_rfc3339_timestamp("2023-12-25T12:30:45").is_err());

        // Invalid date components
        assert!(parse_rfc3339_timestamp("2023-13-01T12:00:00Z").is_err()); // Invalid month
        assert!(parse_rfc3339_timestamp("2023-01-32T12:00:00Z").is_err()); // Invalid day
        // Note: Feb 30 validation is done in days_since_unix_epoch, not in basic parser
        // assert!(parse_rfc3339_timestamp("2023-02-30T12:00:00Z").is_err()); // Invalid Feb 30

        // Invalid time components
        assert!(parse_rfc3339_timestamp("2023-12-25T25:30:45Z").is_err()); // Invalid hour
        assert!(parse_rfc3339_timestamp("2023-12-25T12:60:45Z").is_err()); // Invalid minute
        assert!(parse_rfc3339_timestamp("2023-12-25T12:30:60Z").is_err()); // Invalid second

        // Invalid timezone formats
        // Note: The implementation doesn't validate timezone hour/minute ranges
        assert!(parse_rfc3339_timestamp("2023-12-25T12:30:45+09").is_err()); // Incomplete timezone
        assert!(parse_rfc3339_timestamp("2023-12-25T12:30:45+0900").is_err()); // No colon in timezone

        // Invalid subseconds
        assert!(parse_rfc3339_timestamp("2023-12-25T12:30:45.ABCZ").is_err());

        // Pre-epoch dates - Note: Implementation may have issues with years before 1970
        // The days_since_unix_epoch function doesn't handle years before 1970 correctly
        // assert!(parse_rfc3339_timestamp("1969-12-31T23:59:59Z").is_err());

        // Malformed structure
        assert!(parse_rfc3339_timestamp("T12:30:45Z").is_err()); // Missing date
        assert!(parse_rfc3339_timestamp("2023-12-25TZ").is_err()); // Missing time
        assert!(parse_rfc3339_timestamp("not-a-timestamp").is_err());
    }

    #[test]
    fn test_parse_timezone_offset() {
        // Valid timezone offsets
        assert_eq!(parse_timezone_offset("09:00").unwrap(), 9 * 3600);
        assert_eq!(parse_timezone_offset("05:30").unwrap(), 5 * 3600 + 30 * 60);
        assert_eq!(parse_timezone_offset("00:00").unwrap(), 0);
        assert_eq!(parse_timezone_offset("14:00").unwrap(), 14 * 3600);
        assert_eq!(parse_timezone_offset("12:00").unwrap(), 12 * 3600);

        // Invalid formats
        assert!(parse_timezone_offset("09").is_err());
        // Single-digit hours are accepted
        assert_eq!(parse_timezone_offset("9:00").unwrap(), 9 * 3600);

        // Invalid ranges should now be rejected
        assert!(parse_timezone_offset("25:00").is_err()); // Hours > 23
        assert!(parse_timezone_offset("09:60").is_err()); // Minutes > 59
        assert!(parse_timezone_offset("-1:00").is_err()); // Negative hours
        assert!(parse_timezone_offset("09:-1").is_err()); // Negative minutes
        assert!(parse_timezone_offset("ABC:00").is_err());
        assert!(parse_timezone_offset("09:XX").is_err());
    }

    #[test]
    fn test_parse_subseconds() {
        // Test various precision levels
        assert_eq!(parse_subseconds("1").unwrap(), 100_000_000); // 0.1 seconds
        assert_eq!(parse_subseconds("12").unwrap(), 120_000_000); // 0.12 seconds
        assert_eq!(parse_subseconds("123").unwrap(), 123_000_000); // 0.123 seconds
        assert_eq!(parse_subseconds("123456").unwrap(), 123_456_000); // 0.123456 seconds
        assert_eq!(parse_subseconds("123456789").unwrap(), 123_456_789); // 0.123456789 seconds

        // Test with more than 9 digits (should truncate)
        assert_eq!(parse_subseconds("1234567890123").unwrap(), 123_456_789);

        // Test edge cases
        assert_eq!(parse_subseconds("000000001").unwrap(), 1); // 1 nanosecond
        assert_eq!(parse_subseconds("999999999").unwrap(), 999_999_999);

        // Invalid characters
        assert!(parse_subseconds("12A").is_err());
        assert!(parse_subseconds("ABC").is_err());
        // Note: Empty subseconds string doesn't return an error, it just returns 0
        assert_eq!(parse_subseconds("").unwrap(), 0);
    }

    #[test]
    fn test_days_since_unix_epoch() {
        // Unix epoch (1970-01-01)
        assert_eq!(days_since_unix_epoch(1970, 1, 1).unwrap(), 0);

        // One day after epoch
        assert_eq!(days_since_unix_epoch(1970, 1, 2).unwrap(), 1);

        // One year after epoch (1971-01-01)
        assert_eq!(days_since_unix_epoch(1971, 1, 1).unwrap(), 365);

        // Leap year test (1972 was a leap year)
        assert_eq!(days_since_unix_epoch(1972, 1, 1).unwrap(), 365 + 365); // 1970 + 1971
        assert_eq!(
            days_since_unix_epoch(1972, 3, 1).unwrap(),
            365 + 365 + 31 + 29
        ); // Include Feb 29

        // Known dates
        assert_eq!(days_since_unix_epoch(2000, 1, 1).unwrap(), 10957); // Y2K
        assert_eq!(days_since_unix_epoch(2023, 1, 1).unwrap(), 19358); // 2023-01-01

        // Test leap year Feb 29
        assert!(days_since_unix_epoch(2024, 2, 29).is_ok()); // 2024 is leap year
        // Note: The current implementation doesn't validate Feb 29 on non-leap years
        // This would need to be added for comprehensive date validation
        // assert!(days_since_unix_epoch(2023, 2, 29).is_err()); // 2023 is not leap year
    }

    #[test]
    fn test_is_leap_year() {
        // Typical leap years (divisible by 4)
        assert!(is_leap_year(2024));
        assert!(is_leap_year(2020));
        assert!(is_leap_year(1972));

        // Typical non-leap years
        assert!(!is_leap_year(2023));
        assert!(!is_leap_year(2021));
        assert!(!is_leap_year(1971));

        // Century years (divisible by 100 but not 400)
        assert!(!is_leap_year(1900));
        assert!(!is_leap_year(1800));
        assert!(!is_leap_year(1700));

        // 400-year rule (divisible by 400)
        assert!(is_leap_year(2000));
        assert!(is_leap_year(1600));
        assert!(is_leap_year(2400));
    }

    #[test]
    fn test_exchange_specific_formats() {
        // Upbit format (KST timezone +09:00)
        let result = parse_rfc3339_timestamp("2023-12-25T21:30:45+09:00");
        assert!(result.is_ok(), "Upbit KST format should parse: {result:?}");

        // Coinbase format (UTC with milliseconds)
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.123Z");
        assert!(
            result.is_ok(),
            "Coinbase UTC format should parse: {result:?}"
        );

        // Bithumb format (should handle KST)
        let result = parse_rfc3339_timestamp("2023-12-25T21:30:45+09:00");
        assert!(
            result.is_ok(),
            "Bithumb KST format should parse: {result:?}"
        );

        // ISO8601 variations that some exchanges might use
        let result = parse_rfc3339_timestamp("2023-12-25T12:30:45.000Z");
        assert!(
            result.is_ok(),
            "ISO8601 with exact milliseconds should parse: {result:?}"
        );
    }

    #[test]
    fn test_parse_rfc3339_timestamp_performance() {
        // Performance test with many timestamps
        let timestamps = vec![
            "2023-12-25T12:30:45Z",
            "2023-12-25T12:30:45.123Z",
            "2023-12-25T12:30:45.123456Z",
            "2023-12-25T12:30:45.123456789Z",
            "2023-12-25T21:30:45+09:00",
            "2023-12-25T07:30:45-05:00",
        ];

        let start = std::time::Instant::now();
        for _ in 0..1000 {
            for timestamp in &timestamps {
                let result = parse_rfc3339_timestamp(timestamp);
                assert!(result.is_ok(), "Timestamp should parse: {timestamp}");
            }
        }
        let duration = start.elapsed();

        // Should be fast enough for HFT (< 50ms for 6000 parses)
        assert!(
            duration.as_millis() < 50,
            "Parsing should be fast: {duration:?}"
        );
    }

    #[test]
    fn test_parse_rfc3339_timestamp_basic_validation() {
        // Test basic validation (original failing tests)
        assert!(parse_rfc3339_timestamp("").is_err());
        assert!(parse_rfc3339_timestamp("invalid").is_err());
        assert!(parse_rfc3339_timestamp("not-a-timestamp").is_err());
    }

    #[test]
    fn test_parse_timestamp_with_fallback() {
        // Test fallback behavior
        let result = parse_timestamp_with_fallback("", "test");
        assert!(result > 0, "Fallback should return a valid timestamp");

        let result2 = parse_timestamp_with_fallback("invalid", "test");
        assert!(result2 > 0, "Fallback should return a valid timestamp");

        // Should return recent timestamp (within last few seconds)
        let now = get_timestamp_ns_result().unwrap();
        let diff = result2.abs_diff(now);
        assert!(diff < 5_000_000_000, "Fallback timestamp should be recent"); // Within 5 seconds
    }

    #[test]
    fn test_monotonic_vs_epoch_timestamps() {
        // Test that monotonic and epoch timestamps are different
        let monotonic_ns = get_monotonic_timestamp_ns();
        let epoch_ns = get_epoch_timestamp_ns();

        // Monotonic time should be much smaller than epoch time
        // (epoch time is ~1.7e18 ns, monotonic time is typically < 1e15 ns)
        assert!(
            monotonic_ns < epoch_ns,
            "Monotonic time ({monotonic_ns}) should be less than epoch time ({epoch_ns})"
        );

        // Epoch time should be reasonable (after 2020)
        let year_2020_ns = 1_577_836_800_000_000_000u64; // 2020-01-01 00:00:00 UTC
        assert!(
            epoch_ns > year_2020_ns,
            "Epoch timestamp should be after 2020: {epoch_ns}"
        );
    }

    #[test]
    fn test_clock_raw_documentation() {
        // This test serves as documentation for Clock::raw() behavior
        let clock = Clock::new();
        let monotonic1 = get_quanta_timestamp_ns(&clock);
        let monotonic2 = clock.raw();

        // Both should be very close (within 1ms)
        let diff = monotonic2.abs_diff(monotonic1);
        assert!(diff < 1_000_000, "Clock::raw() calls should be very close");

        // Monotonic time should be much smaller than epoch time
        let epoch_ns = get_epoch_timestamp_ns();
        assert!(
            monotonic1 < epoch_ns / 1000,
            "Monotonic time should be orders of magnitude smaller than epoch time"
        );
    }

    #[test]
    fn test_epoch_timestamp_functions() {
        // Test that epoch timestamp functions return reasonable values
        let epoch_ns = get_epoch_timestamp_ns();
        let system_ns = get_timestamp_ns_result().unwrap();

        // Should be very close (within 1 second)
        let diff = epoch_ns.abs_diff(system_ns);
        assert!(
            diff < 1_000_000_000,
            "Epoch timestamp functions should return similar values"
        );

        // Should be after 2020
        let year_2020_ns = 1_577_836_800_000_000_000u64;
        assert!(
            epoch_ns > year_2020_ns,
            "Epoch timestamp should be after 2020"
        );
    }

    #[test]
    fn test_safe_timestamp_functions() {
        // Test that safe versions never panic
        let ms_safe = get_timestamp_ms_safe();
        assert!(ms_safe.is_some(), "Safe version should return Some");

        let ns_safe = get_timestamp_ns_safe();
        assert!(ns_safe.is_some(), "Safe version should return Some");

        let epoch_safe = get_epoch_timestamp_ns_safe();
        assert!(epoch_safe.is_some(), "Safe version should return Some");
    }

    #[test]
    fn test_clock_error_behavior() {
        // This test documents the expected behavior with clock errors
        // In production, the system clock should never fail, but if it does:

        #[cfg(feature = "panic-on-clock-error")]
        {
            // With the feature enabled, functions would panic on clock error
            // We can't test the actual panic without mocking SystemTime
            // This is just documentation
        }

        #[cfg(not(feature = "panic-on-clock-error"))]
        {
            // Without the feature, functions return sentinel values on error
            // The sentinel values are near u64::MAX to indicate error
            // Again, we can't test without mocking, but this documents behavior
        }

        // The safe versions always return None on error instead of panicking
        // This is the recommended approach when clock errors can be handled gracefully
    }

    #[test]
    fn test_system_time_to_nanos() {
        // Test with current system time
        let now = SystemTime::now();
        let timestamp_ns = system_time_to_nanos(now);

        // Should be reasonable (after 2020)
        let year_2020_ns = 1_577_836_800_000_000_000u64; // 2020-01-01 00:00:00 UTC
        assert!(
            timestamp_ns > year_2020_ns,
            "Timestamp should be after 2020: {timestamp_ns}"
        );

        // Should be close to get_epoch_timestamp_ns()
        let epoch_ns = get_epoch_timestamp_ns();
        let diff = timestamp_ns.abs_diff(epoch_ns);
        assert!(
            diff < 1_000_000_000, // Within 1 second
            "system_time_to_nanos should be close to get_epoch_timestamp_ns: diff={diff}ns"
        );

        // Test with Unix epoch
        let epoch_time = UNIX_EPOCH;
        let epoch_timestamp = system_time_to_nanos(epoch_time);
        assert_eq!(
            epoch_timestamp, 0,
            "Unix epoch should convert to 0 nanoseconds"
        );

        // Test with a known timestamp (2023-01-01 00:00:00 UTC)
        let known_time = UNIX_EPOCH + std::time::Duration::from_secs(1_672_531_200); // 2023-01-01
        let known_timestamp = system_time_to_nanos(known_time);
        let expected_ns = 1_672_531_200_000_000_000_u64;
        assert_eq!(
            known_timestamp, expected_ns,
            "Known timestamp should convert correctly"
        );
    }

    #[test]
    fn test_format_timestamp_fix() {
        // Test Unix epoch
        assert_eq!(format_timestamp_fix(0), "19700101-00:00:00");

        // Test known timestamp: 2023-12-25 12:30:45 UTC
        let timestamp = 1703507445;
        assert_eq!(format_timestamp_fix(timestamp), "20231225-12:30:45");

        // Test another known timestamp: 2024-01-01 00:00:00 UTC
        let timestamp = 1704067200;
        assert_eq!(format_timestamp_fix(timestamp), "20240101-00:00:00");

        // Test with current time (should not panic)
        let current_secs = get_epoch_timestamp_ns() / 1_000_000_000;
        let formatted = format_timestamp_fix(current_secs);
        assert!(formatted.len() == 17); // YYYYMMDD-HH:MM:SS
        assert!(formatted.contains('-'));
        assert!(formatted.contains(':'));
    }

    #[test]
    fn test_format_timestamp_fix_millis() {
        // Test Unix epoch
        assert_eq!(format_timestamp_fix_millis(0), "19700101-00:00:00.000");

        // Test known timestamp: 2023-12-25 12:30:45 UTC
        let timestamp = 1703507445;
        assert_eq!(
            format_timestamp_fix_millis(timestamp),
            "20231225-12:30:45.000"
        );

        // Should always end with .000 since input is in seconds
        let result = format_timestamp_fix_millis(timestamp);
        assert!(result.ends_with(".000"));
        assert_eq!(result.len(), 21); // YYYYMMDD-HH:MM:SS.sss
    }

    #[test]
    fn test_format_current_time_fix() {
        // Test that current time formatting works
        let current_fix = format_current_time_fix();

        // Should have correct format
        assert_eq!(current_fix.len(), 17); // YYYYMMDD-HH:MM:SS
        assert!(current_fix.contains('-'));
        assert!(current_fix.contains(':'));

        // Should start with current year (2025 or later)
        let year_str = &current_fix[0..4];
        let year: u32 = year_str.parse().expect("Should parse year");
        assert!(year >= 2025, "Year should be 2025 or later, got {year}");

        // Verify format structure
        assert_eq!(&current_fix[8..9], "-");
        assert_eq!(&current_fix[11..12], ":");
        assert_eq!(&current_fix[14..15], ":");
    }

    /// Comprehensive FIX timestamp testing for production compliance
    /// Tests edge cases, leap years, boundaries, and FIX protocol requirements
    #[test]
    fn test_format_timestamp_fix_comprehensive_edge_cases() {
        // Test Year 2000 (Y2K boundary) - Jan 1, 2000 00:00:00 UTC
        let y2k_timestamp = 946684800;
        assert_eq!(format_timestamp_fix(y2k_timestamp), "20000101-00:00:00");

        // Test leap year Feb 29, 2000 (2000 is a leap year)
        let leap_day_2000 = 951782400; // 2000-02-29 00:00:00
        assert_eq!(format_timestamp_fix(leap_day_2000), "20000229-00:00:00");

        // Test leap year Feb 29, 2024 (recent leap year)
        let leap_day_2024 = 1709164800; // 2024-02-29 00:00:00
        assert_eq!(format_timestamp_fix(leap_day_2024), "20240229-00:00:00");

        // Test end of year - Dec 31, 2023 23:59:59
        let end_of_year = 1704067199;
        assert_eq!(format_timestamp_fix(end_of_year), "20231231-23:59:59");

        // Test start of next year - Jan 1, 2024 00:00:00
        let start_of_year = 1704067200;
        assert_eq!(format_timestamp_fix(start_of_year), "20240101-00:00:00");

        // Test far future timestamp - Jan 1, 2050 00:00:00
        let future_timestamp = 2524608000;
        assert_eq!(format_timestamp_fix(future_timestamp), "20500101-00:00:00");

        // Test timezone edge case - UTC midnight transitions
        let utc_midnight = 1703980800; // 2023-12-31 00:00:00 UTC
        assert_eq!(format_timestamp_fix(utc_midnight), "20231231-00:00:00");
    }

    #[test]
    fn test_format_timestamp_fix_protocol_compliance() {
        // FIX protocol requires specific format: YYYYMMDD-HH:MM:SS
        let test_cases = [
            (0, "19700101-00:00:00"),          // Unix epoch
            (3661, "19700101-01:01:01"),       // 1 hour, 1 minute, 1 second
            (86400, "19700102-00:00:00"),      // Exactly 1 day
            (31536000, "19710101-00:00:00"),   // Exactly 1 year (365 days)
            (1609459200, "20210101-00:00:00"), // New Year 2021
        ];

        for (timestamp, expected) in test_cases {
            let result = format_timestamp_fix(timestamp);
            assert_eq!(result, expected, "Timestamp {timestamp} failed FIX format");

            // Verify FIX protocol format requirements
            assert_eq!(
                result.len(),
                17,
                "FIX timestamp must be exactly 17 characters"
            );
            assert_eq!(&result[8..9], "-", "Must have dash separator at position 8");
            assert_eq!(&result[11..12], ":", "Must have colon at position 11");
            assert_eq!(&result[14..15], ":", "Must have colon at position 14");

            // Verify all characters are digits or separators
            for (i, ch) in result.chars().enumerate() {
                match i {
                    8 => assert_eq!(ch, '-', "Position 8 must be dash"),
                    11 | 14 => assert_eq!(ch, ':', "Positions 11,14 must be colons"),
                    _ => assert!(
                        ch.is_ascii_digit(),
                        "Position {i} must be digit, got '{ch}'"
                    ),
                }
            }
        }
    }

    #[test]
    fn test_format_timestamp_fix_millis_precision() {
        // Test millisecond precision format for FIX protocol
        let timestamp = 1703507445; // 2023-12-25 12:30:45

        let result = format_timestamp_fix_millis(timestamp);
        assert_eq!(result, "20231225-12:30:45.000");

        // Verify millisecond format compliance
        assert_eq!(
            result.len(),
            21,
            "FIX millis timestamp must be 21 characters"
        );
        assert!(
            result.ends_with(".000"),
            "Must end with .000 for second precision"
        );
        assert_eq!(
            &result[17..18],
            ".",
            "Must have dot separator at position 17"
        );

        // Verify the base part matches non-millis version
        let base_result = format_timestamp_fix(timestamp);
        assert_eq!(&result[0..17], base_result.as_str());
    }

    #[test]
    fn test_format_timestamp_fix_performance() {
        // Performance test for high-frequency trading requirements
        let timestamp = 1703507445;
        let iterations = 10000;

        let start = std::time::Instant::now();
        for _ in 0..iterations {
            let _ = format_timestamp_fix(timestamp);
        }
        let duration = start.elapsed();

        // Should format 10,000 timestamps in < 50ms (HFT requirement)
        assert!(
            duration.as_millis() < 50,
            "FIX timestamp formatting too slow: {duration:?} for {iterations} iterations"
        );

        // Test millisecond version performance
        let start_millis = std::time::Instant::now();
        for _ in 0..iterations {
            let _ = format_timestamp_fix_millis(timestamp);
        }
        let duration_millis = start_millis.elapsed();

        assert!(
            duration_millis.as_millis() < 100,
            "FIX millis timestamp formatting too slow: {duration_millis:?}"
        );
    }

    #[test]
    fn test_format_timestamp_fix_trading_session_times() {
        // Test typical trading session times for major exchanges

        // NYSE opening: 9:30 AM EST (14:30 UTC) on 2024-01-02
        let nyse_open = 1704205800; // 2024-01-02 14:30:00 UTC
        assert_eq!(format_timestamp_fix(nyse_open), "20240102-14:30:00");

        // London market close: 4:30 PM GMT (16:30 UTC) on 2024-01-02
        let london_close = 1704213000; // 2024-01-02 16:30:00 UTC
        assert_eq!(format_timestamp_fix(london_close), "20240102-16:30:00");

        // Tokyo market open: 9:00 AM JST (00:00 UTC next day) on 2024-01-03
        let tokyo_open = 1704240000; // 2024-01-03 00:00:00 UTC
        assert_eq!(format_timestamp_fix(tokyo_open), "20240103-00:00:00");

        // After-hours trading: 8:00 PM EST (01:00 UTC next day)
        let after_hours = 1704250800; // 2024-01-03 03:00:00 UTC
        assert_eq!(format_timestamp_fix(after_hours), "20240103-03:00:00");
    }

    #[test]
    fn test_format_timestamp_fix_consistency() {
        // Test that same timestamp always produces same result
        let timestamp = 1703507445;
        let results: Vec<SmartString> = (0..100).map(|_| format_timestamp_fix(timestamp)).collect();

        let first = &results[0];
        for (i, result) in results.iter().enumerate() {
            assert_eq!(
                result, first,
                "Inconsistent result at iteration {i}: got '{result}', expected '{first}'"
            );
        }
    }

    #[test]
    fn test_format_timestamp_fix_memory_efficiency() {
        // Test that SmartString is used efficiently (stack allocation for short strings)
        let timestamp = 1703507445;
        let result = format_timestamp_fix(timestamp);

        // FIX timestamps (17 chars) should fit in SmartString's inline buffer
        assert_eq!(result.len(), 17);

        // Test that the result is a proper SmartString
        assert!(
            result.capacity() >= 17,
            "SmartString should have sufficient capacity"
        );
    }

    #[test]
    fn test_format_current_time_fix_real_time() {
        // Test current time formatting with real-time validation
        let before = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        let fix_formatted = format_current_time_fix();

        let after = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        // Parse the year, month, day from the formatted string
        let year: u32 = fix_formatted[0..4].parse().expect("Should parse year");
        let month: u32 = fix_formatted[4..6].parse().expect("Should parse month");
        let day: u32 = fix_formatted[6..8].parse().expect("Should parse day");
        let hour: u32 = fix_formatted[9..11].parse().expect("Should parse hour");
        let minute: u32 = fix_formatted[12..14].parse().expect("Should parse minute");
        let second: u32 = fix_formatted[15..17].parse().expect("Should parse second");

        // Validate ranges
        assert!(year >= 2025, "Year should be current or future");
        assert!((1..=12).contains(&month), "Month should be 1-12");
        assert!((1..=31).contains(&day), "Day should be 1-31");
        assert!(hour <= 23, "Hour should be 0-23");
        assert!(minute <= 59, "Minute should be 0-59");
        assert!(second <= 59, "Second should be 0-59");

        // The formatted time should be within reasonable bounds
        // This validates our function works with real system time
        assert!(after >= before, "Time should move forward");
    }
}