cqs/

impact.rs

//! Impact analysis core
//!
//! Provides BFS caller traversal, test discovery, snippet extraction,
//! transitive caller analysis, and mermaid diagram generation.

use std::collections::{HashMap, HashSet, VecDeque};
use std::path::{Path, PathBuf};

use crate::store::{CallGraph, CallerWithContext};
use crate::Store;

/// Direct caller with display-ready fields
pub struct CallerInfo {
    pub name: String,
    pub file: PathBuf,
    pub line: u32,
    pub call_line: u32,
    pub snippet: Option<String>,
}

/// Affected test with call depth
pub struct TestInfo {
    pub name: String,
    pub file: PathBuf,
    pub line: u32,
    pub call_depth: usize,
}

/// Transitive caller at a given depth
pub struct TransitiveCaller {
    pub name: String,
    pub file: PathBuf,
    pub line: u32,
    pub depth: usize,
}

/// Complete impact analysis result
pub struct ImpactResult {
    pub function_name: String,
    pub callers: Vec<CallerInfo>,
    pub tests: Vec<TestInfo>,
    pub transitive_callers: Vec<TransitiveCaller>,
}

/// Maximum depth for test search BFS
const MAX_TEST_SEARCH_DEPTH: usize = 5;

/// Run impact analysis: find callers, affected tests, and transitive callers.
pub fn analyze_impact(
    store: &Store,
    target_name: &str,
    depth: usize,
) -> anyhow::Result<ImpactResult> {
    let callers = build_caller_info(store, target_name)?;
    let graph = store.get_call_graph()?;
    let tests = find_affected_tests(store, &graph, target_name)?;
    let transitive_callers = if depth > 1 {
        find_transitive_callers(store, &graph, target_name, depth)?
    } else {
        Vec::new()
    };

    Ok(ImpactResult {
        function_name: target_name.to_string(),
        callers,
        tests,
        transitive_callers,
    })
}

/// Lightweight caller + test coverage hints for a function.
pub struct FunctionHints {
    pub caller_count: usize,
    pub test_count: usize,
}

/// Core implementation — accepts pre-loaded graph and test chunks.
///
/// Use this when processing multiple functions to avoid loading the graph
/// N times (e.g., scout, which processes 10+ functions).
pub fn compute_hints_with_graph(
    graph: &CallGraph,
    test_chunks: &[crate::store::ChunkSummary],
    function_name: &str,
    prefetched_caller_count: Option<usize>,
) -> FunctionHints {
    let caller_count = match prefetched_caller_count {
        Some(n) => n,
        None => graph
            .reverse
            .get(function_name)
            .map(|v| v.len())
            .unwrap_or(0),
    };
    let ancestors = reverse_bfs(graph, function_name, MAX_TEST_SEARCH_DEPTH);
    let test_count = test_chunks
        .iter()
        .filter(|t| ancestors.get(&t.name).is_some_and(|&d| d > 0))
        .count();

    FunctionHints {
        caller_count,
        test_count,
    }
}

/// Compute caller count and test count for a single function.
///
/// Convenience wrapper that loads graph internally. Pass `prefetched_caller_count`
/// to avoid re-querying callers when the caller already has them (e.g., `explain`
/// fetches callers before this).
pub fn compute_hints(
    store: &Store,
    function_name: &str,
    prefetched_caller_count: Option<usize>,
) -> anyhow::Result<FunctionHints> {
    let caller_count = match prefetched_caller_count {
        Some(n) => n,
        None => store.get_callers_full(function_name)?.len(),
    };
    let graph = store.get_call_graph()?;
    let test_chunks = store.find_test_chunks()?;
    Ok(compute_hints_with_graph(
        &graph,
        &test_chunks,
        function_name,
        Some(caller_count),
    ))
}

/// Build caller info with call-site snippets
fn build_caller_info(store: &Store, target_name: &str) -> anyhow::Result<Vec<CallerInfo>> {
    let callers_ctx = store.get_callers_with_context(target_name)?;
    let mut callers = Vec::with_capacity(callers_ctx.len());

    for caller in &callers_ctx {
        let snippet = extract_call_snippet(store, caller);
        callers.push(CallerInfo {
            name: caller.name.clone(),
            file: caller.file.clone(),
            line: caller.line,
            call_line: caller.call_line,
            snippet,
        });
    }

    Ok(callers)
}

