syster-base 0.2.3-alpha

//! Salsa database definition and queries.

use std::path::Path;
use std::sync::Arc;

use crate::base::FileId;
use crate::syntax::SyntaxFile;
use crate::syntax::sysml::ast::types::SysMLFile;

use super::input::SourceRoot;
use super::symbols::{HirSymbol, extract_symbols_unified};

// ============================================================================
// INPUTS
// ============================================================================

/// Input: The raw text content of a file.
///
/// Set this explicitly when a file is opened or changed.
#[salsa::input]
pub struct FileText {
    pub file: FileId,
    #[return_ref]
    pub text: String,
}

/// Input: Configuration for the source root.
#[salsa::input]
pub struct SourceRootInput {
    #[return_ref]
    pub root: SourceRoot,
}

// ============================================================================
// DATABASE IMPLEMENTATION
// ============================================================================

/// The concrete Salsa database implementation.
///
/// This is the "root" database that holds all query storage.
#[salsa::db]
#[derive(Default, Clone)]
pub struct RootDatabase {
    storage: salsa::Storage<Self>,
}

#[salsa::db]
impl salsa::Database for RootDatabase {
    fn salsa_event(&self, _event: &dyn Fn() -> salsa::Event) {
        // Can log events here for debugging
    }
}

impl RootDatabase {
    /// Create a new empty database.
    pub fn new() -> Self {
        Self::default()
    }
}

// ============================================================================
// DERIVED QUERIES
// ============================================================================

/// Result of parsing a file.
///
/// Note: Eq is implemented manually because SysMLFile only derives PartialEq.
/// For Salsa tracking, we treat ParseResults as equal if they have the same
/// success status, errors, and AST presence (AST content equality via PartialEq).
#[derive(Clone, Debug, PartialEq)]
pub struct ParseResult {
    /// The parse was successful (no fatal errors).
    pub success: bool,
    /// Parse errors (may be present even with partial success).
    pub errors: Vec<String>,
    /// The parsed AST (if successful).
    pub ast: Option<Arc<SysMLFile>>,
}

// Manual Eq impl - safe because SysMLFile's PartialEq is reflexive
impl Eq for ParseResult {}

impl ParseResult {
    /// Create a successful parse result.
    pub fn ok(ast: SysMLFile) -> Self {
        Self {
            success: true,
            errors: Vec::new(),
            ast: Some(Arc::new(ast)),
        }
    }

    /// Create a successful parse result with errors (warnings).
    pub fn ok_with_errors(ast: SysMLFile, errors: Vec<String>) -> Self {
        Self {
            success: true,
            errors,
            ast: Some(Arc::new(ast)),
        }
    }

    /// Create a failed parse result with errors.
    pub fn err(errors: Vec<String>) -> Self {
        Self {
            success: false,
            errors,
            ast: None,
        }
    }

    /// Check if parsing succeeded.
    pub fn is_ok(&self) -> bool {
        self.success
    }

    /// Check if there are any errors.
    pub fn has_errors(&self) -> bool {
        !self.errors.is_empty()
    }

    /// Get the AST if parsing succeeded.
    pub fn get_ast(&self) -> Option<&SysMLFile> {
        self.ast.as_deref()
    }
}

/// Parse a file and return whether it succeeded.
///
/// This is a tracked Salsa query - results are memoized and automatically
/// invalidated when the input `FileText` changes.
#[salsa::tracked]
pub fn parse_file(db: &dyn salsa::Database, file_text: FileText) -> ParseResult {
    let text = file_text.text(db);

    // Use the existing parser (with .sysml extension to satisfy parser requirements)
    let result = crate::syntax::sysml::parser::parse_with_result(text, Path::new("file.sysml"));

    if let Some(ast) = result.content {
        let errors: Vec<String> = result.errors.iter().map(|e| format!("{:?}", e)).collect();
        if errors.is_empty() {
            ParseResult::ok(ast)
        } else {
            ParseResult::ok_with_errors(ast, errors)
        }
    } else {
        ParseResult::err(result.errors.iter().map(|e| format!("{:?}", e)).collect())
    }
}

/// Extract symbols from a parsed file.
///
/// This is a pure function that takes a FileId and AST, then returns symbols.
/// It's designed to be composable with other queries.
pub fn file_symbols(file: FileId, ast: &SysMLFile) -> Vec<HirSymbol> {
    extract_symbols_unified(file, &SyntaxFile::SysML(ast.clone()))
}

