zipora 3.1.7

//! Statistics and Monitoring - consolidated minimal module.
//!
//! Previously 5,275 LOC across 7 sub-modules. Collapsed to type stubs that
//! preserve the public API for downstream compatibility. None of these types
//! are used by the core library; they exist only as exported API surface.
//!
//! For actual profiling/timing, use `dev_infrastructure::debug` (StatsScopedTimer,
//! HighPrecisionTimer, BenchmarkSuite).

use crate::error::ZiporaError;
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::time::{Duration, Instant};

// ============================================================================
// Core types (from mod.rs)
// ============================================================================
/// Simple statistics
#[derive(Debug, Clone)]
pub struct TrieStat {
    pub insert_time: f64,
    pub lookup_time: f64,
    pub build_time: f64,
    pub total_bytes: u64,
}

impl Default for TrieStat {
    fn default() -> Self {
        Self::new()
    }
}

impl TrieStat {
    pub fn new() -> Self {
        Self {
            insert_time: 0.0,
            lookup_time: 0.0,
            build_time: 0.0,
            total_bytes: 0,
        }
    }
}

/// Composite statistics
#[derive(Debug)]
pub struct TrieStatistics {
    pub memory: StatsMemoryStats,
    pub performance: StatsPerformanceStats,
    pub compression: StatsCompressionStats,
    pub distribution: DistributionStats,
    pub errors: ErrorStats,
    pub timing: TimingStats,
}

impl Default for TrieStatistics {
    fn default() -> Self {
        Self::new()
    }
}

impl TrieStatistics {
    pub fn new() -> Self {
        Self {
            memory: StatsMemoryStats::new(),
            performance: StatsPerformanceStats::new(),
            compression: StatsCompressionStats::new(),
            distribution: DistributionStats::new(),
            errors: ErrorStats::new(),
            timing: TimingStats::new(),
        }
    }
    pub fn merge(&mut self, _other: &TrieStatistics) {}
    pub fn reset(&mut self) {}
    pub fn generate_report(&self) -> String {
        String::new()
    }
}

#[derive(Debug, Clone, Copy)]
pub enum MemoryCategory {
    Nodes,
    Cache,
    Overhead,
}

#[derive(Debug, Clone, Copy)]
pub enum ErrorType {
    Memory,
    Io,
    Corruption,
    Timeout,
    Other,
}

// ============================================================================
// StatsMemoryStats
// ============================================================================

#[derive(Debug)]
pub struct StatsMemoryStats {
    pub total_allocated: AtomicUsize,
    pub nodes_memory: AtomicUsize,
    pub cache_memory: AtomicUsize,
    pub overhead_memory: AtomicUsize,
    pub peak_memory: AtomicUsize,
    pub allocation_count: AtomicU64,
    pub deallocation_count: AtomicU64,
}

impl Default for StatsMemoryStats {
    fn default() -> Self {
        Self::new()
    }
}

