lcpfs 2026.1.102

// Copyright 2025 LunaOS Contributors
// SPDX-License-Identifier: Apache-2.0

//! Analytics type definitions

use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;

/// Analytics error types
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AnalyticsError {
    /// Analytics subsystem not initialized
    NotInitialized,
    /// Dataset not found
    DatasetNotFound(String),
    /// Insufficient data for analysis
    InsufficientData,
    /// Internal error
    Internal(String),
}

impl fmt::Display for AnalyticsError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NotInitialized => write!(f, "Analytics not initialized"),
            Self::DatasetNotFound(ds) => write!(f, "Dataset not found: {}", ds),
            Self::InsufficientData => write!(f, "Insufficient data for analysis"),
            Self::Internal(msg) => write!(f, "Internal error: {}", msg),
        }
    }
}

/// Storage usage summary
#[derive(Debug, Clone, Default)]
pub struct UsageSummary {
    /// Total capacity in bytes
    pub total_capacity: u64,
    /// Used space in bytes
    pub used_space: u64,
    /// Free space in bytes
    pub free_space: u64,
    /// Usage percentage (0-100)
    pub usage_percent: f32,
    /// Number of files
    pub file_count: u64,
    /// Number of directories
    pub directory_count: u64,
    /// Number of snapshots
    pub snapshot_count: u64,
    /// Logical size (before dedup/compression)
    pub logical_size: u64,
    /// Physical size (after dedup/compression)
    pub physical_size: u64,
    /// Data reduction ratio
    pub reduction_ratio: f32,
}

/// Detailed space breakdown
#[derive(Debug, Clone, Default)]
pub struct SpaceBreakdown {
    /// Space used by file data
    pub data_space: u64,
    /// Space used by metadata
    pub metadata_space: u64,
    /// Space used by snapshots
    pub snapshot_space: u64,
    /// Space used by dedup tables
    pub dedup_table_space: u64,
    /// Space used by indexes
    pub index_space: u64,
    /// Space reserved for COW operations
    pub reserved_space: u64,
    /// Free space available
    pub free_space: u64,
    /// Reclaimable space (deleted but referenced)
    pub reclaimable_space: u64,
}

/// I/O performance statistics
#[derive(Debug, Clone, Default)]
pub struct IoStats {
    /// Read operations count
    pub read_ops: u64,
    /// Write operations count
    pub write_ops: u64,
    /// Bytes read
    pub bytes_read: u64,
    /// Bytes written
    pub bytes_written: u64,
    /// Average read latency in microseconds
    pub avg_read_latency_us: u64,
    /// Average write latency in microseconds
    pub avg_write_latency_us: u64,
    /// Maximum read latency in microseconds
    pub max_read_latency_us: u64,
    /// Maximum write latency in microseconds
    pub max_write_latency_us: u64,
    /// Read throughput in bytes/second
    pub read_throughput: u64,
    /// Write throughput in bytes/second
    pub write_throughput: u64,
    /// Cache hit rate (0.0-1.0)
    pub cache_hit_rate: f32,
    /// Queue depth
    pub queue_depth: u32,
}

/// Capacity forecast
#[derive(Debug, Clone, Default)]
pub struct CapacityForecast {
    /// Current usage in bytes
    pub current_usage: u64,
    /// Predicted usage at end of period
    pub predicted_usage: u64,
    /// Daily growth rate in bytes
    pub daily_growth_rate: i64,
    /// Days until full (0 = already full, -1 = declining)
    pub days_until_full: i32,
    /// Recommended action
    pub recommendation: ForecastRecommendation,
    /// Confidence level (0.0-1.0)
    pub confidence: f32,
}

/// Forecast recommendation
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub enum ForecastRecommendation {
    /// No action needed
    #[default]
    NoAction,
    /// Consider adding capacity
    ConsiderExpansion,
    /// Expansion needed soon
    ExpansionNeeded,
    /// Critical: immediate action required
    Critical,
    /// Run cleanup/dedup
    RunCleanup,
}

/// Space consumer entry
#[derive(Debug, Clone)]
pub struct SpaceConsumer {
    /// Path to the file/directory
    pub path: String,
    /// Object ID
    pub object_id: u64,
    /// Space used in bytes
    pub space_used: u64,
    /// Percentage of total space
    pub percent_of_total: f32,
    /// Is this a directory
    pub is_directory: bool,
    /// Number of files (if directory)
    pub file_count: u64,
}