/// Extract a snippet around the call site from the caller's indexed content
fn extract_call_snippet(store: &Store, caller: &CallerWithContext) -> Option<String> {
    let result = match store.search_by_name(&caller.name, 1) {
        Ok(results) => results.into_iter().next(),
        Err(e) => {
            tracing::warn!(caller = %caller.name, error = %e, "Failed to fetch call snippet");
            return None;
        }
    };
    result.and_then(|r| {
        let lines: Vec<&str> = r.chunk.content.lines().collect();
        let offset = caller.call_line.saturating_sub(r.chunk.line_start) as usize;
        if offset < lines.len() {
            let start = offset.saturating_sub(1);
            let end = (offset + 2).min(lines.len());
            Some(lines[start..end].join("\n"))
        } else {
            None
        }
    })
}

/// Find tests that transitively call the target via reverse BFS
fn find_affected_tests(
    store: &Store,
    graph: &CallGraph,
    target_name: &str,
) -> anyhow::Result<Vec<TestInfo>> {
    let test_chunks = store.find_test_chunks()?;
    let ancestors = reverse_bfs(graph, target_name, MAX_TEST_SEARCH_DEPTH);

    let mut tests: Vec<TestInfo> = test_chunks
        .iter()
        .filter_map(|test| {
            ancestors.get(&test.name).and_then(|&d| {
                if d > 0 {
                    Some(TestInfo {
                        name: test.name.clone(),
                        file: test.file.clone(),
                        line: test.line_start,
                        call_depth: d,
                    })
                } else {
                    None
                }
            })
        })
        .collect();

    tests.sort_by_key(|t| t.call_depth);
    Ok(tests)
}

/// Find transitive callers up to the given depth
fn find_transitive_callers(
    store: &Store,
    graph: &CallGraph,
    target_name: &str,
    depth: usize,
) -> anyhow::Result<Vec<TransitiveCaller>> {
    let mut result = Vec::new();
    let mut visited: HashSet<String> = HashSet::new();
    visited.insert(target_name.to_string());
    let mut queue: VecDeque<(String, usize)> = VecDeque::new();
    queue.push_back((target_name.to_string(), 0));

    while let Some((current, d)) = queue.pop_front() {
        if d >= depth {
            continue;
        }
        if let Some(callers) = graph.reverse.get(&current) {
            for caller_name in callers {
                if visited.insert(caller_name.clone()) {
                    match store.search_by_name(caller_name, 1) {
                        Ok(results) => {
                            if let Some(r) = results.into_iter().next() {
                                result.push(TransitiveCaller {
                                    name: caller_name.clone(),
                                    file: r.chunk.file,
                                    line: r.chunk.line_start,
                                    depth: d + 1,
                                });
                            }
                        }
                        Err(e) => {
                            tracing::warn!(caller = %caller_name, error = %e, "Failed to look up transitive caller");
                        }
                    }
                    queue.push_back((caller_name.clone(), d + 1));
                }
            }
        }
    }

    Ok(result)
}

/// Reverse BFS from a target node, returning all ancestors with their depths
pub(crate) fn reverse_bfs(
    graph: &CallGraph,
    target: &str,
    max_depth: usize,
) -> HashMap<String, usize> {
    let mut ancestors: HashMap<String, usize> = HashMap::new();
    let mut queue: VecDeque<(String, usize)> = VecDeque::new();
    ancestors.insert(target.to_string(), 0);
    queue.push_back((target.to_string(), 0));

    while let Some((current, d)) = queue.pop_front() {
        if d >= max_depth {
            continue;
        }
        if let Some(callers) = graph.reverse.get(&current) {
            for caller in callers {
                if !ancestors.contains_key(caller) {
                    ancestors.insert(caller.clone(), d + 1);
                    queue.push_back((caller.clone(), d + 1));
                }
            }
        }
    }

    ancestors
}

