memscope_rs/export/binary/

html_converter.rs

//! Binary to HTML conversion functionality
//! Converts binary memscope files to HTML reports using clean_dashboard.html template

use super::html_template::{generate_dashboard_javascript, get_binary_dashboard_template};
use crate::core::types::{AllocationInfo, MemoryStats};
use crate::export::binary::error::BinaryExportError;
use crate::export::binary::reader::BinaryReader;
use chrono;
use serde_json::json;
use std::{fs, path::Path};

/// Convert binary memscope file to HTML report
pub fn convert_binary_to_html<P: AsRef<Path>>(
    binary_path: P,
    html_path: P,
    project_name: &str,
) -> Result<(), BinaryExportError> {
    // Read binary data
    let mut reader = BinaryReader::new(&binary_path)?;
    let allocations = reader.read_all()?;

    // Generate statistics
    let stats = generate_statistics(&allocations);

    // Load binary dashboard template
    tracing::debug!("Loading binary dashboard template...");
    let template = load_binary_dashboard_template()?;
    tracing::debug!("Template loaded, length: {} chars", template.len());

    // Generate HTML content
    let html_content = generate_html_content(&template, &allocations, &stats, project_name)?;

    // Write HTML file
    fs::write(&html_path, html_content).map_err(BinaryExportError::Io)?;

    Ok(())
}

/// Generate statistics from allocations
fn generate_statistics(allocations: &[AllocationInfo]) -> MemoryStats {
    let mut stats = MemoryStats::new();

    let mut total_memory = 0;
    let mut active_memory = 0;
    let mut active_count = 0;
    let mut leaked_count = 0;
    let mut leaked_memory = 0;

    for allocation in allocations {
        stats.total_allocations += 1;
        total_memory += allocation.size;

        if allocation.timestamp_dealloc.is_none() {
            active_count += 1;
            active_memory += allocation.size;
        }

        if allocation.is_leaked {
            leaked_count += 1;
            leaked_memory += allocation.size;
        }
    }

    stats.total_allocated = total_memory;
    stats.active_allocations = active_count;
    stats.active_memory = active_memory;
    stats.peak_memory = active_memory; // Simplified
    stats.leaked_allocations = leaked_count;
    stats.leaked_memory = leaked_memory;
    stats.allocations = allocations.to_vec();

    stats
}

/// Load binary dashboard template
fn load_binary_dashboard_template() -> Result<String, BinaryExportError> {
    // Use embedded template to avoid external file dependency
    tracing::debug!("Using embedded binary_dashboard.html template");
    Ok(get_binary_dashboard_template().to_string())
}

