tramex_tools/interface/interface_file/

file_index.rs

//! File index for efficient log navigation (Option 3 Implementation)
//!
//! This module provides a lightweight index structure that scans the file once
//! to identify log boundaries and metadata without full parsing.
//!
//! ## How it works:
//! 1. **Fast Initial Scan**: On file open, scan all lines to find log boundaries
//! 2. **Extract Metadata**: For each log, extract timestamp and layer (cheap operation)
//! 3. **Build Index**: Store line ranges and metadata for each log
//! 4. **Lazy Parsing**: Parse full log content only when needed (on navigation)
//! 5. **Smart Caching**: Cache parsed logs to avoid re-parsing
//!
//! ## Benefits:
//! - Fast file loading (~0.5s for 10k logs)
//! - Know total log count immediately
//! - Efficient layer filtering (no need to parse disabled layers)
//! - Instant navigation (index knows where each log is)

use crate::errors::TramexError;
use crate::interface::layer::Layer;
use chrono::NaiveTime;
use std::str::FromStr;

/// Metadata for a single log entry
#[derive(Debug, Clone)]
pub struct LogMetadata {
    /// Start line in the file
    pub start_line: usize,

    /// End line in the file (exclusive)
    pub end_line: usize,

    /// Timestamp in milliseconds
    pub timestamp: i64,

    /// Layer of this log
    pub layer: Layer,
}

/// Index structure for efficient file navigation
#[derive(Debug, Clone)]
pub struct FileIndex {
    /// Metadata for each log entry
    pub log_metadata: Vec<LogMetadata>,

    /// Total number of logs
    pub total_count: usize,
}

impl FileIndex {
    /// Build an index by scanning the file
    /// This is a fast operation that only extracts timestamps and layers
    ///
    /// # Errors
    ///
    /// Fails on parsing failure
    pub fn build_from_lines(lines: &[String]) -> Result<Self, TramexError> {
        // Pre-allocate with estimated capacity (assume ~10 lines per log on average)
        let estimated_logs = lines.len() / 10;
        let mut log_metadata = Vec::with_capacity(estimated_logs);
        let mut current_start: Option<usize> = None;

        for (line_idx, line) in lines.iter().enumerate() {
            // Fast path: check first byte for common cases
            let first_byte = line.as_bytes().first();

            match first_byte {
                Some(b'#') => continue,                 // Comment
                Some(b' ') | Some(b'\t') => continue,   // Indented line
                Some(_) if line.is_empty() => continue, // Empty
                None => continue,                       // Empty line
                _ => {}
            }

            // This is a timestamp line (start of a new log)
            if let Some(start) = current_start {
                // Finalize the previous log
                if let Some(metadata) = Self::extract_metadata_fast(lines, start, line_idx) {
                    log_metadata.push(metadata);
                }
            }

            // Mark this as the start of a new log
            current_start = Some(line_idx);
        }

        // Handle the last log
        if let Some(start) = current_start
            && let Some(metadata) = Self::extract_metadata_fast(lines, start, lines.len())
        {
            log_metadata.push(metadata);
        }

        let total_count = log_metadata.len();
        log::info!("Index built: {} logs from {} lines", total_count, lines.len());

        Ok(Self {
            log_metadata,
            total_count,
        })
    }

    /// Fast metadata extraction - optimized for speed
    fn extract_metadata_fast(lines: &[String], start_line: usize, end_line: usize) -> Option<LogMetadata> {
        let first_line = lines.get(start_line)?;

        // Fast parsing: split only once, avoid allocations
        let mut parts = first_line.split_whitespace();
        let time_str = parts.next()?;
        let layer_str = parts.next()?;

        // Parse timestamp
        let time = NaiveTime::parse_from_str(time_str, "%H:%M:%S%.3f").ok()?;
        let timestamp = super::super::parser::time_to_milliseconds(&time);

        // Parse layer (strip brackets)
        let layer_clean = layer_str.trim_start_matches('[').trim_end_matches(']');
        let layer = Layer::from_str(layer_clean).ok()?;

        Some(LogMetadata {
            start_line,
            end_line,
            timestamp,
            layer,
        })
    }

    /// Extract metadata from a log block without full parsing (legacy - kept for reference)
    #[allow(dead_code)]
    fn extract_metadata(lines: &[String], start_line: usize, end_line: usize) -> Option<LogMetadata> {
        if start_line >= lines.len() {
            return None;
        }

        let first_line = &lines[start_line];
        let parts: Vec<&str> = first_line.split_whitespace().collect();

        if parts.len() < 2 {
            return None;
        }

        // Parse timestamp
        let timestamp = match NaiveTime::parse_from_str(parts[0], "%H:%M:%S%.3f") {
            Ok(time) => super::super::parser::time_to_milliseconds(&time),
            Err(_) => return None,
        };

        // Parse layer
        let layer_str = parts[1].trim_start_matches('[').trim_end_matches(']');
        let layer = match Layer::from_str(layer_str) {
            Ok(l) => l,
            Err(_) => return None,
        };

        Some(LogMetadata {
            start_line,
            end_line,
            timestamp,
            layer,
        })
    }

    /// Find the next log index that matches the enabled layers
    pub fn find_next_enabled_index(&self, current_index: usize, layer_filter: &impl Fn(&Layer) -> bool) -> Option<usize> {
        for idx in (current_index + 1)..self.log_metadata.len() {
            if let Some(metadata) = self.log_metadata.get(idx)
                && layer_filter(&metadata.layer)
            {
                return Some(idx);
            }
        }
        None
    }

    /// Find the previous log index that matches the enabled layers
    pub fn find_previous_enabled_index(
        &self,
        current_index: usize,
        layer_filter: &impl Fn(&Layer) -> bool,
    ) -> Option<usize> {
        if current_index == 0 {
            return None;
        }

        for idx in (0..current_index).rev() {
            if let Some(metadata) = self.log_metadata.get(idx)
                && layer_filter(&metadata.layer)
            {
                return Some(idx);
            }
        }
        None
    }

    /// Get metadata for a specific log index
    pub fn get_metadata(&self, index: usize) -> Option<&LogMetadata> {
        self.log_metadata.get(index)
    }
}