// ============ JSON Serialization ============

/// Serialize impact result to JSON, relativizing paths against the project root
pub fn impact_to_json(result: &ImpactResult, root: &Path) -> serde_json::Value {
    let callers_json: Vec<_> = result
        .callers
        .iter()
        .map(|c| {
            let rel = rel_path(&c.file, root);
            serde_json::json!({
                "name": c.name,
                "file": rel,
                "line": c.line,
                "call_line": c.call_line,
                "snippet": c.snippet,
            })
        })
        .collect();

    let tests_json: Vec<_> = result
        .tests
        .iter()
        .map(|t| {
            let rel = rel_path(&t.file, root);
            serde_json::json!({
                "name": t.name,
                "file": rel,
                "line": t.line,
                "call_depth": t.call_depth,
            })
        })
        .collect();

    let mut output = serde_json::json!({
        "function": result.function_name,
        "callers": callers_json,
        "tests": tests_json,
        "caller_count": callers_json.len(),
        "test_count": tests_json.len(),
    });

    if !result.transitive_callers.is_empty() {
        let trans_json: Vec<_> = result
            .transitive_callers
            .iter()
            .map(|c| {
                let rel = rel_path(&c.file, root);
                serde_json::json!({
                    "name": c.name,
                    "file": rel,
                    "line": c.line,
                    "depth": c.depth,
                })
            })
            .collect();
        if let Some(obj) = output.as_object_mut() {
            obj.insert("transitive_callers".into(), serde_json::json!(trans_json));
        }
    }

    output
}

// ============ Mermaid Diagram ============

/// Generate a mermaid diagram from impact result
pub fn impact_to_mermaid(result: &ImpactResult, root: &Path) -> String {
    let mut lines = vec!["graph TD".to_string()];
    lines.push(format!(
        "    A[\"{}\"]\n    style A fill:#f96",
        mermaid_escape(&result.function_name)
    ));

    let mut idx = 1;
    for c in &result.callers {
        let rel = rel_path(&c.file, root);
        let letter = node_letter(idx);
        lines.push(format!(
            "    {}[\"{} ({}:{})\"]",
            letter,
            mermaid_escape(&c.name),
            mermaid_escape(&rel),
            c.line
        ));
        lines.push(format!("    {} --> A", letter));
        idx += 1;
    }

    for t in &result.tests {
        let rel = rel_path(&t.file, root);
        let letter = node_letter(idx);
        lines.push(format!(
            "    {}{{\"{}\\n{}\\ndepth: {}\"}}",
            letter,
            mermaid_escape(&t.name),
            mermaid_escape(&rel),
            t.call_depth
        ));
        lines.push(format!("    {} -.-> A", letter));
        idx += 1;
    }

    lines.join("\n")
}

// ============ Diff-Aware Impact ============

/// A function identified as changed by a diff
pub struct ChangedFunction {
    pub name: String,
    pub file: String,
    pub line_start: u32,
}

/// A test affected by diff changes, tracking which changed function leads to it
pub struct DiffTestInfo {
    pub name: String,
    pub file: PathBuf,
    pub line: u32,
    pub via: String,
    pub call_depth: usize,
}

/// Summary counts for diff impact
pub struct DiffImpactSummary {
    pub changed_count: usize,
    pub caller_count: usize,
    pub test_count: usize,
}

/// Aggregated impact result from a diff
pub struct DiffImpactResult {
    pub changed_functions: Vec<ChangedFunction>,
    pub all_callers: Vec<CallerInfo>,
    pub all_tests: Vec<DiffTestInfo>,
    pub summary: DiffImpactSummary,
}