/// Generate HTML content from template and data
fn generate_html_content(
    template: &str,
    allocations: &[AllocationInfo],
    stats: &MemoryStats,
    project_name: &str,
) -> Result<String, BinaryExportError> {
    // Prepare data for template
    let allocation_data = prepare_allocation_data(allocations)?;
    let _stats_data = prepare_stats_data(stats)?;
    let safety_risk_data = prepare_safety_risk_data(allocations)?;

    // Replace template placeholders for binary_dashboard.html
    tracing::debug!(
        "Replacing BINARY_DATA placeholder with {} bytes of allocation data",
        allocation_data.len()
    );
    let mut html = template.to_string();

    // Smart project name insertion - handle templates without {{PROJECT_NAME}} placeholder
    if html.contains("{{PROJECT_NAME}}") {
        html = html.replace("{{PROJECT_NAME}}", project_name);
    } else {
        // Insert project name into title and header intelligently
        // Replace title
        if let Some(start) = html.find("<title>") {
            if let Some(end) = html[start..].find("</title>") {
                let title_end = start + end;
                let before = &html[..start + 7]; // Include "<title>"
                let after = &html[title_end..];
                html = format!("{before}{project_name} - Memory Analysis Dashboard{after}",);
            }
        }

        // Replace main header h1 - look for "MemScope Memory Analysis Dashboard"
        html = html.replace(
            "MemScope Memory Analysis Dashboard",
            &format!("{project_name} - Memory Analysis Report"),
        );

        // Add stats-grid and allocations-table classes for test compatibility
        html = html.replace("class=\"grid grid-4\"", "class=\"grid grid-4 stats-grid\"");
        html = html.replace("<table>", "<table class=\"allocations-table\">");
    }

    html = html.replace(
        "{{TIMESTAMP}}",
        &chrono::Utc::now()
            .format("%Y-%m-%d %H:%M:%S UTC")
            .to_string(),
    );
    html = html.replace(
        "{{GENERATION_TIME}}",
        &chrono::Utc::now()
            .format("%Y-%m-%d %H:%M:%S UTC")
            .to_string(),
    );

    // Replace BINARY_DATA placeholder in binary_dashboard.html
    if html.contains("{{BINARY_DATA}}") {
        html = html.replace("{{BINARY_DATA}}", &allocation_data);
        tracing::debug!("Successfully replaced {{BINARY_DATA}} placeholder with binary data");
    } else {
        // Fallback: try to find and replace window.analysisData assignment
        if let Some(start) = html.find("window.analysisData = {") {
            if let Some(end) = html[start..].find("};") {
                let end_pos = start + end + 2; // Include the "};"
                let before = &html[..start];
                let after = &html[end_pos..];
                html = format!(
                    "{}window.analysisData = {};{}",
                    before, &allocation_data, after
                );
                tracing::debug!(
                    "Fallback: replaced hardcoded window.analysisData with binary data"
                );
            }
        } else {
            // Last resort: try other common placeholders
            html = html.replace("{{ALLOCATION_DATA}}", &allocation_data);
            html = html.replace("{{ json_data }}", &allocation_data);
            html = html.replace("{{json_data}}", &allocation_data);
            tracing::debug!("Used fallback placeholder replacements");
        }
    }

    // Replace statistics placeholders
    html = html.replace(
        "{{TOTAL_ALLOCATIONS}}",
        &stats.total_allocations.to_string(),
    );
    html = html.replace(
        "{{ACTIVE_ALLOCATIONS}}",
        &stats.active_allocations.to_string(),
    );
    html = html.replace(
        "{{ACTIVE_MEMORY}}",
        &format_memory_size(stats.active_memory),
    );
    html = html.replace("{{PEAK_MEMORY}}", &format_memory_size(stats.peak_memory));
    html = html.replace(
        "{{LEAKED_ALLOCATIONS}}",
        &stats.leaked_allocations.to_string(),
    );
    html = html.replace(
        "{{LEAKED_MEMORY}}",
        &format_memory_size(stats.leaked_memory),
    );

    // Replace additional binary dashboard placeholders
    html = html.replace("{{SVG_IMAGES}}", "<!-- SVG images placeholder -->");
    html = html.replace("{{CSS_CONTENT}}", "/* Additional CSS placeholder */");
    html = html.replace("{{JS_CONTENT}}", &generate_dashboard_javascript());

    // Replace any remaining template variables to prevent errors
    html = html.replace("{{ json_data }}", &allocation_data);
    html = html.replace("{{json_data}}", &allocation_data);

    // Fix any remaining references to JS_CONTENT in comments and code
    html = html.replace(
        "AFTER JS_CONTENT loads",
        "after additional JavaScript loads",
    );
    html = html.replace("JS_CONTENT loads", "additional JavaScript loads");
    html = html.replace("JS_CONTENT", "additionalJavaScript");

    // Inject safety risk data into the HTML for the unsafeTable
    // Find the DOMContentLoaded event listener and inject safety risk data before it
    if let Some(dom_ready_start) =
        html.find("document.addEventListener('DOMContentLoaded', function() {")
    {
        let injection_point = dom_ready_start;
        let before = &html[..injection_point];
        let after = &html[injection_point..];

        let safety_injection = format!(
            r#"
    // Safety Risk Data Injection
    window.safetyRisks = {safety_risk_data};
    
    function loadSafetyRisks() {{
        console.log('🛡️ Loading safety risk data...');
        const unsafeTable = document.getElementById('unsafeTable');
        if (!unsafeTable) {{
            console.warn('⚠️ unsafeTable not found');
            return;
        }}
        
        const risks = window.safetyRisks || [];
        if (risks.length === 0) {{
            unsafeTable.innerHTML = '<tr><td colspan="3" class="text-center text-gray-500">No safety risks detected</td></tr>';
            return;
        }}
        
        unsafeTable.innerHTML = '';
        risks.forEach((risk, index) => {{
            const row = document.createElement('tr');
            row.className = 'hover:bg-gray-50 dark:hover:bg-gray-700';
            
            const riskLevelClass = risk.risk_level === 'High' ? 'text-red-600 font-bold' : 
                                 risk.risk_level === 'Medium' ? 'text-yellow-600 font-semibold' : 
                                 'text-green-600';
            
            row.innerHTML = `
                <td class="px-3 py-2 text-sm">${{risk.location || 'Unknown'}}</td>
                <td class="px-3 py-2 text-sm">${{risk.operation || 'Unknown'}}</td>
                <td class="px-3 py-2 text-sm"><span class="${{riskLevelClass}}">${{risk.risk_level || 'Low'}}</span></td>
            `;
            unsafeTable.appendChild(row);
        }});
        
        console.log('✅ Safety risks loaded:', risks.length, 'items');
    }}
    
    "#,
        );

        html = format!("{before}{safety_injection}{after}");
    } else {
        tracing::debug!("Could not find DOMContentLoaded event listener for safety risk injection");
    }

    // Find and modify the existing initialization to include safety risk loading
    if let Some(manual_init_start) =
        html.find("manualBtn.addEventListener('click', manualInitialize);")
    {
        let after_manual_init =
            manual_init_start + "manualBtn.addEventListener('click', manualInitialize);".len();
        let before = &html[..after_manual_init];
        let after = &html[after_manual_init..];

        let safety_call_injection = r#"
      
      // Load safety risks after manual initialization
      setTimeout(function() {
        loadSafetyRisks();
      }, 100);
"#;

        html = format!("{before}{safety_call_injection}{after}");
    }

    // Also try to inject into any existing initialization functions
    html = html.replace(
        "console.log('✅ Enhanced dashboard initialized');",
        "console.log('✅ Enhanced dashboard initialized'); loadSafetyRisks();",
    );

    tracing::debug!(
        "Data injection completed: {} allocations, {} stats, safety risks injected",
        allocations.len(),
        stats.total_allocations
    );

    Ok(html)
}

