tcss_core/

import.rs

//! Import system for TCSS
//!
//! This module handles processing @import statements:
//! - Loading imported files
//! - Parsing imported content
//! - Circular import detection
//! - Import caching
//! - Merging imported ASTs

use crate::ast::{ASTNode, Program};
use crate::lexer::Lexer;
use crate::parser::Parser;
use crate::resolver::{ImportType, Resolver};
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::Path;

/// Import cache entry
#[derive(Debug, Clone)]
struct CacheEntry {
    /// Parsed program
    program: Program,
    
    /// File modification time (for cache invalidation)
    #[allow(dead_code)]
    modified: Option<std::time::SystemTime>,
}

/// Import processor with caching and circular detection
pub struct ImportProcessor {
    /// Path resolver
    resolver: Resolver,
    
    /// Cache of parsed imports
    cache: HashMap<String, CacheEntry>,
    
    /// Currently processing imports (for circular detection)
    processing: HashSet<String>,
    
    /// Enable caching
    cache_enabled: bool,
}

impl ImportProcessor {
    /// Create a new import processor
    pub fn new<P: AsRef<Path>>(base_dir: P) -> Self {
        Self {
            resolver: Resolver::new(base_dir),
            cache: HashMap::new(),
            processing: HashSet::new(),
            cache_enabled: true,
        }
    }
    
    /// Enable or disable caching
    pub fn set_cache_enabled(&mut self, enabled: bool) {
        self.cache_enabled = enabled;
    }
    
    /// Clear the import cache
    pub fn clear_cache(&mut self) {
        self.cache.clear();
    }
    
    /// Process all imports in a program
    pub fn process_imports(&mut self, program: &mut Program) -> Result<(), String> {
        // Find all import nodes
        let mut imports_to_process = Vec::new();
        
        for (index, node) in program.nodes.iter().enumerate() {
            if let ASTNode::Import { path } = node {
                imports_to_process.push((index, path.clone()));
            }
        }
        
        // Process imports in reverse order to maintain correct indices
        for (index, path) in imports_to_process.iter().rev() {
            let imported_program = self.load_import(path)?;
            
            // Remove the import node
            program.nodes.remove(*index);
            
            // Insert imported nodes at the same position
            for (offset, node) in imported_program.nodes.iter().enumerate() {
                program.nodes.insert(index + offset, node.clone());
            }
        }
        
        Ok(())
    }
    
    /// Load and parse an import
    fn load_import(&mut self, path: &str) -> Result<Program, String> {
        // Resolve the import path
        let resolved = self.resolver.resolve(path)?;
        
        // Check for circular imports
        if self.processing.contains(&resolved.resolved_path) {
            return Err(format!("Circular import detected: {}", path));
        }
        
        // Check cache
        if self.cache_enabled {
            if let Some(entry) = self.cache.get(&resolved.resolved_path) {
                return Ok(entry.program.clone());
            }
        }
        
        // Mark as processing
        self.processing.insert(resolved.resolved_path.clone());
        
        // Load the file content
        let content = match resolved.import_type {
            ImportType::Url => self.load_url(&resolved.resolved_path)?,
            _ => self.load_file(&resolved.resolved_path)?,
        };
        
        // Parse the content
        let mut lexer = Lexer::new(&content);
        let tokens = lexer.tokenize()
            .map_err(|e| format!("Error tokenizing {}: {}", path, e))?;
        
        let mut parser = Parser::new(tokens);
        let mut program = parser.parse()
            .map_err(|e| format!("Error parsing {}: {}", path, e))?;
        
        // Update resolver base directory for nested imports
        let old_base = self.resolver.base_dir().to_path_buf();
        if let ImportType::Relative | ImportType::Absolute = resolved.import_type {
            if let Some(parent) = Path::new(&resolved.resolved_path).parent() {
                self.resolver.set_base_dir(parent);
            }
        }
        
        // Recursively process imports in the imported file
        self.process_imports(&mut program)?;
        
        // Restore base directory
        self.resolver.set_base_dir(old_base);
        
        // Remove from processing set
        self.processing.remove(&resolved.resolved_path);
        
        // Cache the result
        if self.cache_enabled {
            self.cache.insert(
                resolved.resolved_path.clone(),
                CacheEntry {
                    program: program.clone(),
                    modified: None,
                },
            );
        }
        
        Ok(program)
    }

