aimx/info_library/

registry.rs

use std::sync::OnceLock;
use std::collections::HashMap;
use crate::info_library::FunctionCard;

/// Global registry providing access to all function documentation.
/// 
/// Uses static initialization with OnceLock for thread-safe singleton access.
/// Provides efficient lookup by identifier and category.
pub struct FunctionInfoRegistry {
    /// All function cards in insertion order
    cards: Vec<FunctionCard>,
    
    /// Map from function identifier to card index
    by_identifier: HashMap<&'static str, usize>,
    
    /// Map from category name to list of card indices
    by_category: HashMap<&'static str, Vec<usize>>,
    
    /// Search index for text-based lookup
    search_index: HashMap<String, Vec<usize>>,
}

impl FunctionInfoRegistry {
    /// Get the global singleton instance.
    /// 
    /// Uses OnceLock for lazy initialization - first call builds the registry,
    /// subsequent calls return the cached instance.
    pub fn global() -> &'static Self {
        static REGISTRY: OnceLock<FunctionInfoRegistry> = OnceLock::new();
        REGISTRY.get_or_init(Self::initialize)
    }
    
    /// Initialize the registry with all function documentation.
    fn initialize() -> Self {
        let mut cards = Vec::new();
        
        // Build cards from all modules - these functions will be created
        // in subsequent sub-plans as each module is documented
        cards.extend(Self::build_text_cards());
        cards.extend(Self::build_math_cards());
        cards.extend(Self::build_business_cards());
        cards.extend(Self::build_date_cards());
        cards.extend(Self::build_collection_cards());
        cards.extend(Self::build_statistical_cards());
        cards.extend(Self::build_functional_cards());
        cards.extend(Self::build_set_cards());
        cards.extend(Self::build_task_cards());
        cards.extend(Self::build_misc_cards());
        
        // Build lookup indices
        let mut by_identifier = HashMap::new();
        let mut by_category = HashMap::new();
        let mut search_index = HashMap::new();
        
        for (index, card) in cards.iter().enumerate() {
            // Identifier index
            by_identifier.insert(card.identifier, index);
            
            // Category index
            for &category in card.categories {
                by_category.entry(category).or_insert_with(Vec::new).push(index);
            }
            
            // Search index
            let searchable_text = format!("{} {} {}", 
                card.identifier, 
                card.brief, 
                card.description
            ).to_lowercase();
            
            // Index by individual words
            for word in searchable_text.split_whitespace() {
                // Remove punctuation from the word
                let clean_word = word.trim_matches(|c: char| !c.is_alphanumeric());
                if clean_word.len() > 2 { // Skip very short words
                    search_index.entry(clean_word.to_string())
                        .or_insert_with(Vec::new)
                        .push(index);
                }
            }
        }
        
        Self {
            cards,
            by_identifier,
            by_category,
            search_index,
        }
    }
    
    /// Get function card by identifier.
    pub fn get(&self, identifier: &str) -> Option<&FunctionCard> {
        self.by_identifier.get(identifier).map(|&index| &self.cards[index])
    }
    
    /// Get function card by identifier with error handling.
    pub fn get_required(&self, identifier: &str) -> Result<&FunctionCard, String> {
        self.get(identifier)
            .ok_or_else(|| format!("Function '{}' not found in registry", identifier))
    }
    
    /// Get all functions in a specific category.
    pub fn by_category(&self, category: &str) -> Vec<&FunctionCard> {
        self.by_category.get(category)
            .map(|indices| {
                indices.iter()
                    .map(|&i| &self.cards[i])
                    .collect()
            })
            .unwrap_or_default()
    }
    
    /// Get all available categories.
    pub fn categories(&self) -> Vec<&'static str> {
        super::categories::FunctionCategory::all()
    }
    
    /// Search functions by query string.
    pub fn search(&self, query: &str) -> Vec<&FunctionCard> {
        let query = query.to_lowercase();
        
        // Direct identifier match (case-insensitive)
        for (identifier, &index) in &self.by_identifier {
            if identifier.to_lowercase() == query {
                return vec![&self.cards[index]];
            }
        }
        
        // Search by words in identifier, brief, and description
        let mut results = std::collections::HashSet::new();
        for word in query.split_whitespace() {
            if word.len() > 2 { // Skip very short words
                if let Some(indices) = self.search_index.get(word) {
                    for &index in indices {
                        results.insert(index);
                    }
                }
            }
        }
        
        // Sort results by relevance (identifier matches first)
        let mut result_vec: Vec<_> = results.into_iter()
            .map(|index| &self.cards[index])
            .collect();
        
        result_vec.sort_by(|a, b| {
            let a_match = a.identifier.to_lowercase().contains(&query);
            let b_match = b.identifier.to_lowercase().contains(&query);
            b_match.cmp(&a_match) // Prioritize identifier matches
        });
        
        result_vec
    }
    
    /// Get all functions.
    pub fn all_functions(&self) -> Vec<&FunctionCard> {
        self.cards.iter().collect()
    }
    
    /// Get total function count.
    pub fn count(&self) -> usize {
        self.cards.len()
    }
    
    fn build_text_cards() -> Vec<FunctionCard> { 
        super::text_cards::TEXT_CARDS.to_vec()
    }
    fn build_math_cards() -> Vec<FunctionCard> { 
        super::math_cards::MATH_CARDS.to_vec()
    }
    fn build_business_cards() -> Vec<FunctionCard> { 
        super::business_cards::BUSINESS_CARDS.to_vec()
    }
    fn build_date_cards() -> Vec<FunctionCard> { 
        super::date_cards::DATE_CARDS.to_vec()
    }
    fn build_collection_cards() -> Vec<FunctionCard> { 
        super::collection_cards::COLLECTION_CARDS.to_vec()
    }
    fn build_statistical_cards() -> Vec<FunctionCard> { 
        super::statistical_cards::STATISTICAL_CARDS.to_vec()
    }
    fn build_functional_cards() -> Vec<FunctionCard> { 
        super::functional_cards::FUNCTIONAL_CARDS.iter().map(|&card| card.clone()).collect()
    }
    fn build_set_cards() -> Vec<FunctionCard> { 
        super::set_cards::SET_CARDS.to_vec()
    }
    fn build_task_cards() -> Vec<FunctionCard> { 
        super::task_cards::TASK_CARDS.to_vec()
    }
    fn build_misc_cards() -> Vec<FunctionCard> { 
        super::misc_cards::get_misc_function_cards()
    }
}