/// File type statistics
#[derive(Debug, Clone)]
pub struct FileTypeStats {
    /// File extension or type
    pub file_type: String,
    /// Number of files
    pub count: u64,
    /// Total space used
    pub total_size: u64,
    /// Average file size
    pub avg_size: u64,
    /// Percentage of total space
    pub percent_of_total: f32,
}

/// Deduplication statistics
#[derive(Debug, Clone, Default)]
pub struct DedupStats {
    /// Total blocks
    pub total_blocks: u64,
    /// Unique blocks
    pub unique_blocks: u64,
    /// Deduplicated blocks
    pub dedup_blocks: u64,
    /// Space saved by deduplication
    pub space_saved: u64,
    /// Deduplication ratio
    pub dedup_ratio: f32,
    /// Dedup table entries
    pub table_entries: u64,
    /// Dedup table size
    pub table_size: u64,
}

/// Compression statistics
#[derive(Debug, Clone, Default)]
pub struct CompressionStats {
    /// Total uncompressed size
    pub uncompressed_size: u64,
    /// Total compressed size
    pub compressed_size: u64,
    /// Compression ratio
    pub compression_ratio: f32,
    /// Space saved by compression
    pub space_saved: u64,
    /// Number of compressed blocks
    pub compressed_blocks: u64,
    /// Number of incompressible blocks
    pub incompressible_blocks: u64,
    /// Compression algorithm breakdown
    pub algorithm_stats: BTreeMap<String, AlgorithmStats>,
}

/// Per-algorithm compression statistics
#[derive(Debug, Clone, Default)]
pub struct AlgorithmStats {
    /// Algorithm name
    pub name: String,
    /// Blocks using this algorithm
    pub block_count: u64,
    /// Average compression ratio
    pub avg_ratio: f32,
    /// Total bytes compressed
    pub total_bytes: u64,
}

/// Snapshot usage statistics
#[derive(Debug, Clone, Default)]
pub struct SnapshotUsage {
    /// Total number of snapshots
    pub snapshot_count: u64,
    /// Total space used by all snapshots
    pub total_space: u64,
    /// Space that would be freed if all snapshots deleted
    pub reclaimable_space: u64,
    /// Per-snapshot details
    pub snapshots: Vec<SnapshotDetails>,
}

/// Individual snapshot details
#[derive(Debug, Clone)]
pub struct SnapshotDetails {
    /// Snapshot name
    pub name: String,
    /// Creation timestamp
    pub created: u64,
    /// Exclusive space (unique to this snapshot)
    pub exclusive_space: u64,
    /// Referenced space
    pub referenced_space: u64,
    /// Number of files changed
    pub files_changed: u64,
}

/// Metric types for trending
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum MetricType {
    /// Used space
    UsedSpace,
    /// Free space
    FreeSpace,
    /// File count
    FileCount,
    /// Read IOPS
    ReadIops,
    /// Write IOPS
    WriteIops,
    /// Read throughput
    ReadThroughput,
    /// Write throughput
    WriteThroughput,
    /// Cache hit rate
    CacheHitRate,
    /// Compression ratio
    CompressionRatio,
    /// Dedup ratio
    DedupRatio,
}

/// Trend period
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TrendPeriod {
    /// Last hour (1-minute intervals)
    Hour,
    /// Last day (1-hour intervals)
    Day,
    /// Last week (1-day intervals)
    Week,
    /// Last month (1-day intervals)
    Month,
    /// Last year (1-week intervals)
    Year,
}

/// Trend data point
#[derive(Debug, Clone)]
pub struct TrendPoint {
    /// Timestamp
    pub timestamp: u64,
    /// Value
    pub value: u64,
}

/// Full analytics report
#[derive(Debug, Clone, Default)]
pub struct FullReport {
    /// Report generation timestamp
    pub generated_at: u64,
    /// Dataset name
    pub dataset: String,
    /// Usage summary
    pub usage: UsageSummary,
    /// Space breakdown
    pub space: SpaceBreakdown,
    /// I/O statistics
    pub io: IoStats,
    /// Capacity forecast
    pub forecast: CapacityForecast,
    /// Dedup statistics
    pub dedup: DedupStats,
    /// Compression statistics
    pub compression: CompressionStats,
    /// Snapshot usage
    pub snapshots: SnapshotUsage,
    /// Top consumers
    pub top_consumers: Vec<SpaceConsumer>,
    /// File type distribution
    pub file_types: Vec<FileTypeStats>,
    /// Health score (0-100)
    pub health_score: u8,
    /// Recommendations
    pub recommendations: Vec<String>,
}