leindex 1.6.0

// C# language parser implementation

use crate::parse::traits::{Block, Edge, EdgeType, Parameter, Visibility};
use crate::parse::traits::{
    CodeIntelligence, ComplexityMetrics, Error, Graph, ImportInfo, Result, SignatureInfo,
};
use tree_sitter::Parser;

/// C# language parser with full CodeIntelligence implementation
pub struct CSharpParser;

impl Default for CSharpParser {
    fn default() -> Self {
        Self::new()
    }
}

impl CSharpParser {
    /// Create a new C# parser
    pub fn new() -> Self {
        Self
    }

    /// Extract all function and type definitions from C# source
    fn extract_all_definitions(
        &self,
        source: &[u8],
        root: tree_sitter::Node<'_>,
    ) -> Vec<SignatureInfo> {
        let mut signatures = Vec::new();

        fn visit_node(
            node: &tree_sitter::Node<'_>,
            source: &[u8],
            signatures: &mut Vec<SignatureInfo>,
            parent_path: &[String],
        ) {
            match node.kind() {
                "method_declaration" | "local_function_statement" => {
                    if let Some(sig) = extract_method_signature(node, source, parent_path) {
                        signatures.push(sig);
                    }
                    // Don't recurse into method bodies
                }
                "class_declaration" => {
                    if let Some(name) = node
                        .child_by_field_name("name")
                        .and_then(|n| n.utf8_text(source).ok())
                    {
                        let qualified_name = if parent_path.is_empty() {
                            name.to_string()
                        } else {
                            format!("{}.{}", parent_path.join("."), name)
                        };

                        signatures.push(SignatureInfo {
                            name: name.to_string(),
                            qualified_name,
                            parameters: vec![],
                            return_type: Some("class".to_string()),
                            visibility: extract_visibility(node, source),
                            is_async: false,
                            is_method: false,
                            docstring: None,
                            calls: vec![],
                            imports: vec![],
                            byte_range: (0, 0),
                            cyclomatic_complexity: 0,
                        });
                    }

                    let mut cursor = node.walk();
                    for child in node.children(&mut cursor) {
                        visit_node(&child, source, signatures, parent_path);
                    }
                }
                "interface_declaration" => {
                    if let Some(name) = node
                        .child_by_field_name("name")
                        .and_then(|n| n.utf8_text(source).ok())
                    {
                        let qualified_name = if parent_path.is_empty() {
                            name.to_string()
                        } else {
                            format!("{}.{}", parent_path.join("."), name)
                        };

                        signatures.push(SignatureInfo {
                            name: name.to_string(),
                            qualified_name,
                            parameters: vec![],
                            return_type: Some("interface".to_string()),
                            visibility: extract_visibility(node, source),
                            is_async: false,
                            is_method: false,
                            docstring: None,
                            calls: vec![],
                            imports: vec![],
                            byte_range: (0, 0),
                            cyclomatic_complexity: 0,
                        });
                    }
                }
                "struct_declaration" => {
                    if let Some(name) = node
                        .child_by_field_name("name")
                        .and_then(|n| n.utf8_text(source).ok())
                    {
                        let qualified_name = if parent_path.is_empty() {
                            name.to_string()
                        } else {
                            format!("{}.{}", parent_path.join("."), name)
                        };

                        signatures.push(SignatureInfo {
                            name: name.to_string(),
                            qualified_name,
                            parameters: vec![],
                            return_type: Some("struct".to_string()),
                            visibility: extract_visibility(node, source),
                            is_async: false,
                            is_method: false,
                            docstring: None,
                            calls: vec![],
                            imports: vec![],
                            byte_range: (0, 0),
                            cyclomatic_complexity: 0,
                        });
                    }
                }
                "enum_declaration" => {
                    if let Some(name) = node
                        .child_by_field_name("name")
                        .and_then(|n| n.utf8_text(source).ok())
                    {
                        let qualified_name = if parent_path.is_empty() {
                            name.to_string()
                        } else {
                            format!("{}.{}", parent_path.join("."), name)
                        };

                        signatures.push(SignatureInfo {
                            name: name.to_string(),
                            qualified_name,
                            parameters: vec![],
                            return_type: Some("enum".to_string()),
                            visibility: extract_visibility(node, source),
                            is_async: false,
                            is_method: false,
                            docstring: None,
                            calls: vec![],
                            imports: vec![],
                            byte_range: (0, 0),
                            cyclomatic_complexity: 0,
                        });
                    }
                }
                _ => {
                    let mut cursor = node.walk();
                    for child in node.children(&mut cursor) {
                        visit_node(&child, source, signatures, parent_path);
                    }
                }
            }
        }

        visit_node(&root, source, &mut signatures, &[]);
        signatures
    }
}

