trustformers-debug 0.1.1

//! Advanced Debugging Features Demo
#![allow(unused_variables)]
//!
//! This example demonstrates the cutting-edge debugging capabilities added to
//! the TrustformeRS Debug crate, including quantum-inspired analysis,
//! WebAssembly interface, and real-time dashboard.

use anyhow::Result;
use scirs2_core::ndarray::Array2;
use std::time::Duration;
use tokio::time::sleep;
use tokio_stream::StreamExt;
use trustformers_debug::{
    DashboardAlertSeverity, DashboardBuilder, MetricCategory, QuantumDebugConfig, QuantumDebugger,
};

#[tokio::main]
async fn main() -> Result<()> {
    println!("🚀 TrustformeRS Advanced Debugging Features Demo");
    println!("================================================\n");

    // Demo 1: Quantum-Inspired Neural Network Analysis
    println!("1️⃣  Quantum-Inspired Neural Network Analysis");
    println!("-------------------------------------------");
    quantum_debugging_demo().await?;

    println!("\n2️⃣  WebAssembly Interface Demo");
    println!("-----------------------------");
    // wasm_interface_demo().await?; // Commented out - requires 'wasm' feature

    println!("\n3️⃣  Real-Time Dashboard Demo");
    println!("---------------------------");
    realtime_dashboard_demo().await?;

    println!("\n✨ All advanced debugging features demonstrated successfully!");
    Ok(())
}

/// Demonstrate quantum-inspired debugging capabilities
async fn quantum_debugging_demo() -> Result<()> {
    // Configure quantum debugging
    let config = QuantumDebugConfig {
        num_qubits: 8,
        enable_superposition_analysis: true,
        enable_entanglement_detection: true,
        enable_interference_analysis: true,
        measurement_sampling_rate: 0.15,
        enable_error_correction: true,
        enable_vqe_analysis: true,
        enable_qaoa_analysis: true,
        enable_noise_modeling: true,
        enable_hybrid_debugging: true,
        max_circuit_depth: 50,
        noise_level: 0.02,
        enable_quantum_benchmarking: true,
        enable_feature_map_analysis: true,
    };

    let mut quantum_debugger = QuantumDebugger::new(config);

    println!("🔬 Creating neural network layers for quantum analysis...");

    // Create some test neural network weights
    let layer1_weights = Array2::<f32>::from_shape_fn((4, 4), |(i, j)| {
        0.1 * (i as f32 + j as f32) + 0.05 * (i as f32 * j as f32).sin()
    })
    .into_dyn();

    let layer2_weights =
        Array2::<f32>::from_shape_fn((6, 6), |(i, j)| 0.2 * ((i + j) as f32).exp() / 10.0)
            .into_dyn();

    let layer3_weights =
        Array2::<f32>::from_shape_fn((8, 8), |(i, j)| 0.15 * (i as f32 - j as f32).abs().sqrt())
            .into_dyn();

    // Perform quantum analysis on each layer
    println!("⚛️  Analyzing layer1 with quantum methods...");
    let analysis1 = quantum_debugger.analyze_layer_quantum("attention_layer", &layer1_weights)?;
    println!("   - Coherence Score: {:.4}", analysis1.coherence_score);
    println!(
        "   - Quantum Advantage Score: {:.4}",
        analysis1.quantum_advantage_score
    );

    if let Some(ref entanglement) = analysis1.entanglement_analysis {
        println!(
            "   - Quantum Mutual Information: {:.4}",
            entanglement.quantum_mutual_information
        );
        println!(
            "   - Von Neumann Entropy (avg): {:.4}",
            entanglement.von_neumann_entropy.iter().sum::<f64>()
                / entanglement.von_neumann_entropy.len() as f64
        );
    }

    println!("⚛️  Analyzing layer2 with quantum methods...");
    let analysis2 = quantum_debugger.analyze_layer_quantum("feedforward_layer", &layer2_weights)?;
    println!("   - Coherence Score: {:.4}", analysis2.coherence_score);
    println!(
        "   - Quantum Advantage Score: {:.4}",
        analysis2.quantum_advantage_score
    );

    println!("⚛️  Analyzing layer3 with quantum methods...");
    let analysis3 = quantum_debugger.analyze_layer_quantum("output_layer", &layer3_weights)?;
    println!("   - Coherence Score: {:.4}", analysis3.coherence_score);
    println!(
        "   - Quantum Advantage Score: {:.4}",
        analysis3.quantum_advantage_score
    );

    // Generate quantum optimization recommendations
    let optimizations = quantum_debugger.suggest_quantum_optimizations();
    println!("\n🎯 Quantum Optimization Suggestions:");
    for (i, suggestion) in optimizations.iter().enumerate() {
        println!("   {}. {}", i + 1, suggestion);
    }

    // Get comprehensive report
    let report = quantum_debugger.get_comprehensive_report();
    println!("\n📊 Quantum Analysis Summary:");
    println!("   - Total layers analyzed: {}", report.len());

    let avg_coherence: f64 =
        report.values().map(|a| a.coherence_score).sum::<f64>() / report.len() as f64;
    let avg_advantage: f64 =
        report.values().map(|a| a.quantum_advantage_score).sum::<f64>() / report.len() as f64;

    println!("   - Average Coherence Score: {:.4}", avg_coherence);
    println!("   - Average Quantum Advantage: {:.4}", avg_advantage);

    Ok(())
}