impl StatsMemoryStats {
    pub fn new() -> Self {
        Self {
            total_allocated: AtomicUsize::new(0),
            nodes_memory: AtomicUsize::new(0),
            cache_memory: AtomicUsize::new(0),
            overhead_memory: AtomicUsize::new(0),
            peak_memory: AtomicUsize::new(0),
            allocation_count: AtomicU64::new(0),
            deallocation_count: AtomicU64::new(0),
        }
    }
    pub fn record_allocation(&self, size: usize, _cat: MemoryCategory) {
        self.allocation_count.fetch_add(1, Ordering::Relaxed);
        self.total_allocated.fetch_add(size, Ordering::Relaxed);
    }
    pub fn record_deallocation(&self, size: usize, _cat: MemoryCategory) {
        self.deallocation_count.fetch_add(1, Ordering::Relaxed);
        self.total_allocated.fetch_sub(size, Ordering::Relaxed);
    }
    pub fn merge(&mut self, _other: &StatsMemoryStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

// ============================================================================
// StatsPerformanceStats
// ============================================================================

#[derive(Debug)]
pub struct StatsPerformanceStats {
    pub insert_count: AtomicU64,
    pub lookup_count: AtomicU64,
    pub delete_count: AtomicU64,
    pub cache_hits: AtomicU64,
    pub cache_misses: AtomicU64,
    pub total_operations: AtomicU64,
    pub failed_operations: AtomicU64,
    pub average_operation_time_ns: AtomicU64,
}

impl Default for StatsPerformanceStats {
    fn default() -> Self {
        Self::new()
    }
}

impl StatsPerformanceStats {
    pub fn new() -> Self {
        Self {
            insert_count: AtomicU64::new(0),
            lookup_count: AtomicU64::new(0),
            delete_count: AtomicU64::new(0),
            cache_hits: AtomicU64::new(0),
            cache_misses: AtomicU64::new(0),
            total_operations: AtomicU64::new(0),
            failed_operations: AtomicU64::new(0),
            average_operation_time_ns: AtomicU64::new(0),
        }
    }
    pub fn record_insert(&self) {
        self.insert_count.fetch_add(1, Ordering::Relaxed);
    }
    pub fn record_lookup(&self, _hit: bool) {
        self.lookup_count.fetch_add(1, Ordering::Relaxed);
    }
    pub fn record_delete(&self) {
        self.delete_count.fetch_add(1, Ordering::Relaxed);
    }
    pub fn merge(&mut self, _other: &StatsPerformanceStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

// ============================================================================
// StatsCompressionStats, DistributionStats, ErrorStats, TimingStats
// ============================================================================

#[derive(Debug)]
pub struct StatsCompressionStats {
    pub original_size: AtomicUsize,
    pub compressed_size: AtomicUsize,
}

impl Default for StatsCompressionStats {
    fn default() -> Self {
        Self::new()
    }
}

impl StatsCompressionStats {
    pub fn new() -> Self {
        Self {
            original_size: AtomicUsize::new(0),
            compressed_size: AtomicUsize::new(0),
        }
    }
    pub fn merge(&mut self, _other: &StatsCompressionStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

#[derive(Debug)]
pub struct DistributionStats {
    pub total_samples: AtomicU64,
}

impl Default for DistributionStats {
    fn default() -> Self {
        Self::new()
    }
}

impl DistributionStats {
    pub fn new() -> Self {
        Self {
            total_samples: AtomicU64::new(0),
        }
    }
    pub fn merge(&mut self, _other: &DistributionStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

#[derive(Debug)]
pub struct ErrorStats {
    pub total_errors: AtomicU64,
}

impl Default for ErrorStats {
    fn default() -> Self {
        Self::new()
    }
}

impl ErrorStats {
    pub fn new() -> Self {
        Self {
            total_errors: AtomicU64::new(0),
        }
    }
    pub fn record_error(&self, _et: ErrorType) {
        self.total_errors.fetch_add(1, Ordering::Relaxed);
    }
    pub fn merge(&mut self, _other: &ErrorStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

#[derive(Debug)]
pub struct TimingStats {
    pub creation_time: Instant,
}

impl Default for TimingStats {
    fn default() -> Self {
        Self::new()
    }
}

impl TimingStats {
    pub fn new() -> Self {
        Self {
            creation_time: Instant::now(),
        }
    }
    pub fn uptime(&self) -> Duration {
        self.creation_time.elapsed()
    }
    pub fn merge(&mut self, _other: &TimingStats) {}
    pub fn reset(&mut self) {}
    pub fn report(&self) -> String {
        String::new()
    }
}

// ============================================================================
// Memory tracking stubs (from memory_tracking.rs)
// ============================================================================

#[derive(Debug, Clone)]
pub struct MemoryBreakdown {
    pub total: usize,
    pub components: HashMap<String, usize>,
}

impl Default for MemoryBreakdown {
    fn default() -> Self {
        Self::new()
    }
}

impl MemoryBreakdown {
    pub fn new() -> Self {
        Self {
            total: 0,
            components: HashMap::new(),
        }
    }
    pub fn add_component(&mut self, name: &str, size: usize) {
        self.total += size;
        self.components.insert(name.to_string(), size);
    }
}

pub struct GlobalMemoryTracker;
impl Default for GlobalMemoryTracker {
    fn default() -> Self {
        Self::new()
    }
}

impl GlobalMemoryTracker {
    pub fn new() -> Self {
        Self
    }
}

pub struct TrackedObject;
pub struct LocalMemoryTracker;
impl Default for LocalMemoryTracker {
    fn default() -> Self {
        Self::new()
    }
}

impl LocalMemoryTracker {
    pub fn new() -> Self {
        Self
    }
}

#[derive(Debug, Clone)]
pub struct FragmentationAnalysis;

// ============================================================================
// Timing stubs (from timing.rs)
// ============================================================================

pub struct Profiling;
pub type QTime = Instant;
pub type QDuration = Duration;

pub struct StatsPerfTimer {
    start: Instant,
}
impl Default for StatsPerfTimer {
    fn default() -> Self {
        Self::new()
    }
}

impl StatsPerfTimer {
    pub fn new() -> Self {
        Self {
            start: Instant::now(),
        }
    }
    pub fn elapsed(&self) -> Duration {
        self.start.elapsed()
    }
}

pub struct TimerCollection;
impl Default for TimerCollection {
    fn default() -> Self {
        Self::new()
    }
}

impl TimerCollection {
    pub fn new() -> Self {
        Self
    }
}

pub struct StatsScopedTimer;
impl StatsScopedTimer {
    pub fn new(_name: &str) -> Self {
        Self
    }
}

pub fn str_date_time_now() -> String {
    format!("{:?}", std::time::SystemTime::now())
}

// ============================================================================
// Histogram stubs (from histogram.rs)
// ============================================================================

#[derive(Debug, Clone)]
pub struct FreqHist {
    counts: Vec<u64>,
}
impl Default for FreqHist {
    fn default() -> Self {
        Self::new()
    }
}

impl FreqHist {
    pub fn new() -> Self {
        Self {
            counts: vec![0u64; 256],
        }
    }
    pub fn add(&mut self, byte: u8) {
        self.counts[byte as usize] += 1;
    }
}

pub type FreqHistO1 = FreqHist;
pub type FreqHistO2 = FreqHist;
pub type HistogramData = FreqHist;
pub type HistogramDataO1 = FreqHist;
pub type HistogramDataO2 = FreqHist;

pub struct HistogramCollection;
impl Default for HistogramCollection {
    fn default() -> Self {
        Self::new()
    }
}

impl HistogramCollection {
    pub fn new() -> Self {
        Self
    }
}

// ============================================================================
// Entropy analysis stubs (from entropy_analysis.rs)
// ============================================================================

pub struct EntropyAnalyzer;
impl Default for EntropyAnalyzer {
    fn default() -> Self {
        Self::new()
    }
}

impl EntropyAnalyzer {
    pub fn new() -> Self {
        Self
    }
}

#[derive(Debug, Clone)]
pub struct EntropyConfig;
impl Default for EntropyConfig {
    fn default() -> Self {
        Self
    }
}

#[derive(Debug, Clone)]
pub struct EntropyResults;

#[derive(Debug, Clone)]
pub struct CompressionEstimates;

#[derive(Debug, Clone)]
pub struct DistributionInfo;

pub struct EntropyAnalyzerCollection;

// ============================================================================
// Buffer management stubs (from buffer_management.rs)
// ============================================================================

pub struct ContextBuffer {
    _data: Vec<u8>,
}
impl ContextBuffer {
    pub fn new(cap: usize) -> Self {
        Self {
            _data: Vec::with_capacity(cap),
        }
    }
}

#[derive(Debug, Clone)]
pub struct BufferMetadata;

#[derive(Debug, Clone, Copy)]
pub enum BufferPriority {
    Low,
    Normal,
    High,
    Critical,
}

pub trait StatisticsContext: Send + Sync {}

pub struct DefaultStatisticsContext;
impl StatisticsContext for DefaultStatisticsContext {}

pub struct BufferPoolManager;
impl BufferPoolManager {
    pub fn new(_config: BufferPoolConfig) -> Self {
        Self
    }
}

#[derive(Debug, Clone)]
pub struct BufferPoolConfig;
impl Default for BufferPoolConfig {
    fn default() -> Self {
        Self
    }
}

pub struct PoolStatistics;
pub struct ScopedBuffer;

// ============================================================================
// Profiling stubs (from profiling.rs — not dev_infrastructure profiling)
// ============================================================================

#[derive(Clone)]
pub struct Profiler;
impl Default for Profiler {
    fn default() -> Self {
        Self
    }
}
impl Profiler {
    pub fn new(_config: ProfilerConfig) -> Self {
        Self
    }
}

#[derive(Debug, Clone)]
pub struct ProfilerConfig {
    pub enabled: bool,
    pub sample_rate: f64,
}
impl Default for ProfilerConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            sample_rate: 1.0,
        }
    }
}

pub struct OperationProfile;

pub struct ProfiledOperation;

static GLOBAL_PROFILER: std::sync::OnceLock<Profiler> = std::sync::OnceLock::new();

pub fn stats_global_profiler() -> &'static Profiler {
    GLOBAL_PROFILER.get_or_init(Profiler::default)
}

pub fn init_global_profiler(config: ProfilerConfig) -> Result<(), ZiporaError> {
    GLOBAL_PROFILER
        .set(Profiler::new(config))
        .map_err(|_| ZiporaError::invalid_data("global profiler already initialized"))
}

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

    #[test]
    fn test_trie_statistics_creation() {
        let stats = TrieStatistics::new();
        assert_eq!(stats.memory.total_allocated.load(Ordering::Relaxed), 0);
    }

    #[test]
    fn test_memory_breakdown() {
        let mut breakdown = MemoryBreakdown::new();
        breakdown.add_component("nodes", 1000);
        breakdown.add_component("cache", 500);
        assert_eq!(breakdown.total, 1500);
        assert_eq!(breakdown.components.len(), 2);
    }

    #[test]
    fn test_freq_hist() {
        let mut hist = FreqHist::new();
        hist.add(65); // 'A'
        hist.add(65);
        assert_eq!(hist.counts[65], 2);
    }
}