/// Map diff hunks to function names using the index.
///
/// For each hunk, finds chunks whose line range overlaps the hunk's range.
/// Returns deduplicated function names.
pub fn map_hunks_to_functions(
    store: &Store,
    hunks: &[crate::diff_parse::DiffHunk],
) -> Vec<ChangedFunction> {
    let mut seen = HashSet::new();
    let mut functions = Vec::new();

    // Group hunks by file
    let mut by_file: HashMap<&str, Vec<&crate::diff_parse::DiffHunk>> = HashMap::new();
    for hunk in hunks {
        by_file.entry(&hunk.file).or_default().push(hunk);
    }

    for (file, file_hunks) in &by_file {
        let chunks = match store.get_chunks_by_origin(file) {
            Ok(c) => c,
            Err(_) => continue,
        };
        for hunk in file_hunks {
            let hunk_end = hunk.start + hunk.count; // exclusive
            for chunk in &chunks {
                // Overlap: hunk [start, start+count) vs chunk [line_start, line_end]
                if hunk.start <= chunk.line_end
                    && hunk_end > chunk.line_start
                    && seen.insert(chunk.name.clone())
                {
                    functions.push(ChangedFunction {
                        name: chunk.name.clone(),
                        file: file.to_string(),
                        line_start: chunk.line_start,
                    });
                }
            }
        }
    }

    functions
}

/// Run impact analysis across all changed functions from a diff.
///
/// Fetches call graph and test chunks once, then analyzes each function.
/// Results are deduplicated by name.
pub fn analyze_diff_impact(
    store: &Store,
    changed: &[ChangedFunction],
) -> anyhow::Result<DiffImpactResult> {
    if changed.is_empty() {
        return Ok(DiffImpactResult {
            changed_functions: Vec::new(),
            all_callers: Vec::new(),
            all_tests: Vec::new(),
            summary: DiffImpactSummary {
                changed_count: 0,
                caller_count: 0,
                test_count: 0,
            },
        });
    }

    let graph = store.get_call_graph()?;
    let test_chunks = store.find_test_chunks()?;

    let mut all_callers = Vec::new();
    let mut all_tests = Vec::new();
    let mut seen_callers = HashSet::new();
    let mut seen_tests = HashSet::new();

    for func in changed {
        // Direct callers
        if let Ok(callers_ctx) = store.get_callers_with_context(&func.name) {
            for caller in &callers_ctx {
                if seen_callers.insert(caller.name.clone()) {
                    let snippet = extract_call_snippet(store, caller);
                    all_callers.push(CallerInfo {
                        name: caller.name.clone(),
                        file: caller.file.clone(),
                        line: caller.line,
                        call_line: caller.call_line,
                        snippet,
                    });
                }
            }
        }

        // Affected tests via reverse BFS
        let ancestors = reverse_bfs(&graph, &func.name, MAX_TEST_SEARCH_DEPTH);
        for test in &test_chunks {
            if let Some(&depth) = ancestors.get(&test.name) {
                if depth > 0 && seen_tests.insert(test.name.clone()) {
                    all_tests.push(DiffTestInfo {
                        name: test.name.clone(),
                        file: test.file.clone(),
                        line: test.line_start,
                        via: func.name.clone(),
                        call_depth: depth,
                    });
                }
            }
        }
    }

    all_tests.sort_by_key(|t| t.call_depth);

    let summary = DiffImpactSummary {
        changed_count: changed.len(),
        caller_count: all_callers.len(),
        test_count: all_tests.len(),
    };

    Ok(DiffImpactResult {
        changed_functions: Vec::new(), // filled by caller
        all_callers,
        all_tests,
        summary,
    })
}

/// Serialize diff impact result to JSON
pub fn diff_impact_to_json(result: &DiffImpactResult, root: &Path) -> serde_json::Value {
    let changed_json: Vec<_> = result
        .changed_functions
        .iter()
        .map(|f| {
            serde_json::json!({
                "name": f.name,
                "file": f.file,
                "line_start": f.line_start,
            })
        })
        .collect();

    let callers_json: Vec<_> = result
        .all_callers
        .iter()
        .map(|c| {
            let rel = rel_path(&c.file, root);
            serde_json::json!({
                "name": c.name,
                "file": rel,
                "line": c.line,
                "call_line": c.call_line,
            })
        })
        .collect();

    let tests_json: Vec<_> = result
        .all_tests
        .iter()
        .map(|t| {
            let rel = rel_path(&t.file, root);
            serde_json::json!({
                "name": t.name,
                "file": rel,
                "line": t.line,
                "via": t.via,
                "call_depth": t.call_depth,
            })
        })
        .collect();

    serde_json::json!({
        "changed_functions": changed_json,
        "callers": callers_json,
        "tests": tests_json,
        "summary": {
            "changed_count": result.summary.changed_count,
            "caller_count": result.summary.caller_count,
            "test_count": result.summary.test_count,
        }
    })
}