/// Extract symbols from a file given its text.
///
/// This is a tracked Salsa query that combines parsing + symbol extraction.
/// Results are memoized per-file.
#[salsa::tracked]
pub fn file_symbols_from_text(db: &dyn salsa::Database, file_text: FileText) -> Vec<HirSymbol> {
    let file = file_text.file(db);
    let result = parse_file(db, file_text);
    match result.ast {
        Some(ast) => extract_symbols_unified(file, &SyntaxFile::SysML((*ast).clone())),
        None => Vec::new(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::hir::symbols::SymbolKind;

    #[test]
    fn test_database_creation() {
        let _db = RootDatabase::new();
    }

    #[test]
    fn test_parse_result() {
        let ast = SysMLFile {
            namespace: None,
            namespaces: Vec::new(),
            elements: Vec::new(),
        };

        let ok = ParseResult::ok(ast.clone());
        assert!(ok.is_ok());
        assert!(!ok.has_errors());
        assert!(ok.get_ast().is_some());

        let err = ParseResult::err(vec!["error".to_string()]);
        assert!(!err.is_ok());
        assert!(err.has_errors());
        assert!(err.get_ast().is_none());
    }

    #[test]
    fn test_file_symbols_empty() {
        let ast = SysMLFile {
            namespace: None,
            namespaces: Vec::new(),
            elements: Vec::new(),
        };

        let file = FileId::new(0);
        let symbols = file_symbols(file, &ast);
        assert!(symbols.is_empty());
    }

    #[test]
    fn test_file_symbols_from_real_sysml() {
        let sysml = r#"
            package Vehicle {
                part def Car {
                    attribute mass : Real;
                    part engine : Engine;
                }
                
                part def Engine {
                    attribute power : Real;
                }
            }
        "#;

        let result = crate::syntax::sysml::parser::parse_with_result(
            sysml,
            std::path::Path::new("test.sysml"),
        );
        assert!(result.content.is_some(), "Parse failed");

        let ast = result.content.unwrap();
        let file = FileId::new(1);
        let symbols = file_symbols(file, &ast);

        // Should have: Vehicle (package), Car (part def), Engine (part def),
        // mass (attribute), engine (part), power (attribute)
        assert!(
            symbols.len() >= 4,
            "Expected at least 4 symbols, got {}",
            symbols.len()
        );

        // Find the Vehicle package
        let vehicle = symbols.iter().find(|s| s.name.as_ref() == "Vehicle");
        assert!(vehicle.is_some(), "Vehicle package not found");
        assert_eq!(vehicle.unwrap().kind, SymbolKind::Package);

        // Find the Car definition
        let car = symbols.iter().find(|s| s.name.as_ref() == "Car");
        assert!(car.is_some(), "Car part def not found");
        assert_eq!(car.unwrap().kind, SymbolKind::PartDef);
        assert_eq!(car.unwrap().qualified_name.as_ref(), "Vehicle::Car");

        // Find the Engine definition
        let engine_def = symbols
            .iter()
            .find(|s| s.name.as_ref() == "Engine" && s.kind == SymbolKind::PartDef);
        assert!(engine_def.is_some(), "Engine part def not found");
    }

    #[test]
    fn test_file_symbols_nested_usages() {
        let sysml = r#"
            part def Outer {
                part inner : Inner;
            }
            part def Inner;
        "#;

        let result = crate::syntax::sysml::parser::parse_with_result(
            sysml,
            std::path::Path::new("test.sysml"),
        );
        let ast = result.content.unwrap();
        let symbols = file_symbols(FileId::new(0), &ast);

        // Find 'inner' usage
        let inner_usage = symbols.iter().find(|s| s.name.as_ref() == "inner");
        assert!(inner_usage.is_some(), "inner usage not found");
        assert_eq!(inner_usage.unwrap().kind, SymbolKind::PartUsage);
        assert_eq!(inner_usage.unwrap().qualified_name.as_ref(), "Outer::inner");
    }

    #[test]
    fn test_salsa_tracked_parse_query() {
        // Test that the tracked parse_file query works through the database
        let db = RootDatabase::new();

        let sysml = "part def Car;";
        let file_text = FileText::new(&db, FileId::new(0), sysml.to_string());

        // Call the tracked query
        let result = parse_file(&db, file_text);
        assert!(
            result.is_ok(),
            "Parse failed with errors: {:?}",
            result.errors
        );
        assert!(result.get_ast().is_some());
    }

    #[test]
    fn test_salsa_tracked_symbols_query() {
        // Test that the tracked file_symbols_from_text query works
        let db = RootDatabase::new();

        let sysml = r#"
            package Test {
                part def Widget;
            }
        "#;
        let file_text = FileText::new(&db, FileId::new(0), sysml.to_string());

        // Call the tracked query
        let symbols = file_symbols_from_text(&db, file_text);

        assert!(!symbols.is_empty());
        let widget = symbols.iter().find(|s| s.name.as_ref() == "Widget");
        assert!(widget.is_some(), "Widget not found in symbols");
        assert_eq!(widget.unwrap().kind, SymbolKind::PartDef);
    }

    #[test]
    fn test_salsa_memoization() {
        // Test that queries are memoized (same input returns same result)
        let db = RootDatabase::new();

        let sysml = "part def MemoTest;";
        let file_text = FileText::new(&db, FileId::new(0), sysml.to_string());

        // Call twice - should be memoized
        let symbols1 = file_symbols_from_text(&db, file_text);
        let symbols2 = file_symbols_from_text(&db, file_text);

        // Results should be equal (memoized)
        assert_eq!(symbols1, symbols2);
    }
}