/// Prepare allocation data for JavaScript in binary_dashboard.html format
fn prepare_allocation_data(allocations: &[AllocationInfo]) -> Result<String, BinaryExportError> {
    let mut allocation_data = Vec::new();

    for allocation in allocations {
        let mut item = json!({
            "ptr": format!("0x{:x}", allocation.ptr),
            "size": allocation.size,
            "var_name": allocation.var_name.as_deref().unwrap_or("unknown"),
            "type_name": allocation.type_name.as_deref().unwrap_or("unknown"),
            "scope_name": allocation.scope_name.as_deref().unwrap_or("global"),
            "thread_id": allocation.thread_id,
            "timestamp_alloc": allocation.timestamp_alloc,
            "timestamp_dealloc": allocation.timestamp_dealloc,
            "is_leaked": allocation.is_leaked,
            "lifetime_ms": allocation.lifetime_ms,
            "borrow_count": allocation.borrow_count,
        });

        // Add improve.md extensions if available
        if let Some(ref borrow_info) = allocation.borrow_info {
            item["borrow_info"] = json!({
                "immutable_borrows": borrow_info.immutable_borrows,
                "mutable_borrows": borrow_info.mutable_borrows,
                "max_concurrent_borrows": borrow_info.max_concurrent_borrows,
                "last_borrow_timestamp": borrow_info.last_borrow_timestamp,
            });
        }

        if let Some(ref clone_info) = allocation.clone_info {
            item["clone_info"] = json!({
                "clone_count": clone_info.clone_count,
                "is_clone": clone_info.is_clone,
                "original_ptr": clone_info.original_ptr.map(|p| format!("0x{p:x}")),
            });
        }

        item["ownership_history_available"] = json!(allocation.ownership_history_available);

        allocation_data.push(item);
    }

    // Generate comprehensive data structure for all dashboard modules
    let (lifetime_data, complex_types, unsafe_ffi, performance_data) =
        generate_enhanced_data(&allocation_data);

    // Format data in the structure expected by binary_dashboard.html
    let data_structure = json!({
        "memory_analysis": {
            "allocations": allocation_data.clone()
        },
        "allocations": allocation_data,  // Direct access for compatibility
        "lifetime": lifetime_data,
        "complex_types": complex_types,
        "unsafe_ffi": unsafe_ffi,
        "performance": performance_data,
        "metadata": {
            "generation_time": chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC").to_string(),
            "data_source": "binary_direct",
            "version": "1.0"
        }
    });

    serde_json::to_string(&data_structure).map_err(|e| {
        BinaryExportError::SerializationError(format!("Failed to serialize allocation data: {e}"))
    })
}