impl CodeIntelligence for CSharpParser {
    fn get_signatures(&self, source: &[u8]) -> Result<Vec<SignatureInfo>> {
        let mut parser = Parser::new();
        self.get_signatures_with_parser(source, &mut parser)
    }

    fn get_signatures_with_parser(
        &self,
        source: &[u8],
        parser: &mut tree_sitter::Parser,
    ) -> Result<Vec<SignatureInfo>> {
        parser
            .set_language(&crate::parse::traits::languages::csharp::language())
            .map_err(|e| Error::ParseFailed(e.to_string()))?;

        let tree = parser
            .parse(source, None)
            .ok_or_else(|| Error::ParseFailed("Failed to parse C# source".to_string()))?;

        let root_node = tree.root_node();
        let imports = extract_csharp_imports(root_node, source);
        let mut signatures = self.extract_all_definitions(source, root_node);

        for sig in &mut signatures {
            sig.imports = imports.clone();
        }

        Ok(signatures)
    }

    fn compute_cfg(&self, source: &[u8], node_id: usize) -> Result<Graph<Block, Edge>> {
        let mut parser = Parser::new();
        parser
            .set_language(&crate::parse::traits::languages::csharp::language())
            .map_err(|e| Error::ParseFailed(e.to_string()))?;

        let tree = parser
            .parse(source, None)
            .ok_or_else(|| Error::ParseFailed("Failed to parse C# source".to_string()))?;

        let root_node = tree.root_node();
        let node = find_node_by_id(&root_node, node_id)
            .ok_or_else(|| Error::ParseFailed(format!("Node {} not found", node_id)))?;

        let mut cfg_builder = CfgBuilder::new(source);
        cfg_builder.build_from_node(&node)?;

        Ok(cfg_builder.finish())
    }

    fn extract_complexity(&self, node: &tree_sitter::Node<'_>) -> ComplexityMetrics {
        let mut complexity = ComplexityMetrics {
            cyclomatic: 1,
            nesting_depth: 0,
            line_count: 0,
            token_count: 0,
        };

        calculate_complexity(node, &mut complexity, 0);
        complexity
    }
}

fn extract_csharp_imports(root: tree_sitter::Node<'_>, source: &[u8]) -> Vec<ImportInfo> {
    let mut imports = Vec::new();

    fn add_import(imports: &mut Vec<ImportInfo>, path: &str, alias: Option<String>) {
        let path = path.trim().trim_end_matches(';').trim();
        if path.is_empty() {
            return;
        }
        imports.push(ImportInfo {
            path: path.to_string(),
            alias,
        });
    }

    fn visit(node: &tree_sitter::Node<'_>, source: &[u8], imports: &mut Vec<ImportInfo>) {
        if node.kind() == "using_directive" {
            if let Ok(text) = node.utf8_text(source) {
                let text = text.trim().trim_end_matches(';').trim();
                let text = text.trim_start_matches("using ");
                if let Some((alias, path)) = text.split_once('=') {
                    add_import(imports, path.trim(), Some(alias.trim().to_string()));
                } else {
                    let alias = text.split('.').next_back().map(|s| s.to_string());
                    add_import(imports, text, alias);
                }
            }
        }

        let mut cursor = node.walk();
        for child in node.children(&mut cursor) {
            visit(&child, source, imports);
        }
    }

    visit(&root, source, &mut imports);
    imports
}