// Demonstrate WebAssembly interface capabilities (commented out - requires 'wasm' feature)
#[allow(dead_code)]
/*
async fn wasm_interface_demo() -> Result<()> {
    println!("🌐 Initializing WebAssembly Debug Session...");

    // Create WASM debug session
    let mut wasm_session = WasmDebugSession::new();

    // Initialize with configuration
    let config_json = r#"{
        "browser_optimizations": true,
        "nodejs_features": false,
        "max_memory_mb": 128,
        "enable_streaming": true,
        "streaming_chunk_size": 512,
        "enable_webgl": false,
        "enable_web_workers": true
    }"#;

    let success = wasm_session.initialize(config_json);
    println!("   ✅ Session initialized: {}", success);

    // Add test tensors
    println!("📊 Adding tensors for WASM analysis...");

    let tensor1_data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
    let tensor1_shape = vec![2, 4];
    let success = wasm_session.add_tensor("conv_weights", &tensor1_data, &tensor1_shape);
    println!("   ✅ Added conv_weights tensor: {}", success);

    let tensor2_data = vec![0.1, 0.5, -0.2, 100.0, 0.3]; // Contains outlier
    let tensor2_shape = vec![5];
    let success = wasm_session.add_tensor("biases", &tensor2_data, &tensor2_shape);
    println!("   ✅ Added biases tensor: {}", success);

    let tensor3_data = vec![0.0, 0.0, 0.0, 0.5, 0.8, 0.3, 0.0, 0.0, 0.0]; // Sparse tensor
    let tensor3_shape = vec![3, 3];
    let success = wasm_session.add_tensor("attention_mask", &tensor3_data, &tensor3_shape);
    println!("   ✅ Added attention_mask tensor: {}", success);

    // Perform individual tensor analysis
    println!("🔍 Analyzing individual tensors...");

    let analysis1 = wasm_session.analyze_tensor("conv_weights");
    println!(
        "   📈 Conv weights analysis: {} characters",
        analysis1.len()
    );

    let analysis2 = wasm_session.analyze_tensor("biases");
    println!("   📈 Biases analysis: {} characters", analysis2.len());

    // Perform batch analysis
    println!("📊 Performing batch analysis of all tensors...");
    let batch_analysis = wasm_session.analyze_all_tensors();
    println!(
        "   📋 Batch analysis result: {} characters",
        batch_analysis.len()
    );

    // Detect anomalies
    println!("🚨 Detecting anomalies in tensors...");
    let anomalies1 = wasm_session.detect_anomalies("biases", 2.0);
    println!("   ⚠️  Biases anomalies: {} characters", anomalies1.len());

    let anomalies2 = wasm_session.detect_anomalies("attention_mask", 1.5);
    println!(
        "   ⚠️  Attention mask anomalies: {} characters",
        anomalies2.len()
    );

    // Generate visualization data
    println!("📊 Generating visualization data...");
    let viz_data1 = wasm_session.generate_visualization_data("conv_weights");
    println!(
        "   🎨 Conv weights visualization: {} characters",
        viz_data1.len()
    );

    let viz_data2 = wasm_session.generate_visualization_data("attention_mask");
    println!(
        "   🎨 Attention mask visualization: {} characters",
        viz_data2.len()
    );

    // Export results in different formats
    println!("💾 Exporting analysis results...");

    let json_export = wasm_session.export_results("json");
    println!("   📄 JSON export: {} characters", json_export.len());

    let csv_export = wasm_session.export_results("csv");
    println!("   📊 CSV export: {} characters", csv_export.len());

    let html_export = wasm_session.export_results("html");
    println!("   🌐 HTML export: {} characters", html_export.len());

    // Get session statistics
    let stats = wasm_session.get_session_stats();
    println!("📊 Session Statistics: {} characters", stats.len());

    // Get tensor list
    let tensor_list = wasm_session.get_tensor_list();
    println!("📋 Tensor list: {}", tensor_list);

    // Clean up
    wasm_session.clear();
    println!("🧹 Session cleared");

    Ok(())
}
*/
/// Demonstrate real-time dashboard capabilities
async fn realtime_dashboard_demo() -> Result<()> {
    println!("📊 Setting up Real-Time Dashboard...");

    // Create dashboard with custom configuration
    let dashboard = DashboardBuilder::new()
        .port(8082)
        .update_frequency(50) // 50ms updates
        .max_data_points(100)
        .gpu_monitoring(true)
        .memory_profiling(true)
        .build();

    // Start the dashboard
    println!("🚀 Starting dashboard server...");
    dashboard.start().await?;

    // Subscribe to WebSocket messages (simulate client connection)
    let mut message_stream = dashboard.subscribe();
    println!("   ✅ WebSocket client connected");

    // Simulate training metrics over time
    println!("🏋️  Simulating training session with real-time metrics...");

    for epoch in 0..5 {
        println!("   📈 Epoch {}/5", epoch + 1);

        // Simulate training metrics for this epoch
        for step in 0..10 {
            let loss = 2.0 * (-0.1 * (epoch * 10 + step) as f64).exp()
                + 0.1
                + 0.05 * (step as f64 * 0.5).sin();
            let accuracy = 0.5
                + 0.4 * (1.0 - (-0.08 * (epoch * 10 + step) as f64).exp())
                + 0.02 * (step as f64 * 0.3).cos();
            let learning_rate = 0.001 * 0.95_f64.powi(epoch);

            // Add training metrics
            let _ = dashboard.add_metrics(vec![
                (MetricCategory::Training, "loss".to_string(), loss),
                (MetricCategory::Training, "accuracy".to_string(), accuracy),
                (
                    MetricCategory::Training,
                    "learning_rate".to_string(),
                    learning_rate,
                ),
            ]);

            // Simulate system metrics
            let memory_usage = 45.0 + 25.0 * (step as f64 / 10.0) + 5.0 * (step as f64 * 0.8).sin();
            let gpu_util = 60.0 + 30.0 * (step as f64 / 10.0) + 8.0 * (step as f64 * 0.6).cos();
            let gpu_memory = 30.0 + 20.0 * (step as f64 / 10.0) + 3.0 * (step as f64 * 1.2).sin();

            let _ = dashboard.add_metrics(vec![
                (
                    MetricCategory::Memory,
                    "usage_percent".to_string(),
                    memory_usage,
                ),
                (MetricCategory::GPU, "utilization".to_string(), gpu_util),
                (
                    MetricCategory::GPU,
                    "memory_percent".to_string(),
                    gpu_memory,
                ),
            ]);

            // Occasionally simulate alerts
            if step == 5 && epoch == 2 {
                let _ = dashboard.create_alert(
                    DashboardAlertSeverity::Warning,
                    MetricCategory::Memory,
                    "High Memory Usage".to_string(),
                    "Memory usage exceeded 75%".to_string(),
                    Some(memory_usage),
                    Some(75.0),
                );
                println!("   ⚠️  Generated high memory usage alert");
            }

            if step == 8 && epoch == 3 {
                let _ = dashboard.create_alert(
                    DashboardAlertSeverity::Info,
                    MetricCategory::Training,
                    "Training Progress".to_string(),
                    format!("Reached {:.1}% accuracy", accuracy * 100.0),
                    Some(accuracy),
                    None,
                );
                println!("   ℹ️  Generated training progress alert");
            }

            // Small delay to simulate real training time
            sleep(Duration::from_millis(20)).await;
        }

        println!(
            "      Loss: {:.4}, Accuracy: {:.3}%",
            2.0 * (-0.1 * (epoch * 10 + 9) as f64).exp() + 0.1,
            (0.5 + 0.4 * (1.0 - (-0.08 * (epoch * 10 + 9) as f64).exp())) * 100.0
        );
    }

    // Get historical data samples
    println!("📊 Retrieving historical data...");
    let training_data = dashboard.get_historical_data(&MetricCategory::Training);
    let gpu_data = dashboard.get_historical_data(&MetricCategory::GPU);
    let memory_data = dashboard.get_historical_data(&MetricCategory::Memory);

    println!("   📈 Training data points: {}", training_data.len());
    println!("   🎮 GPU data points: {}", gpu_data.len());
    println!("   🧠 Memory data points: {}", memory_data.len());

    // Show system statistics
    let stats = dashboard.get_system_stats();
    println!("📊 Dashboard System Statistics:");
    println!("   - Uptime: {} seconds", stats.uptime);
    println!("   - Total alerts: {}", stats.total_alerts);
    println!("   - Active connections: {}", stats.active_connections);
    println!(
        "   - Data points collected: {}",
        stats.data_points_collected
    );
    println!("   - Memory usage: {:.1} MB", stats.memory_usage_mb);
    println!("   - CPU usage: {:.1}%", stats.cpu_usage_percent);

    // Try to receive a few WebSocket messages
    println!("📡 Checking WebSocket messages...");
    let mut message_count = 0;

    while message_count < 3 {
        match tokio::time::timeout(Duration::from_millis(100), message_stream.next()).await {
            Ok(Some(Ok(message))) => {
                message_count += 1;
                match message {
                    trustformers_debug::WebSocketMessage::MetricUpdate { data } => {
                        println!(
                            "   📊 Received metric update with {} data points",
                            data.len()
                        );
                    },
                    trustformers_debug::WebSocketMessage::Alert { alert } => {
                        println!("   🚨 Received alert: {} - {}", alert.title, alert.message);
                    },
                    trustformers_debug::WebSocketMessage::SystemStats { stats } => {
                        println!(
                            "   📊 Received system stats: {} data points collected",
                            stats.data_points_collected
                        );
                    },
                    _ => {
                        println!("   📨 Received other message type");
                    },
                }
            },
            Ok(Some(Err(_))) => {
                println!("   ❌ WebSocket error received");
                break;
            },
            Ok(None) => {
                println!("   📭 WebSocket stream ended");
                break;
            },
            Err(_) => {
                // Timeout, no more messages
                break;
            },
        }
    }

    // Stop the dashboard
    dashboard.stop();
    println!("⏹️  Dashboard stopped");

    Ok(())
}