    /// Load content from a file
    fn load_file(&self, path: &str) -> Result<String, String> {
        fs::read_to_string(path)
            .map_err(|e| format!("Failed to read file {}: {}", path, e))
    }

    /// Load content from a URL
    fn load_url(&self, url: &str) -> Result<String, String> {
        // For now, return an error as URL loading requires HTTP client
        // In a real implementation, use reqwest or similar
        Err(format!(
            "URL imports not yet supported in this environment: {}. \
            To enable URL imports, add an HTTP client dependency.",
            url
        ))
    }

    /// Get the resolver (for testing)
    pub fn resolver(&self) -> &Resolver {
        &self.resolver
    }

    /// Get mutable resolver
    pub fn resolver_mut(&mut self) -> &mut Resolver {
        &mut self.resolver
    }
}

impl Default for ImportProcessor {
    fn default() -> Self {
        Self::new(".")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use std::io::Write;
    use tempfile::TempDir;

    #[test]
    fn test_process_simple_import() {
        let temp_dir = TempDir::new().unwrap();
        let base_path = temp_dir.path();

        // Create a file to import
        let import_file = base_path.join("colors.tcss");
        let mut file = fs::File::create(&import_file).unwrap();
        writeln!(file, "@var primary: #3498db").unwrap();
        writeln!(file, "@var secondary: #2ecc71").unwrap();

        // Create main file with import
        let main_content = "@import './colors.tcss'\n\n.button:\n    background: primary";

        let mut lexer = Lexer::new(main_content);
        let tokens = lexer.tokenize().unwrap();
        let mut parser = Parser::new(tokens);
        let mut program = parser.parse().unwrap();

        // Process imports
        let mut processor = ImportProcessor::new(base_path);
        processor.process_imports(&mut program).unwrap();

        // Should have 3 nodes: 2 variables + 1 CSS rule
        assert_eq!(program.nodes.len(), 3);
    }

    #[test]
    fn test_circular_import_detection() {
        let temp_dir = TempDir::new().unwrap();
        let base_path = temp_dir.path();

        // Create file A that imports B
        let file_a = base_path.join("a.tcss");
        let mut f = fs::File::create(&file_a).unwrap();
        writeln!(f, "@import './b.tcss'").unwrap();

        // Create file B that imports A (circular)
        let file_b = base_path.join("b.tcss");
        let mut f = fs::File::create(&file_b).unwrap();
        writeln!(f, "@import './a.tcss'").unwrap();

        // Try to process
        let mut lexer = Lexer::new("@import './a.tcss'");
        let tokens = lexer.tokenize().unwrap();
        let mut parser = Parser::new(tokens);
        let mut program = parser.parse().unwrap();

        let mut processor = ImportProcessor::new(base_path);
        let result = processor.process_imports(&mut program);

        assert!(result.is_err());
        assert!(result.unwrap_err().contains("Circular import"));
    }

    #[test]
    fn test_cache() {
        let temp_dir = TempDir::new().unwrap();
        let base_path = temp_dir.path();

        // Create a file to import
        let import_file = base_path.join("vars.tcss");
        let mut file = fs::File::create(&import_file).unwrap();
        writeln!(file, "@var x: 10").unwrap();

        let mut processor = ImportProcessor::new(base_path);

        // First load
        let result1 = processor.load_import("./vars.tcss").unwrap();
        assert_eq!(processor.cache.len(), 1);

        // Second load (should use cache)
        let result2 = processor.load_import("./vars.tcss").unwrap();
        assert_eq!(result1.nodes.len(), result2.nodes.len());

        // Clear cache
        processor.clear_cache();
        assert_eq!(processor.cache.len(), 0);
    }
}