fn extract_method_signature(
    node: &tree_sitter::Node<'_>,
    source: &[u8],
    parent_path: &[String],
) -> Option<SignatureInfo> {
    // Try to get name from "name" field first (for method_declaration)
    // If not found, look for an identifier child (for local_function_statement)
    let name = node
        .child_by_field_name("name")
        .and_then(|n| n.utf8_text(source).ok())
        .map(|s| s.to_string())
        .or_else(|| {
            // For local_function_statement, find the identifier child
            let mut cursor = node.walk();
            for child in node.children(&mut cursor) {
                if child.kind() == "identifier" {
                    return child.utf8_text(source).ok().map(|s| s.to_string());
                }
            }
            None
        })?;

    let qualified_name = if parent_path.is_empty() {
        name.clone()
    } else {
        format!("{}.{}", parent_path.join("."), name)
    };

    let parameters = extract_csharp_parameters(node, source);

    // For return type, try "type" field or look for generic_name
    let return_type = node
        .child_by_field_name("type")
        .and_then(|t| t.utf8_text(source).ok())
        .map(|s| s.trim().to_string())
        .or_else(|| {
            // For local_function_statement, look for generic_name child
            let mut cursor = node.walk();
            for child in node.children(&mut cursor) {
                if child.kind() == "generic_name"
                    || child.kind() == "predefined_type"
                    || child.kind() == "identifier"
                {
                    return child.utf8_text(source).ok().map(|s| s.trim().to_string());
                }
            }
            None
        });

    let is_async = {
        let mut cursor = node.walk();
        let mut found = false;
        for child in node.children(&mut cursor) {
            if child.kind() == "modifier" {
                if let Ok(text) = child.utf8_text(source) {
                    if text.trim() == "async" {
                        found = true;
                        break;
                    }
                }
            }
        }
        found
    };

    let calls = extract_csharp_calls(node, source);

    Some(SignatureInfo {
        name,
        qualified_name,
        parameters,
        return_type,
        visibility: extract_visibility(node, source),
        is_async,
        is_method: true,
        docstring: None,
        calls,

        imports: vec![],
        byte_range: (0, 0),
        cyclomatic_complexity: 0,
    })
}

#[allow(clippy::manual_find)]
fn extract_csharp_calls(node: &tree_sitter::Node<'_>, source: &[u8]) -> Vec<String> {
    let mut calls = Vec::new();

    fn clean_call_text(raw: &str) -> String {
        raw.split('(').next().unwrap_or(raw).trim().to_string()
    }

    fn find_calls(node: &tree_sitter::Node<'_>, source: &[u8], calls: &mut Vec<String>) {
        match node.kind() {
            "invocation_expression" => {
                if let Some(expr) = node.child_by_field_name("expression") {
                    if let Ok(text) = expr.utf8_text(source) {
                        let name = clean_call_text(text);
                        if !name.is_empty() {
                            calls.push(name);
                        }
                    }
                }
            }
            "object_creation_expression" => {
                if let Some(typ) = node.child_by_field_name("type") {
                    if let Ok(text) = typ.utf8_text(source) {
                        let name = clean_call_text(text);
                        if !name.is_empty() {
                            calls.push(name);
                        }
                    }
                }
            }
            _ => {}
        }

        let mut cursor = node.walk();
        for child in node.children(&mut cursor) {
            find_calls(&child, source, calls);
        }
    }

    find_calls(node, source, &mut calls);
    calls
}

fn extract_csharp_parameters(node: &tree_sitter::Node<'_>, source: &[u8]) -> Vec<Parameter> {
    let mut parameters = Vec::new();

    // Try "parameters" field first, then look for parameter_list child
    let params_node = node.child_by_field_name("parameters").or_else(|| {
        let mut cursor = node.walk();
        let result = node.children(&mut cursor).find(|child| child.kind() == "parameter_list");
        result
    });

    if let Some(params) = params_node {
        let mut cursor = params.walk();
        for child in params.children(&mut cursor) {
            if child.kind() == "parameter" {
                let name = child
                    .child_by_field_name("name")
                    .and_then(|n| n.utf8_text(source).ok())
                    .map(|s| s.to_string());

                let type_annotation = child
                    .child_by_field_name("type")
                    .and_then(|t| t.utf8_text(source).ok())
                    .map(|s| s.trim().to_string());

                if let Some(name_text) = name {
                    parameters.push(Parameter {
                        name: name_text,
                        type_annotation,
                        default_value: None,
                    });
                }
            }
        }
    }

    parameters
}

