syster-base 0.1.12-alpha

#![allow(clippy::unwrap_used)]

//! Test to verify semantic token text extraction is correct
//! This test creates realistic SysML code, parses it, and verifies
//! that semantic tokens correctly identify the text they're highlighting.

use crate::semantic::Workspace;
use crate::semantic::adapters::syntax_factory::populate_syntax_file;
use crate::semantic::graphs::ReferenceIndex;
use crate::semantic::processors::SemanticTokenCollector;
use crate::semantic::symbol_table::SymbolTable;
use crate::syntax::SyntaxFile;
use crate::syntax::parser::parse_content;
use std::path::PathBuf;

/// Helper to parse SysML content
fn parse_sysml(source: &str) -> SyntaxFile {
    let path = PathBuf::from("test.sysml");
    parse_content(source, &path).expect("Parse should succeed")
}

#[test]
fn test_stdlib_package_with_types() {
    // Test standard library package with type references
    let source = r#"standard library package AnalysisTooling {
    doc
    /*
     * This package contains definitions for metadata annotations related
     * to analysis tool integration.
     */

    private import ScalarValues::*;
    
    metadata def ToolExecution {
        doc
        /*
         * ToolExecution metadata identifies an external analysis tool to be
         * used to implement the annotated action.
         */
    
        attribute toolName : String;
        attribute uri : String;
    }
}"#;

    let syntax_file = parse_sysml(source);

    // Create a workspace to test type reference extraction
    let mut workspace = Workspace::<SyntaxFile>::new();
    let path = PathBuf::from("test.sysml");
    workspace.add_file(path.clone(), syntax_file);
    workspace.populate_file(&path).expect("Failed to populate");

    let tokens = SemanticTokenCollector::collect_from_workspace(&workspace, "test.sysml");
    let lines: Vec<&str> = source.lines().collect();

    // Should have tokens for: package, metadata def, attributes
    // Note: Type references like "String" may not be in the symbol table yet
    assert!(
        !tokens.is_empty(),
        "Expected at least 1 token, got {}",
        tokens.len()
    );

    // Find the AnalysisTooling token
    let pkg_token = tokens.iter().find(|t| t.line == 0);
    assert!(pkg_token.is_some(), "Should have token on line 0");
    let pkg_text: String = lines[0]
        .chars()
        .skip(pkg_token.unwrap().column as usize)
        .take(pkg_token.unwrap().length as usize)
        .collect();

    assert_eq!(
        pkg_text, "AnalysisTooling",
        "Package token should highlight 'AnalysisTooling'"
    );

    // Check if we have metadata def token
    let metadata_def_token = tokens.iter().find(|t| t.line == 10);
    if let Some(tok) = metadata_def_token {
        let text: String = lines[10]
            .chars()
            .skip(tok.column as usize)
            .take(tok.length as usize)
            .collect();
        assert_eq!(text, "ToolExecution", "Should capture metadata def name");
    }
}

#[test]
fn test_kerml_classifiers() {
    // Test KerML classifiers
    let source = r#"package TestPkg {
    classifier MyClassifier;
    class MyClass;
    feature myFeature;
}"#;
    let path = PathBuf::from("test.kerml");
    let syntax_file = parse_content(source, &path).expect("Parse should succeed");

    let mut symbol_table = SymbolTable::new();
    let mut reference_index = ReferenceIndex::new();
    symbol_table.set_current_file(Some("test.kerml".to_string()));

    let result = populate_syntax_file(&syntax_file, &mut symbol_table, &mut reference_index);
    assert!(result.is_ok(), "Symbol population failed: {result:?}");

    let tokens = SemanticTokenCollector::collect_from_symbols(&symbol_table, "test.kerml");
    let lines: Vec<&str> = source.lines().collect();

    // Should have tokens for package and classifiers (features may not be in symbol table yet)
    assert!(
        tokens.len() >= 3,
        "Expected at least 3 tokens, got {}",
        tokens.len()
    );

    // Verify classifier token
    let classifier_token = tokens.iter().find(|t| t.line == 1);
    assert!(
        classifier_token.is_some(),
        "Should have token on line 1 (classifier)"
    );
    let classifier_text: String = lines[1]
        .chars()
        .skip(classifier_token.unwrap().column as usize)
        .take(classifier_token.unwrap().length as usize)
        .collect();
    assert_eq!(
        classifier_text, "MyClassifier",
        "Classifier token should be 'MyClassifier'"
    );

    // Verify class token
    let class_token = tokens.iter().find(|t| t.line == 2);
    assert!(class_token.is_some(), "Should have token on line 2 (class)");
    let class_text: String = lines[2]
        .chars()
        .skip(class_token.unwrap().column as usize)
        .take(class_token.unwrap().length as usize)
        .collect();
    assert_eq!(class_text, "MyClass", "Class token should be 'MyClass'");
}