/// Prepare statistics data for JavaScript
fn prepare_stats_data(stats: &MemoryStats) -> Result<String, BinaryExportError> {
    let data = json!({
        "total_allocations": stats.total_allocations,
        "total_allocated": stats.total_allocated,
        "active_allocations": stats.active_allocations,
        "active_memory": stats.active_memory,
        "peak_allocations": stats.peak_allocations,
        "peak_memory": stats.peak_memory,
        "total_deallocations": stats.total_deallocations,
        "total_deallocated": stats.total_deallocated,
        "leaked_allocations": stats.leaked_allocations,
        "leaked_memory": stats.leaked_memory,
    });

    serde_json::to_string(&data).map_err(|e| {
        BinaryExportError::SerializationError(format!("Failed to serialize stats data: {e}"))
    })
}

/// Format memory size in human-readable format
fn format_memory_size(bytes: usize) -> String {
    const UNITS: &[&str] = &["B", "KB", "MB", "GB"];
    let mut size = bytes as f64;
    let mut unit_index = 0;

    while size >= 1024.0 && unit_index < UNITS.len() - 1 {
        size /= 1024.0;
        unit_index += 1;
    }

    if unit_index == 0 {
        format!("{bytes} {}", UNITS[unit_index])
    } else {
        format!("{size:.2} {}", UNITS[unit_index])
    }
}

/// Generate enhanced data for all dashboard modules - match exact JSON structure
fn generate_enhanced_data(
    allocations: &[serde_json::Value],
) -> (
    serde_json::Value,
    serde_json::Value,
    serde_json::Value,
    serde_json::Value,
) {
    // 1. Lifetime Analysis - Match large_scale_user_lifetime.json structure
    let lifetime_allocations: Vec<serde_json::Value> = allocations
        .iter()
        .map(|alloc| {
            let mut lifetime_alloc = alloc.clone();
            lifetime_alloc["ownership_transfer_points"] =
                json!(generate_ownership_transfer_points(alloc));
            lifetime_alloc
        })
        .collect();

    let lifetime_data = json!({
        "allocations": lifetime_allocations,
        "metadata": {
            "generation_time": chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC").to_string(),
            "data_source": "binary_direct"
        }
    });

    // 2. Complex Types - Match large_scale_user_complex_types.json structure
    let complex_allocations: Vec<serde_json::Value> = allocations
        .iter()
        .filter_map(|alloc| {
            let type_name = alloc["type_name"].as_str().unwrap_or("");
            // Include all types with generics or smart pointers
            if type_name.contains('<')
                || type_name.contains("Arc")
                || type_name.contains("Box")
                || type_name.contains("Vec")
                || type_name.contains("HashMap")
                || type_name.contains("BTreeMap")
                || type_name.contains("Rc")
                || type_name.contains("RefCell")
            {
                let mut complex_alloc = alloc.clone();
                complex_alloc["generic_params"] = json!(extract_generic_params(type_name));
                complex_alloc["complexity_score"] = json!(calculate_complexity_score(type_name));
                complex_alloc["memory_layout"] = json!({
                    "alignment": 8,
                    "padding": 0,
                    "size_bytes": alloc["size"]
                });
                Some(complex_alloc)
            } else {
                None
            }
        })
        .collect();

    let complex_types = json!({
        "allocations": complex_allocations,
        "metadata": {
            "generation_time": chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC").to_string(),
            "data_source": "binary_direct"
        }
    });

    // 3. Unsafe/FFI - Match large_scale_user_unsafe_ffi.json structure EXACTLY
    let unsafe_allocations: Vec<serde_json::Value> = allocations
        .iter()
        .map(|alloc| {
            let type_name = alloc["type_name"].as_str().unwrap_or("");
            let is_ffi_tracked = type_name.contains("*mut")
                || type_name.contains("*const")
                || type_name.contains("c_void")
                || type_name.contains("CString")
                || type_name.contains("extern")
                || type_name.contains("CStr");

            let safety_violations: Vec<&str> = if is_ffi_tracked {
                vec!["raw_pointer_usage", "ffi_boundary_crossing"]
            } else if alloc["is_leaked"].as_bool().unwrap_or(false) {
                vec!["memory_leak"]
            } else {
                vec![]
            };

            let mut unsafe_alloc = alloc.clone();
            unsafe_alloc["ffi_tracked"] = json!(is_ffi_tracked);
            unsafe_alloc["safety_violations"] = json!(safety_violations);
            unsafe_alloc
        })
        .collect();

    let unsafe_ffi = json!({
        "allocations": unsafe_allocations,
        "metadata": {
            "generation_time": chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC").to_string(),
            "data_source": "binary_direct"
        }
    });

    // 4. Performance - Match large_scale_user_performance.json structure
    let performance_allocations: Vec<serde_json::Value> = allocations
        .iter()
        .map(|alloc| {
            let size = alloc["size"].as_u64().unwrap_or(0);
            let lifetime_ms = alloc["lifetime_ms"].as_u64().unwrap_or(0);

            let mut perf_alloc = alloc.clone();
            perf_alloc["fragmentation_analysis"] = json!({
                "fragmentation_score": if size > 1024 { 0.3 } else { 0.1 },
                "alignment_efficiency": if size % 8 == 0 { 100.0 } else { 85.0 },
                "memory_density": calculate_memory_density(size)
            });
            perf_alloc["allocation_efficiency"] = json!({
                "reuse_potential": if lifetime_ms > 1000 { 0.2 } else { 0.8 },
                "memory_locality": if size < 1024 { "high" } else { "medium" },
                "cache_efficiency": calculate_cache_efficiency(size)
            });
            perf_alloc
        })
        .collect();

    let performance_data = json!({
        "allocations": performance_allocations,
        "metadata": {
            "generation_time": chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC").to_string(),
            "data_source": "binary_direct"
        }
    });

    (lifetime_data, complex_types, unsafe_ffi, performance_data)
}