// ============ Test Suggestions ============

/// A suggested test for an untested caller
pub struct TestSuggestion {
    /// Suggested test function name
    pub test_name: String,
    /// Suggested file for the test
    pub suggested_file: String,
    /// The untested function this test would cover
    pub for_function: String,
    /// Where the naming pattern came from (empty if default)
    pub pattern_source: String,
    /// Whether to put the test inline (vs external test file)
    pub inline: bool,
}

/// Suggest tests for untested callers in an impact result.
///
/// Loads its own call graph and test chunks — only called when `--suggest-tests`
/// is set, so the normal path pays zero overhead.
pub fn suggest_tests(store: &Store, impact: &ImpactResult) -> Vec<TestSuggestion> {
    let graph = match store.get_call_graph() {
        Ok(g) => g,
        Err(_) => return Vec::new(),
    };
    let test_chunks = match store.find_test_chunks() {
        Ok(t) => t,
        Err(_) => return Vec::new(),
    };

    let mut suggestions = Vec::new();

    for caller in &impact.callers {
        // Check if this caller is reached by ANY test (not just the target's tests)
        let ancestors = reverse_bfs(&graph, &caller.name, MAX_TEST_SEARCH_DEPTH);
        let is_tested = test_chunks
            .iter()
            .any(|t| ancestors.get(&t.name).is_some_and(|&d| d > 0));

        if is_tested {
            continue;
        }

        // Fetch file chunks once for inline test check, pattern, and language
        let file_chunks = store
            .get_chunks_by_origin(&caller.file.to_string_lossy())
            .ok()
            .unwrap_or_default();

        let is_test_chunk = |c: &crate::store::ChunkSummary| {
            c.name.starts_with("test_") || c.name.starts_with("Test")
        };

        let has_inline_tests = file_chunks.iter().any(is_test_chunk);

        let pattern_source = if has_inline_tests {
            file_chunks
                .iter()
                .find(|c| is_test_chunk(c))
                .map(|c| c.name.clone())
                .unwrap_or_default()
        } else {
            String::new()
        };

        let language = file_chunks.first().map(|c| c.language);

        // Generate test name based on language
        let base_name = caller.name.trim_start_matches("self.");
        let test_name = match language {
            Some(crate::parser::Language::JavaScript | crate::parser::Language::TypeScript) => {
                format!("test('{base_name}', ...)")
            }
            Some(crate::parser::Language::Java) if !base_name.is_empty() => {
                // Java: camelCase testMethodName
                let mut chars = base_name.chars();
                let first = chars.next().unwrap().to_uppercase().to_string();
                let rest: String = chars.collect();
                format!("test{first}{rest}")
            }
            _ => {
                // Rust, Python, Go, C, SQL, Markdown — all use snake_case test_ prefix
                format!("test_{base_name}")
            }
        };

        // Suggest file location
        let caller_file_str = caller.file.to_string_lossy().replace('\\', "/");

        let suggested_file = if has_inline_tests {
            caller_file_str.to_string()
        } else {
            suggest_test_file(&caller_file_str)
        };

        suggestions.push(TestSuggestion {
            test_name,
            suggested_file,
            for_function: caller.name.clone(),
            pattern_source,
            inline: has_inline_tests,
        });
    }

    suggestions
}