#[test]
fn test_attribute_definitions_and_usages() {
    // Test specifically for attribute definitions and usages
    let source = r#"package TestPackage {
    part def Vehicle {
        attribute mass: Real;
    }
    
    part myVehicle : Vehicle;
}"#;
    let syntax_file = parse_sysml(source);
    let mut symbol_table = SymbolTable::new();
    let mut reference_index = ReferenceIndex::new();
    symbol_table.set_current_file(Some("test.sysml".to_string()));

    let result = populate_syntax_file(&syntax_file, &mut symbol_table, &mut reference_index);
    assert!(result.is_ok(), "Symbol population failed: {result:?}");

    let tokens = SemanticTokenCollector::collect_from_symbols(&symbol_table, "test.sysml");
    let lines: Vec<&str> = source.lines().collect();

    // We should have tokens for: TestPackage, Vehicle (def), mass (attribute usage), myVehicle (part usage)
    assert!(
        tokens.len() >= 4,
        "Expected at least 4 tokens, got {}",
        tokens.len()
    );

    // Find the attribute token (should be 'mass' on line 2)
    let mass_token = tokens.iter().find(|t| t.line == 2);
    assert!(
        mass_token.is_some(),
        "Should have a token on line 2 (attribute mass)"
    );

    let mass_token = mass_token.unwrap();
    let mass_line = lines[2];
    let mass_text: String = mass_line
        .chars()
        .skip(mass_token.column as usize)
        .take(mass_token.length as usize)
        .collect();
    assert_eq!(mass_text, "mass", "Attribute token should highlight 'mass'");
}

#[test]
fn test_semantic_token_text_extraction() {
    // Real SysML code with various elements
    let source = r#"standard library package QuantityTest {
    abstract attribute def TensorQuantityValue;
    attribute def ScalarQuantityValue;
    part vehicle: Vehicle;
}"#;
    // Parse the file
    let syntax_file = parse_sysml(source);

    // Build symbol table
    let mut symbol_table = SymbolTable::new();
    let mut reference_index = ReferenceIndex::new();
    symbol_table.set_current_file(Some("test.sysml".to_string()));

    let populate_result =
        populate_syntax_file(&syntax_file, &mut symbol_table, &mut reference_index);
    assert!(
        populate_result.is_ok(),
        "Symbol population failed: {populate_result:?}"
    );

    // Collect semantic tokens
    let tokens = SemanticTokenCollector::collect_from_symbols(&symbol_table, "test.sysml");
    let lines: Vec<&str> = source.lines().collect();

    for (i, token) in tokens.iter().enumerate() {
        let line_text = lines.get(token.line as usize).unwrap_or(&"");

        // Extract text using character offsets
        let start_char = token.column as usize;
        let _end_char = start_char + token.length as usize;

        // Convert character offsets to byte offsets for slicing
        let _start_byte: usize = line_text
            .chars()
            .take(start_char)
            .map(|c| c.len_utf8())
            .sum();
        let char_slice: String = line_text
            .chars()
            .skip(start_char)
            .take(token.length as usize)
            .collect();

        // Verify the extracted text matches expectations
        assert!(
            !char_slice.is_empty(),
            "Token {} has empty text extraction at line {} col {}",
            i,
            token.line,
            token.column
        );
    }

    // Specific assertions about the tokens
    assert!(
        tokens.len() >= 3,
        "Should have at least 3 tokens (package, definitions, usage)"
    );

    // Find the package token (should be "QuantityTest")
    let package_token = tokens
        .iter()
        .find(|t| t.line == 0)
        .expect("Should have token on line 0");
    let package_line = lines[0];
    let package_text: String = package_line
        .chars()
        .skip(package_token.column as usize)
        .take(package_token.length as usize)
        .collect();

    // KNOWN ISSUE: The AST span for Package currently covers the entire package declaration,
    // not just the identifier. So for "standard library package QuantityTest",
    // the span is (0,0) to (0,8) which captures "standard" instead of "QuantityTest".
    //
    // This is a parser/AST issue - we need separate spans for:
    // - The entire element (for navigation)
    // - Just the identifier (for semantic tokens)
    //
    // For now, we verify the token extraction mechanism works correctly,
    // even though the spans themselves are pointing to the wrong locations.

    // Temporarily accept that we're highlighting the wrong text until the parser is fixed
    assert!(
        !package_text.is_empty(),
        "Package token should extract some text (even if wrong position)"
    );

    // Check a definition token
    if let Some(def_token) = tokens.iter().find(|t| t.line == 1) {
        let def_line = lines[1];
        let def_text: String = def_line
            .chars()
            .skip(def_token.column as usize)
            .take(def_token.length as usize)
            .collect();

        // KNOWN ISSUE: Similar to packages, definition spans cover the entire declaration
        // rather than just the identifier
        assert!(
            !def_text.is_empty(),
            "Definition token should extract some text"
        );
    }
}