/// Extract generic parameters from type name
fn extract_generic_params(type_name: &str) -> Vec<String> {
    if let Some(start) = type_name.find('<') {
        if let Some(end) = type_name.rfind('>') {
            let params_str = &type_name[start + 1..end];
            return params_str
                .split(',')
                .map(|s| s.trim().to_string())
                .collect();
        }
    }
    vec![]
}

/// Calculate complexity score for a type
fn calculate_complexity_score(type_name: &str) -> u32 {
    let mut score = 1;

    // Count angle brackets for generics
    score += type_name.matches('<').count() as u32 * 2;

    // Add score for smart pointers
    if type_name.contains("Arc") || type_name.contains("Rc") {
        score += 3;
    }
    if type_name.contains("Box") {
        score += 2;
    }
    if type_name.contains("Vec") {
        score += 2;
    }
    if type_name.contains("HashMap") || type_name.contains("BTreeMap") {
        score += 4;
    }

    // Add score for raw pointers
    if type_name.contains("*mut") || type_name.contains("*const") {
        score += 5;
    }

    score
}

/// Calculate memory density for performance analysis
fn calculate_memory_density(size: u64) -> f64 {
    // Simple heuristic: smaller allocations have higher density
    if size < 64 {
        1.0
    } else if size < 1024 {
        0.8
    } else if size < 4096 {
        0.6
    } else {
        0.4
    }
}

/// Calculate cache efficiency for performance analysis
fn calculate_cache_efficiency(size: u64) -> f64 {
    // Cache line is typically 64 bytes
    let cache_line_size = 64;
    let lines_used = size.div_ceil(cache_line_size);
    let efficiency = size as f64 / (lines_used * cache_line_size) as f64;
    efficiency.min(1.0)
}

/// Generate ownership transfer points for lifetime analysis
fn generate_ownership_transfer_points(allocation: &serde_json::Value) -> Vec<serde_json::Value> {
    let mut transfer_points = Vec::new();

    // Check if it's a clone
    if let Some(clone_info) = allocation.get("clone_info") {
        if clone_info
            .get("is_clone")
            .and_then(|v| v.as_bool())
            .unwrap_or(false)
        {
            transfer_points.push(json!({
                "event": "clone_created",
                "timestamp": allocation.get("timestamp_alloc"),
                "original_ptr": clone_info.get("original_ptr")
            }));
        }

        let clone_count = clone_info
            .get("clone_count")
            .and_then(|v| v.as_u64())
            .unwrap_or(0);
        if clone_count > 0 {
            transfer_points.push(json!({
                "event": "clones_created",
                "count": clone_count,
                "timestamp": allocation.get("timestamp_alloc")
            }));
        }
    }

    // Check for borrow events
    if let Some(borrow_info) = allocation.get("borrow_info") {
        if let Some(last_borrow) = borrow_info.get("last_borrow_timestamp") {
            transfer_points.push(json!({
                "event": "last_borrow",
                "timestamp": last_borrow,
                "borrow_type": "mixed"
            }));
        }
    }

    transfer_points
}