fn extract_visibility(node: &tree_sitter::Node<'_>, source: &[u8]) -> Visibility {
    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        if child.kind() == "modifiers" {
            let mut mcursor = child.walk();
            for modifier in child.children(&mut mcursor) {
                if let Ok(text) = modifier.utf8_text(source) {
                    match text.trim() {
                        "public" => return Visibility::Public,
                        "protected" => return Visibility::Protected,
                        "private" => return Visibility::Private,
                        "internal" => return Visibility::Protected,
                        _ => {}
                    }
                }
            }
        }
    }
    Visibility::Private
}

#[allow(dead_code)]
fn extract_docstring(node: &tree_sitter::Node<'_>, source: &[u8]) -> Option<String> {
    // C# uses XML documentation comments: /// <summary>...</summary>
    // Look for the previous sibling that might be a comment

    // We need to search backwards from the current node
    // This is tricky in tree-sitter, so we'll search the tree for comments
    // that appear before this node's byte range
    let node_start = node.byte_range().start;

    // Walk up to find the root, then search for comments
    let mut current = *node;
    let root = loop {
        let parent = current.parent();
        match parent {
            Some(p) => current = p,
            None => break current,
        }
    };

    // Collect all comments in the tree that appear before our node
    let mut comments_before = Vec::new();
    let mut cursor = root.walk();
    collect_comments_recursive(&root, &mut cursor, source, node_start, &mut comments_before);

    // Get the closest comment before this node
    comments_before
        .into_iter()
        .rev()
        .find(|comment_start| {
            // Check if the comment is "close" to the node (within ~500 bytes)
            node_start.saturating_sub(*comment_start) <= 500
        })
        .map(|_| {
            // For now, return a placeholder since XML doc comment parsing is complex
            // A full implementation would parse the <summary>, <param>, <returns> tags
            "C# XML documentation comment".to_string()
        })
}

#[allow(dead_code)]
#[allow(clippy::only_used_in_recursion)]
fn collect_comments_recursive(
    node: &tree_sitter::Node<'_>,
    cursor: &mut tree_sitter::TreeCursor<'_>,
    source: &[u8],
    target_byte: usize,
    comments_before: &mut Vec<usize>,
) {
    // Check if this node is a comment before our target
    if node.kind() == "comment" {
        let byte_range = node.byte_range();
        if byte_range.end <= target_byte {
            if let Ok(_comment) = node.utf8_text(source) {
                comments_before.push(byte_range.start);
            }
        }
    }

    // Recurse into children
    let mut c = node.walk();
    for child in node.children(&mut c) {
        collect_comments_recursive(&child, cursor, source, target_byte, comments_before);
    }
}

/// Find a node by its ID
fn find_node_by_id<'a>(
    node: &'a tree_sitter::Node<'a>,
    id: usize,
) -> Option<tree_sitter::Node<'a>> {
    use std::collections::VecDeque;

    if node.id() == id {
        return Some(*node);
    }

    let mut queue: VecDeque<tree_sitter::Node<'a>> = VecDeque::new();
    let mut cursor = node.walk();

    for child in node.children(&mut cursor) {
        queue.push_back(child);
    }

    while let Some(current) = queue.pop_front() {
        if current.id() == id {
            return Some(current);
        }

        let mut child_cursor = current.walk();
        for child in current.children(&mut child_cursor) {
            queue.push_back(child);
        }
    }

    None
}

fn calculate_complexity(
    node: &tree_sitter::Node<'_>,
    metrics: &mut ComplexityMetrics,
    depth: usize,
) {
    metrics.nesting_depth = metrics.nesting_depth.max(depth);
    metrics.line_count = std::cmp::max(metrics.line_count, 1);
    match node.kind() {
        "if_statement" | "for_statement" | "foreach_statement" | "while_statement"
        | "switch_statement" => {
            metrics.cyclomatic += 1;
        }
        _ => {}
    }
    metrics.token_count += node.child_count();
    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        calculate_complexity(&child, metrics, depth + 1);
    }
}

struct CfgBuilder<'a> {
    source: &'a [u8],
    blocks: Vec<Block>,
    edges: Vec<Edge>,
    next_block_id: usize,
}

impl<'a> CfgBuilder<'a> {
    fn new(source: &'a [u8]) -> Self {
        Self {
            source,
            blocks: Vec::new(),
            edges: Vec::new(),
            next_block_id: 0,
        }
    }

    fn build_from_node(&mut self, node: &tree_sitter::Node<'_>) -> Result<()> {
        let entry_id = self.create_block();
        self.build_cfg_recursive(node, entry_id)?;
        Ok(())
    }