/// Derive a test file path from a source file path.
fn suggest_test_file(source: &str) -> String {
    // Extract the filename stem and extension
    let path = std::path::Path::new(source);
    let stem = path
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or("unknown");
    let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("rs");

    // Find the nearest parent directory
    let parent = path.parent().and_then(|p| p.to_str()).unwrap_or("tests");

    match ext {
        "rs" => format!("{parent}/tests/{stem}_test.rs"),
        "py" => format!("{parent}/test_{stem}.py"),
        "ts" | "tsx" => format!("{parent}/{stem}.test.ts"),
        "js" | "jsx" => format!("{parent}/{stem}.test.js"),
        "go" => format!("{parent}/{stem}_test.go"),
        "java" => format!("{parent}/{stem}Test.java"),
        _ => format!("{parent}/tests/{stem}_test.{ext}"),
    }
}

// ============ Helpers ============

fn rel_path(path: &Path, root: &Path) -> String {
    path.strip_prefix(root)
        .unwrap_or(path)
        .to_string_lossy()
        .replace('\\', "/")
}

fn node_letter(i: usize) -> String {
    if i < 26 {
        ((b'A' + i as u8) as char).to_string()
    } else {
        format!("{}{}", ((b'A' + (i % 26) as u8) as char), i / 26)
    }
}

fn mermaid_escape(s: &str) -> String {
    s.replace('"', "&quot;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
}

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

    // ===== suggest_test_file tests =====

    #[test]
    fn test_suggest_test_file_rust() {
        assert_eq!(
            suggest_test_file("src/search.rs"),
            "src/tests/search_test.rs"
        );
    }

    #[test]
    fn test_suggest_test_file_python() {
        assert_eq!(suggest_test_file("src/search.py"), "src/test_search.py");
    }

    #[test]
    fn test_suggest_test_file_typescript() {
        assert_eq!(suggest_test_file("src/search.ts"), "src/search.test.ts");
    }

    #[test]
    fn test_suggest_test_file_javascript() {
        assert_eq!(suggest_test_file("src/search.js"), "src/search.test.js");
    }

    #[test]
    fn test_suggest_test_file_go() {
        assert_eq!(suggest_test_file("pkg/search.go"), "pkg/search_test.go");
    }

    #[test]
    fn test_suggest_test_file_java() {
        assert_eq!(suggest_test_file("src/Search.java"), "src/SearchTest.java");
    }

    // ===== reverse_bfs tests =====

    #[test]
    fn test_reverse_bfs_empty_graph() {
        let graph = CallGraph {
            forward: HashMap::new(),
            reverse: HashMap::new(),
        };
        let result = reverse_bfs(&graph, "target", 5);
        assert_eq!(result.len(), 1); // Just the target itself at depth 0
        assert_eq!(result["target"], 0);
    }

    #[test]
    fn test_reverse_bfs_chain() {
        let mut reverse = HashMap::new();
        reverse.insert("C".to_string(), vec!["B".to_string()]);
        reverse.insert("B".to_string(), vec!["A".to_string()]);
        let graph = CallGraph {
            forward: HashMap::new(),
            reverse,
        };
        let result = reverse_bfs(&graph, "C", 5);
        assert_eq!(result["C"], 0);
        assert_eq!(result["B"], 1);
        assert_eq!(result["A"], 2);
    }

    #[test]
    fn test_reverse_bfs_respects_depth() {
        let mut reverse = HashMap::new();
        reverse.insert("C".to_string(), vec!["B".to_string()]);
        reverse.insert("B".to_string(), vec!["A".to_string()]);
        let graph = CallGraph {
            forward: HashMap::new(),
            reverse,
        };
        let result = reverse_bfs(&graph, "C", 1);
        assert_eq!(result.len(), 2); // C at 0, B at 1
        assert!(!result.contains_key("A")); // Beyond depth limit
    }

    // ===== suggest_tests edge case — empty callers =====

    #[test]
    fn test_suggest_tests_no_callers() {
        // ImpactResult with no callers should produce no suggestions
        let result = ImpactResult {
            function_name: "target_fn".to_string(),
            callers: Vec::new(),
            tests: Vec::new(),
            transitive_callers: Vec::new(),
        };
        // We can't call suggest_tests without a store, but we can verify
        // the empty callers path directly: zero callers → zero iterations
        assert!(result.callers.is_empty());
    }
}