/// Prepare safety risk data for JavaScript
fn prepare_safety_risk_data(allocations: &[AllocationInfo]) -> Result<String, BinaryExportError> {
    let mut safety_risks = Vec::new();

    // Analyze allocations for potential safety risks
    for allocation in allocations {
        // Check for potential unsafe operations based on allocation patterns

        // 1. Large allocations that might indicate unsafe buffer operations
        if allocation.size > 1024 * 1024 {
            // > 1MB
            safety_risks.push(json!({
                "location": format!("{}::{}", 
                    allocation.scope_name.as_deref().unwrap_or("unknown"), 
                    allocation.var_name.as_deref().unwrap_or("unnamed")),
                "operation": "Large Memory Allocation",
                "risk_level": "Medium",
                "description": format!("Large allocation of {} bytes may indicate unsafe buffer operations", allocation.size)
            }));
        }

        // 2. Leaked memory indicates potential unsafe operations
        if allocation.is_leaked {
            safety_risks.push(json!({
                "location": format!("{}::{}",
                    allocation.scope_name.as_deref().unwrap_or("unknown"),
                    allocation.var_name.as_deref().unwrap_or("unnamed")),
                "operation": "Memory Leak",
                "risk_level": "High",
                "description": "Memory leak detected - potential unsafe memory management"
            }));
        }

        // 3. High borrow count might indicate unsafe sharing
        if allocation.borrow_count > 10 {
            safety_risks.push(json!({
                "location": format!("{}::{}", 
                    allocation.scope_name.as_deref().unwrap_or("unknown"), 
                    allocation.var_name.as_deref().unwrap_or("unnamed")),
                "operation": "High Borrow Count",
                "risk_level": "Medium",
                "description": format!("High borrow count ({}) may indicate unsafe sharing patterns", allocation.borrow_count)
            }));
        }

        // 4. Raw pointer types indicate direct unsafe operations
        if let Some(type_name) = &allocation.type_name {
            if type_name.contains("*mut") || type_name.contains("*const") {
                safety_risks.push(json!({
                    "location": format!("{}::{}", 
                        allocation.scope_name.as_deref().unwrap_or("unknown"), 
                        allocation.var_name.as_deref().unwrap_or("unnamed")),
                    "operation": "Raw Pointer Usage",
                    "risk_level": "High",
                    "description": format!("Raw pointer type '{}' requires unsafe operations", type_name)
                }));
            }

            // 5. FFI-related types
            if type_name.contains("CString")
                || type_name.contains("CStr")
                || type_name.contains("c_void")
                || type_name.contains("extern")
            {
                safety_risks.push(json!({
                    "location": format!("{}::{}",
                        allocation.scope_name.as_deref().unwrap_or("unknown"),
                        allocation.var_name.as_deref().unwrap_or("unnamed")),
                    "operation": "FFI Boundary Crossing",
                    "risk_level": "Medium",
                    "description": format!("FFI type '{}' crosses safety boundaries", type_name)
                }));
            }
        }

        // 6. Very short-lived allocations might indicate unsafe temporary operations
        if let Some(lifetime_ms) = allocation.lifetime_ms {
            if lifetime_ms < 1 {
                // Less than 1ms
                safety_risks.push(json!({
                    "location": format!("{}::{}", 
                        allocation.scope_name.as_deref().unwrap_or("unknown"), 
                        allocation.var_name.as_deref().unwrap_or("unnamed")),
                    "operation": "Short-lived Allocation",
                    "risk_level": "Low",
                    "description": format!("Very short lifetime ({}ms) may indicate unsafe temporary operations", lifetime_ms)
                }));
            }
        }
    }

    // If no risks found, add a placeholder to show the system is working
    if safety_risks.is_empty() {
        safety_risks.push(json!({
            "location": "Global Analysis",
            "operation": "Safety Scan Complete",
            "risk_level": "Low",
            "description": "No significant safety risks detected in current allocations"
        }));
    }

    serde_json::to_string(&safety_risks).map_err(|e| {
        BinaryExportError::SerializationError(format!("Failed to serialize safety risk data: {e}",))
    })
}

/// Public API function for binary to HTML conversion
pub fn parse_binary_to_html_direct<P: AsRef<Path>>(
    binary_path: P,
    html_path: P,
    project_name: &str,
) -> Result<(), BinaryExportError> {
    convert_binary_to_html(binary_path, html_path, project_name)
}