// Comprehensive test of ALL MCP tools to verify they return non-empty data
use leankg::db::schema::init_db;
use leankg::graph::GraphEngine;
use leankg::mcp::handler::ToolHandler;
use serde_json::json;
use std::path::PathBuf;

#[tokio::test(flavor = "multi_thread")]
async fn test_all_mcp_tools_return_data() {
    let db_path = PathBuf::from(".leankg");
    let db = init_db(db_path.as_path()).expect("Failed to init db");
    let graph = GraphEngine::new(db);
    let handler = ToolHandler::new(graph.clone(), db_path);

    let valid_file = "./src/main.rs".to_string();
    let valid_function = "./src/main.rs::main".to_string();

    println!("Testing MCP tools...\n");

    // Core tools with valid params
    let tools_and_tests = vec![
        ("mcp_init", json!({"path": ".leankg"})),
        ("mcp_status", json!({})),
        ("mcp_index", json!({"path": "./src"})),
        ("query_file", json!({"file": &valid_file, "pattern": "fn"})),
        ("search_code", json!({"query": "fn"})),
        ("find_function", json!({"name": "main"})),
        ("get_dependencies", json!({"file": &valid_file})),
        ("get_dependents", json!({"file": &valid_file})),
        (
            "get_call_graph",
            json!({"function": &valid_function, "depth": 1}),
        ),
        ("get_callers", json!({"function": "validate_key"})),
        ("get_tested_by", json!({"file": &valid_file})),
        ("get_context", json!({"file": &valid_file})),
        (
            "get_impact_radius",
            json!({"file": &valid_file, "depth": 2}),
        ),
        ("get_review_context", json!({"files": [&valid_file]})),
        ("find_large_functions", json!({})),
        ("generate_doc", json!({"file": &valid_file})),
        ("get_doc_for_file", json!({"file": &valid_file})),
        (
            "get_files_for_doc",
            json!({"doc": "./docs/requirement/prd-leankg.md"}),
        ),
        ("get_doc_structure", json!({})),
        ("get_traceability", json!({"element": &valid_function})),
        ("get_doc_tree", json!({})),
        ("get_code_tree", json!({})),
        ("find_related_docs", json!({"file": &valid_file})),
        ("get_clusters", json!({})),
        ("get_cluster_context", json!({"cluster_id": "1"})),
        ("mcp_hello", json!({})),
        ("ctx_read", json!({"file": &valid_file})),
        ("detect_changes", json!({"path": "./src"})),
        ("orchestrate", json!({"intent": "find main function"})),
        ("get_service_graph", json!({})),
        ("mcp_impact", json!({"file": "./src/main.rs", "depth": 2})),
        ("mcp_index_docs", json!({"path": "./docs"})),
        ("mcp_install", json!({})),
        (
            "run_raw_query",
            json!({"query": "?[name] := *code_elements[_, _, name, _, _, _, _, _, _, _, _, _] :limit 5"}),
        ),
        (
            "search_by_requirement",
            json!({"requirement_id": "REQ-001"}),
        ),
    ];

    let mut passed = 0;
    let mut failed = 0;
    let mut skipped = 0;

    for (tool_name, args) in tools_and_tests {
        match handler.execute_tool(tool_name, &args).await {
            Ok(result) => {
                let is_empty = if result.is_array() {
                    result.as_array().map(|a| a.is_empty()).unwrap_or(false)
                } else if result.is_object() {
                    let obj = result.as_object().unwrap();
                    obj.values().all(|v| {
                        v.is_null()
                            || (v.is_array() && v.as_array().unwrap().is_empty())
                            || (v.is_string() && v.as_str().unwrap().is_empty())
                    })
                } else {
                    false
                };

                if is_empty {
                    // Empty results may be expected for some tools (no matching data)
                    println!("⚠️  {}: no data (empty result)", tool_name);
                    skipped += 1;
                } else {
                    println!("✅ {}: returned data", tool_name);
                    passed += 1;
                }
            }
            Err(e) => {
                let err_str = e.to_string();
                // Categorize errors
                if err_str.contains("not found")
                    || err_str.contains("No such file")
                    || err_str.contains("does not exist")
                    || err_str.contains("not available")
                    || err_str.contains("no doc")
                    || err_str.contains("no clusters")
                    || err_str.contains("empty")
                    || err_str.contains("not exist")
                    || err_str.contains("Cluster not found")
                    || err_str.contains("not initialized")
                    || err_str.contains("not indexed")
                    || err_str.contains("not readable")
                    || err_str.contains("no matching")
                {
                    println!("⚠️  {}: not applicable ({})", tool_name, e);
                    skipped += 1;
                } else {
                    println!("❌ {}: ERROR - {}", tool_name, e);
                    failed += 1;
                }
            }
        }
    }

    println!("\n=== Summary ===");
    println!("Passed: {}", passed);
    println!("Failed: {} (should be 0)", failed);
    println!("Skipped (not applicable): {}", skipped);
    println!("Total tested: {}", passed + failed + skipped);

    assert_eq!(failed, 0, "Some tools returned empty data or errors");
}