#[test]
fn test_kerml_nested_packages_semantic_tokens() {
    // Test that KerML packages properly recurse into nested elements for type references
    let source = r#"package Outer {
    package Inner {
        classifier Nested;
        feature myFeature : SomeType;
    }
}"#;
    let path = PathBuf::from("test.kerml");
    let syntax_file = parse_content(source, &path).expect("Parse should succeed");

    // Create a workspace to test the full extraction (including AST traversal)
    let mut workspace = Workspace::<SyntaxFile>::new();
    workspace.add_file(path.clone(), syntax_file);
    workspace.populate_file(&path).expect("Failed to populate");

    let tokens = SemanticTokenCollector::collect_from_workspace(&workspace, "test.kerml");

    // We should have tokens for:
    // - Outer package
    // - Inner package
    // - Nested classifier
    // - myFeature
    // - SomeType (type reference) - this is what the fix enables

    // At minimum, we should have tokens for the packages and classifier
    assert!(
        tokens.len() >= 3,
        "Expected at least 3 tokens for KerML nested packages, got {}",
        tokens.len()
    );

    // Verify we're getting tokens from the nested structure
    let has_nested_token = tokens.iter().any(|t| t.line >= 2);
    assert!(
        has_nested_token,
        "Should have tokens from nested elements (line 2+)"
    );
}

/// Test that metadata def with short name and specialization generates semantic tokens
/// This is currently broken - no semantic tokens are generated at all.
#[test]
fn test_metadata_def_with_short_name_and_specialization() {
    let source = r#"metadata def <original> OriginalRequirementMetadata :> SemanticMetadata {
    doc /* Metadata for original requirements. */
}"#;

    let syntax_file = parse_sysml(source);

    let mut workspace = Workspace::<SyntaxFile>::new();
    let path = PathBuf::from("test.sysml");
    workspace.add_file(path.clone(), syntax_file);
    workspace.populate_file(&path).expect("Failed to populate");

    let tokens = SemanticTokenCollector::collect_from_workspace(&workspace, "test.sysml");

    // Debug: print symbols in the symbol table
    println!("Symbols in symbol table:");
    for symbol in workspace.symbol_table().get_symbols_for_file("test.sysml") {
        println!("  {:?}", symbol);
    }

    // Debug: print all tokens
    println!("Tokens found: {:?}", tokens);
    for token in &tokens {
        println!(
            "  line={}, col={}, len={}, type={:?}",
            token.line, token.column, token.length, token.token_type
        );
    }

    // Should have at least a token for OriginalRequirementMetadata
    assert!(
        !tokens.is_empty(),
        "Expected semantic tokens for metadata def, got none"
    );

    // The definition name should have a token
    let has_def_token = tokens
        .iter()
        .any(|t| t.line == 0 && t.column >= 24 && t.column <= 52);
    assert!(
        has_def_token,
        "Expected token for 'OriginalRequirementMetadata' on line 0"
    );
}