    fn build_cfg_recursive(
        &mut self,
        node: &tree_sitter::Node<'_>,
        current_block: usize,
    ) -> Result<()> {
        match node.kind() {
            "if_statement" => {
                self.handle_if_statement(node, current_block)?;
            }
            "for_statement" | "foreach_statement" | "while_statement" => {
                self.handle_loop_statement(node, current_block)?;
            }
            _ => {
                if let Ok(text) = node.utf8_text(self.source) {
                    self.add_statement_to_block(current_block, text.to_string());
                }
                let mut cursor = node.walk();
                for child in node.children(&mut cursor) {
                    self.build_cfg_recursive(&child, current_block)?;
                }
            }
        }
        Ok(())
    }

    fn handle_if_statement(
        &mut self,
        _node: &tree_sitter::Node<'_>,
        current_block: usize,
    ) -> Result<()> {
        let true_block = self.create_block();
        let false_block = self.create_block();
        let merge_block = self.create_block();
        self.edges.push(Edge {
            from: current_block,
            to: true_block,
            edge_type: EdgeType::TrueBranch,
        });
        self.edges.push(Edge {
            from: current_block,
            to: false_block,
            edge_type: EdgeType::FalseBranch,
        });
        self.edges.push(Edge {
            from: true_block,
            to: merge_block,
            edge_type: EdgeType::Unconditional,
        });
        self.edges.push(Edge {
            from: false_block,
            to: merge_block,
            edge_type: EdgeType::Unconditional,
        });
        Ok(())
    }

    fn handle_loop_statement(
        &mut self,
        _node: &tree_sitter::Node<'_>,
        current_block: usize,
    ) -> Result<()> {
        let body_block = self.create_block();
        self.edges.push(Edge {
            from: current_block,
            to: body_block,
            edge_type: EdgeType::Unconditional,
        });
        self.edges.push(Edge {
            from: body_block,
            to: current_block,
            edge_type: EdgeType::Loop,
        });
        Ok(())
    }

    fn create_block(&mut self) -> usize {
        let id = self.next_block_id;
        self.next_block_id += 1;
        self.blocks.push(Block {
            id,
            statements: Vec::new(),
        });
        id
    }

    fn add_statement_to_block(&mut self, block_id: usize, statement: String) {
        if let Some(block) = self.blocks.get_mut(block_id) {
            block.statements.push(statement);
        }
    }

    fn finish(self) -> Graph<Block, Edge> {
        Graph {
            blocks: self.blocks,
            edges: self.edges,
            entry_block: 0,
            exit_blocks: vec![self.next_block_id.saturating_sub(1)],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_csharp_method_extraction() {
        let source = b"public class Test {
    public void Greet(string name) {
        Console.WriteLine(\"Hello, \" + name);
    }
}";

        let parser = CSharpParser::new();
        let signatures = parser.get_signatures(source).unwrap();

        // Should find the class and method
        assert!(signatures.len() >= 2);

        let class = signatures.iter().find(|s| s.name == "Test");
        assert!(class.is_some());

        let method = signatures.iter().find(|s| s.name == "Greet");
        assert!(method.is_some());
    }

    #[test]
    fn test_csharp_async_method() {
        let source = b"public async Task<string> FetchData() {
    return await Task.FromResult(\"data\");
}";

        let parser = CSharpParser::new();
        let signatures = parser.get_signatures(source).unwrap();

        let method = signatures.iter().find(|s| s.name == "FetchData");
        assert!(method.is_some());
        assert!(method.unwrap().is_async);
    }

    #[test]
    fn test_csharp_complexity_calculation() {
        let source = b"public void Complex(int x) {
    if (x > 0) {
        for (int i = 0; i < x; i++) {
            if (i % 2 == 0) {
                Console.WriteLine(i);
            }
        }
    }
}";

        let mut parser = Parser::new();
        parser
            .set_language(&tree_sitter_c_sharp::LANGUAGE.into())
            .unwrap();
        let tree = parser.parse(source, None).unwrap();
        let root = tree.root_node();

        let csharp_parser = CSharpParser::new();
        let metrics = csharp_parser.extract_complexity(&root);

        assert!(metrics.cyclomatic > 1);
        assert!(metrics.nesting_depth > 0);
    }
}