// 传统 JavaScript 计算斐波那契数列
function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// 性能对比
console.time('JavaScript');
console.log(fibonacci(40));
console.timeEnd('JavaScript');

// Rust 版本（编译为 WASM）
#[no_mangle]
pub extern "C" fn fibonacci(n: i32) -> i32 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}

// WASM 模块加载和使用
async function loadWasm() {
    // 1. 获取 WASM 文件
    const wasmModule = await WebAssembly.instantiateStreaming(
        fetch('./fibonacci.wasm')
    );
    
    // 2. 调用 WASM 函数
    const { fibonacci } = wasmModule.instance.exports;
    
    console.time('WebAssembly');
    console.log(fibonacci(40));
    console.timeEnd('WebAssembly');
    
    return wasmModule;
}

// 性能测试
async function performanceTest() {
    const wasm = await loadWasm();
    const { fibonacci: wasmFib } = wasm.instance.exports;
    
    // JavaScript 版本
    const jsStart = performance.now();
    const jsResult = fibonacci(35);
    const jsTime = performance.now() - jsStart;
    
    // WebAssembly 版本
    const wasmStart = performance.now();
    const wasmResult = wasmFib(35);
    const wasmTime = performance.now() - wasmStart;
    
    console.log(`JavaScript: ${jsTime}ms, Result: ${jsResult}`);
    console.log(`WebAssembly: ${wasmTime}ms, Result: ${wasmResult}`);
    console.log(`Speedup: ${(jsTime / wasmTime).toFixed(2)}x`);
}

# 安装 Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 安装 wasm-pack
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

# 创建新项目
cargo new --lib wasm-demo
cd wasm-demo

# Cargo.toml
[package]
name = "wasm-demo"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"
js-sys = "0.3"
web-sys = "0.3"

[dependencies.web-sys]
version = "0.3"
features = [
  "console",
  "Document",
  "Element",
  "HtmlElement",
  "Window",
  "CanvasRenderingContext2d",
  "HtmlCanvasElement",
  "ImageData",
]

# 安装 Emscripten
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install latest
./emsdk activate latest
source ./emsdk_env.sh

// math_utils.c
#include <emscripten.h>
#include <math.h>

EMSCRIPTEN_KEEPALIVE
double calculate_distance(double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    return sqrt(dx * dx + dy * dy);
}

EMSCRIPTEN_KEEPALIVE
int is_prime(int n) {
    if (n <= 1) return 0;
    if (n <= 3) return 1;
    if (n % 2 == 0 || n % 3 == 0) return 0;
    
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return 0;
        }
    }
    return 1;
}

# 编译为 WASM
emcc math_utils.c -o math_utils.js \
    -s WASM=1 \
    -s EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
    -s ALLOW_MEMORY_GROWTH=1

// src/lib.rs
use wasm_bindgen::prelude::*;
use web_sys::console;

#[wasm_bindgen]
extern "C" {
    fn alert(s: &str);
}

#[wasm_bindgen]
pub struct ImageProcessor {
    width: u32,
    height: u32,
    data: Vec<u8>,
}

#[wasm_bindgen]
impl ImageProcessor {
    #[wasm_bindgen(constructor)]
    pub fn new(width: u32, height: u32) -> ImageProcessor {
        ImageProcessor {
            width,
            height,
            data: vec![0; (width * height * 4) as usize],
        }
    }
    
    #[wasm_bindgen]
    pub fn get_data_ptr(&self) -> *const u8 {
        self.data.as_ptr()
    }
    
    #[wasm_bindgen]
    pub fn apply_grayscale(&mut self, image_data: &[u8]) {
        for i in (0..image_data.len()).step_by(4) {
            let r = image_data[i] as f32;
            let g = image_data[i + 1] as f32;
            let b = image_data[i + 2] as f32;
            let a = image_data[i + 3];
            
            // 灰度转换公式
            let gray = (0.299 * r + 0.587 * g + 0.114 * b) as u8;
            
            self.data[i] = gray;
            self.data[i + 1] = gray;
            self.data[i + 2] = gray;
            self.data[i + 3] = a;
        }
    }
    
    #[wasm_bindgen]
    pub fn apply_blur(&mut self, radius: f32) {
        let mut temp_data = self.data.clone();
        let width = self.width as i32;
        let height = self.height as i32;
        
        for y in 0..height {
            for x in 0..width {
                let mut r_sum = 0.0;
                let mut g_sum = 0.0;
                let mut b_sum = 0.0;
                let mut count = 0.0;
                
                for dy in -(radius as i32)..=(radius as i32) {
                    for dx in -(radius as i32)..=(radius as i32) {
                        let nx = x + dx;
                        let ny = y + dy;
                        
                        if nx >= 0 && nx < width && ny >= 0 && ny < height {
                            let idx = ((ny * width + nx) * 4) as usize;
                            r_sum += temp_data[idx] as f32;
                            g_sum += temp_data[idx + 1] as f32;
                            b_sum += temp_data[idx + 2] as f32;
                            count += 1.0;
                        }
                    }
                }
                
                let idx = ((y * width + x) * 4) as usize;
                self.data[idx] = (r_sum / count) as u8;
                self.data[idx + 1] = (g_sum / count) as u8;
                self.data[idx + 2] = (b_sum / count) as u8;
            }
        }
    }
    
    #[wasm_bindgen]
    pub fn apply_edge_detection(&mut self) {
        let sobel_x = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
        let sobel_y = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
        
        let mut temp_data = self.data.clone();
        let width = self.width as i32;
        let height = self.height as i32;
        
        for y in 1..height - 1 {
            for x in 1..width - 1 {
                let mut gx = 0.0;
                let mut gy = 0.0;
                
                for i in 0..9 {
                    let dx = (i % 3) - 1;
                    let dy = (i / 3) - 1;
                    let nx = x + dx;
                    let ny = y + dy;
                    
                    let idx = ((ny * width + nx) * 4) as usize;
                    let gray = (temp_data[idx] as f32 + 
                               temp_data[idx + 1] as f32 + 
                               temp_data[idx + 2] as f32) / 3.0;
                    
                    gx += sobel_x[i] as f32 * gray;
                    gy += sobel_y[i] as f32 * gray;
                }
                
                let magnitude = (gx * gx + gy * gy).sqrt();
                let edge_value = magnitude.min(255.0) as u8;
                
                let idx = ((y * width + x) * 4) as usize;
                self.data[idx] = edge_value;
                self.data[idx + 1] = edge_value;
                self.data[idx + 2] = edge_value;
            }
        }
    }
}

// JavaScript 集成
class WasmImageProcessor {
    constructor() {
        this.wasmModule = null;
        this.processor = null;
    }
    
    async init() {
        // 加载 WASM 模块
        const wasm = await import('./pkg/wasm_demo.js');
        await wasm.default();
        this.wasmModule = wasm;
        return this;
    }
    
    processImage(canvas, operation, options = {}) {
        const ctx = canvas.getContext('2d');
        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
        
        // 创建 WASM 处理器
        this.processor = new this.wasmModule.ImageProcessor(
            canvas.width, 
            canvas.height
        );
        
        const startTime = performance.now();
        
        switch (operation) {
            case 'grayscale':
                this.processor.apply_grayscale(imageData.data);
                break;
            case 'blur':
                this.processor.apply_blur(options.radius || 2);
                break;
            case 'edge':
                this.processor.apply_edge_detection();
                break;
        }
        
        const endTime = performance.now();
        console.log(`WASM processing time: ${endTime - startTime}ms`);
        
        // 获取处理后的数据
        const dataPtr = this.processor.get_data_ptr();
        const processedData = new Uint8Array(
            this.wasmModule.memory.buffer,
            dataPtr,
            imageData.data.length
        );
        
        // 更新画布
        const newImageData = new ImageData(
            new Uint8ClampedArray(processedData),
            canvas.width,
            canvas.height
        );
        ctx.putImageData(newImageData, 0, 0);
    }
}

// 使用示例
async function setupImageProcessor() {
    const processor = await new WasmImageProcessor().init();
    const canvas = document.getElementById('imageCanvas');
    const fileInput = document.getElementById('fileInput');
    
    fileInput.addEventListener('change', (e) => {
        const file = e.target.files[0];
        if (file) {
            const reader = new FileReader();
            reader.onload = (event) => {
                const img = new Image();
                img.onload = () => {
                    canvas.width = img.width;
                    canvas.height = img.height;
                    const ctx = canvas.getContext('2d');
                    ctx.drawImage(img, 0, 0);
                };
                img.src = event.target.result;
            };
            reader.readAsDataURL(file);
        }
    });
    
    // 添加处理按钮
    document.getElementById('grayscaleBtn').addEventListener('click', () => {
        processor.processImage(canvas, 'grayscale');
    });
    
    document.getElementById('blurBtn').addEventListener('click', () => {
        processor.processImage(canvas, 'blur', { radius: 3 });
    });
    
    document.getElementById('edgeBtn').addEventListener('click', () => {
        processor.processImage(canvas, 'edge');
    });
}

// src/math.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct Matrix {
    rows: usize,
    cols: usize,
    data: Vec<f64>,
}

#[wasm_bindgen]
impl Matrix {
    #[wasm_bindgen(constructor)]
    pub fn new(rows: usize, cols: usize) -> Matrix {
        Matrix {
            rows,
            cols,
            data: vec![0.0; rows * cols],
        }
    }
    
    #[wasm_bindgen]
    pub fn from_array(rows: usize, cols: usize, data: &[f64]) -> Matrix {
        Matrix {
            rows,
            cols,
            data: data.to_vec(),
        }
    }
    
    #[wasm_bindgen]
    pub fn get(&self, row: usize, col: usize) -> f64 {
        self.data[row * self.cols + col]
    }
    
    #[wasm_bindgen]
    pub fn set(&mut self, row: usize, col: usize, value: f64) {
        self.data[row * self.cols + col] = value;
    }
    
    #[wasm_bindgen]
    pub fn multiply(&self, other: &Matrix) -> Option<Matrix> {
        if self.cols != other.rows {
            return None;
        }
        
        let mut result = Matrix::new(self.rows, other.cols);
        
        for i in 0..self.rows {
            for j in 0..other.cols {
                let mut sum = 0.0;
                for k in 0..self.cols {
                    sum += self.get(i, k) * other.get(k, j);
                }
                result.set(i, j, sum);
            }
        }
        
        Some(result)
    }
    
    #[wasm_bindgen]
    pub fn transpose(&self) -> Matrix {
        let mut result = Matrix::new(self.cols, self.rows);
        
        for i in 0..self.rows {
            for j in 0..self.cols {
                result.set(j, i, self.get(i, j));
            }
        }
        
        result
    }
    
    #[wasm_bindgen]
    pub fn determinant(&self) -> Option<f64> {
        if self.rows != self.cols {
            return None;
        }
        
        if self.rows == 1 {
            return Some(self.get(0, 0));
        }
        
        if self.rows == 2 {
            return Some(
                self.get(0, 0) * self.get(1, 1) - 
                self.get(0, 1) * self.get(1, 0)
            );
        }
        
        // 使用 LU 分解计算行列式
        let mut matrix = self.data.clone();
        let n = self.rows;
        let mut det = 1.0;
        
        for i in 0..n {
            // 寻找主元
            let mut max_row = i;
            for k in i + 1..n {
                if matrix[k * n + i].abs() > matrix[max_row * n + i].abs() {
                    max_row = k;
                }
            }
            
            if max_row != i {
                // 交换行
                for j in 0..n {
                    matrix.swap(i * n + j, max_row * n + j);
                }
                det = -det;
            }
            
            if matrix[i * n + i].abs() < 1e-10 {
                return Some(0.0);
            }
            
            det *= matrix[i * n + i];
            
            // 消元
            for k in i + 1..n {
                let factor = matrix[k * n + i] / matrix[i * n + i];
                for j in i..n {
                    matrix[k * n + j] -= factor * matrix[i * n + j];
                }
            }
        }
        
        Some(det)
    }
    
    #[wasm_bindgen]
    pub fn to_array(&self) -> Vec<f64> {
        self.data.clone()
    }
}

// 向量运算
#[wasm_bindgen]
pub fn dot_product(a: &[f64], b: &[f64]) -> Option<f64> {
    if a.len() != b.len() {
        return None;
    }
    
    let mut result = 0.0;
    for i in 0..a.len() {
        result += a[i] * b[i];
    }
    
    Some(result)
}

#[wasm_bindgen]
pub fn cross_product_3d(a: &[f64], b: &[f64]) -> Option<Vec<f64>> {
    if a.len() != 3 || b.len() != 3 {
        return None;
    }
    
    Some(vec![
        a[1] * b[2] - a[2] * b[1],
        a[2] * b[0] - a[0] * b[2],
        a[0] * b[1] - a[1] * b[0],
    ])
}

// 快速傅里叶变换
#[wasm_bindgen]
pub fn fft(real: &mut [f64], imag: &mut [f64]) -> bool {
    let n = real.len();
    if n != imag.len() || !n.is_power_of_two() {
        return false;
    }
    
    // 位反转
    let mut j = 0;
    for i in 1..n {
        let mut bit = n >> 1;
        while j & bit != 0 {
            j ^= bit;
            bit >>= 1;
        }
        j ^= bit;
        
        if i < j {
            real.swap(i, j);
            imag.swap(i, j);
        }
    }
    
    // FFT 计算
    let mut length = 2;
    while length <= n {
        let angle = -2.0 * std::f64::consts::PI / length as f64;
        let wlen_real = angle.cos();
        let wlen_imag = angle.sin();
        
        let mut i = 0;
        while i < n {
            let mut w_real = 1.0;
            let mut w_imag = 0.0;
            
            for j in 0..length / 2 {
                let u_real = real[i + j];
                let u_imag = imag[i + j];
                let v_real = real[i + j + length / 2] * w_real - 
                            imag[i + j + length / 2] * w_imag;
                let v_imag = real[i + j + length / 2] * w_imag + 
                            imag[i + j + length / 2] * w_real;
                
                real[i + j] = u_real + v_real;
                imag[i + j] = u_imag + v_imag;
                real[i + j + length / 2] = u_real - v_real;
                imag[i + j + length / 2] = u_imag - v_imag;
                
                let temp_real = w_real * wlen_real - w_imag * wlen_imag;
                w_imag = w_real * wlen_imag + w_imag * wlen_real;
                w_real = temp_real;
            }
            
            i += length;
        }
        
        length <<= 1;
    }
    
    true
}

// src/game.rs
use wasm_bindgen::prelude::*;
use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};

#[wasm_bindgen]
pub struct GameEngine {
    width: u32,
    height: u32,
    entities: Vec<Entity>,
    last_time: f64,
}

#[wasm_bindgen]
pub struct Entity {
    x: f64,
    y: f64,
    vx: f64,
    vy: f64,
    radius: f64,
    color: String,
}

#[wasm_bindgen]
impl Entity {
    #[wasm_bindgen(constructor)]
    pub fn new(x: f64, y: f64, vx: f64, vy: f64, radius: f64, color: String) -> Entity {
        Entity { x, y, vx, vy, radius, color }
    }
    
    #[wasm_bindgen(getter)]
    pub fn x(&self) -> f64 { self.x }
    
    #[wasm_bindgen(getter)]
    pub fn y(&self) -> f64 { self.y }
    
    #[wasm_bindgen(getter)]
    pub fn radius(&self) -> f64 { self.radius }
    
    #[wasm_bindgen(getter)]
    pub fn color(&self) -> String { self.color.clone() }
}

#[wasm_bindgen]
impl GameEngine {
    #[wasm_bindgen(constructor)]
    pub fn new(width: u32, height: u32) -> GameEngine {
        GameEngine {
            width,
            height,
            entities: Vec::new(),
            last_time: 0.0,
        }
    }
    
    #[wasm_bindgen]
    pub fn add_entity(&mut self, entity: Entity) {
        self.entities.push(entity);
    }
    
    #[wasm_bindgen]
    pub fn update(&mut self, current_time: f64) {
        let dt = if self.last_time == 0.0 {
            0.016 // 假设 60 FPS
        } else {
            (current_time - self.last_time) / 1000.0
        };
        self.last_time = current_time;
        
        // 更新所有实体
        for entity in &mut self.entities {
            // 更新位置
            entity.x += entity.vx * dt;
            entity.y += entity.vy * dt;
            
            // 边界碰撞检测
            if entity.x - entity.radius <= 0.0 || entity.x + entity.radius >= self.width as f64 {
                entity.vx = -entity.vx;
                entity.x = entity.x.max(entity.radius).min(self.width as f64 - entity.radius);
            }
            
            if entity.y - entity.radius <= 0.0 || entity.y + entity.radius >= self.height as f64 {
                entity.vy = -entity.vy;
                entity.y = entity.y.max(entity.radius).min(self.height as f64 - entity.radius);
            }
        }
        
        // 实体间碰撞检测
        for i in 0..self.entities.len() {
            for j in i + 1..self.entities.len() {
                let (left, right) = self.entities.split_at_mut(j);
                let entity1 = &mut left[i];
                let entity2 = &mut right[0];
                
                let dx = entity2.x - entity1.x;
                let dy = entity2.y - entity1.y;
                let distance = (dx * dx + dy * dy).sqrt();
                let min_distance = entity1.radius + entity2.radius;
                
                if distance < min_distance {
                    // 简单的弹性碰撞
                    let overlap = min_distance - distance;
                    let separation_x = dx / distance * overlap * 0.5;
                    let separation_y = dy / distance * overlap * 0.5;
                    
                    entity1.x -= separation_x;
                    entity1.y -= separation_y;
                    entity2.x += separation_x;
                    entity2.y += separation_y;
                    
                    // 交换速度（简化版）
                    let temp_vx = entity1.vx;
                    let temp_vy = entity1.vy;
                    entity1.vx = entity2.vx;
                    entity1.vy = entity2.vy;
                    entity2.vx = temp_vx;
                    entity2.vy = temp_vy;
                }
            }
        }
    }
    
    #[wasm_bindgen]
    pub fn get_entities(&self) -> Vec<JsValue> {
        self.entities.iter().map(|entity| {
            let obj = js_sys::Object::new();
            js_sys::Reflect::set(&obj, &"x".into(), &entity.x.into()).unwrap();
            js_sys::Reflect::set(&obj, &"y".into(), &entity.y.into()).unwrap();
            js_sys::Reflect::set(&obj, &"radius".into(), &entity.radius.into()).unwrap();
            js_sys::Reflect::set(&obj, &"color".into(), &entity.color.clone().into()).unwrap();
            obj.into()
        }).collect()
    }
    
    #[wasm_bindgen]
    pub fn get_entity_count(&self) -> usize {
        self.entities.len()
    }
    
    #[wasm_bindgen]
    pub fn clear_entities(&mut self) {
        self.entities.clear();
    }
}

// JavaScript 游戏循环
class WasmGame {
    constructor(canvas) {
        this.canvas = canvas;
        this.ctx = canvas.getContext('2d');
        this.engine = null;
        this.animationId = null;
        this.isRunning = false;
    }
    
    async init() {
        const wasm = await import('./pkg/wasm_demo.js');
        await wasm.default();
        
        this.engine = new wasm.GameEngine(this.canvas.width, this.canvas.height);
        
        // 添加一些实体
        for (let i = 0; i < 50; i++) {
            const entity = new wasm.Entity(
                Math.random() * this.canvas.width,
                Math.random() * this.canvas.height,
                (Math.random() - 0.5) * 200,
                (Math.random() - 0.5) * 200,
                5 + Math.random() * 15,
                `hsl(${Math.random() * 360}, 70%, 50%)`
            );
            this.engine.add_entity(entity);
        }
        
        return this;
    }
    
    start() {
        if (this.isRunning) return;
        this.isRunning = true;
        this.gameLoop();
    }
    
    stop() {
        this.isRunning = false;
        if (this.animationId) {
            cancelAnimationFrame(this.animationId);
        }
    }
    
    gameLoop = (timestamp) => {
        if (!this.isRunning) return;
        
        // 更新游戏状态
        this.engine.update(timestamp);
        
        // 渲染
        this.render();
        
        // 继续循环
        this.animationId = requestAnimationFrame(this.gameLoop);
    }
    
    render() {
        // 清空画布
        this.ctx.fillStyle = '#000';
        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
        
        // 渲染所有实体
        const entities = this.engine.get_entities();
        entities.forEach(entity => {
            this.ctx.beginPath();
            this.ctx.arc(entity.x, entity.y, entity.radius, 0, Math.PI * 2);
            this.ctx.fillStyle = entity.color;
            this.ctx.fill();
        });
        
        // 显示性能信息
        this.ctx.fillStyle = '#fff';
        this.ctx.font = '16px Arial';
        this.ctx.fillText(`Entities: ${this.engine.get_entity_count()}`, 10, 30);
    }
}

// 使用示例
async function startGame() {
    const canvas = document.getElementById('gameCanvas');
    const game = await new WasmGame(canvas).init();
    
    document.getElementById('startBtn').addEventListener('click', () => {
        game.start();
    });
    
    document.getElementById('stopBtn').addEventListener('click', () => {
        game.stop();
    });
    
    document.getElementById('resetBtn').addEventListener('click', async () => {
        game.stop();
        await game.init();
    });
}

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct MemoryPool {
    pool: Vec<Vec<u8>>,
    available: Vec<usize>,
}

#[wasm_bindgen]
impl MemoryPool {
    #[wasm_bindgen(constructor)]
    pub fn new(initial_size: usize, block_size: usize) -> MemoryPool {
        let mut pool = Vec::with_capacity(initial_size);
        let mut available = Vec::with_capacity(initial_size);
        
        for i in 0..initial_size {
            pool.push(vec![0; block_size]);
            available.push(i);
        }
        
        MemoryPool { pool, available }
    }
    
    #[wasm_bindgen]
    pub fn allocate(&mut self) -> Option<usize> {
        self.available.pop()
    }
    
    #[wasm_bindgen]
    pub fn deallocate(&mut self, index: usize) {
        if index < self.pool.len() {
            self.available.push(index);
        }
    }
    
    #[wasm_bindgen]
    pub fn get_buffer(&mut self, index: usize) -> Option<*mut u8> {
        if index < self.pool.len() {
            Some(self.pool[index].as_mut_ptr())
        } else {
            None
        }
    }
}

// 高效的数据传输
class WasmDataTransfer {
    constructor(wasmModule) {
        this.wasm = wasmModule;
        this.sharedBuffer = null;
        this.sharedView = null;
    }
    
    // 创建共享内存缓冲区
    createSharedBuffer(size) {
        const ptr = this.wasm.allocate_buffer(size);
        this.sharedBuffer = new Uint8Array(
            this.wasm.memory.buffer,
            ptr,
            size
        );
        this.sharedView = new DataView(this.sharedBuffer.buffer, ptr, size);
        return ptr;
    }
    
    // 批量传输数据
    transferBatch(data) {
        if (!this.sharedBuffer || this.sharedBuffer.length < data.length) {
            this.createSharedBuffer(data.length);
        }
        
        // 直接写入共享内存
        this.sharedBuffer.set(data);
        
        // 通知 WASM 处理数据
        return this.wasm.process_shared_data(data.length);
    }
    
    // 零拷贝数据访问
    getResultView(size) {
        const ptr = this.wasm.get_result_buffer();
        return new Uint8Array(this.wasm.memory.buffer, ptr, size);
    }
}

// 调试宏
#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_namespace = console)]
    fn log(s: &str);
    
    #[wasm_bindgen(js_namespace = console, js_name = log)]
    fn log_u32(a: u32);
    
    #[wasm_bindgen(js_namespace = console, js_name = log)]
    fn log_many(a: &str, b: &str);
}

macro_rules! console_log {
    ($($t:tt)*) => (log(&format_args!($($t)*).to_string()))
}

#[wasm_bindgen]
pub fn debug_function(input: &[u8]) -> Vec<u8> {
    console_log!("Processing {} bytes", input.len());
    
    let start = web_sys::window()
        .unwrap()
        .performance()
        .unwrap()
        .now();
    
    // 处理逻辑
    let result = process_data(input);
    
    let end = web_sys::window()
        .unwrap()
        .performance()
        .unwrap()
        .now();
    
    console_log!("Processing took {}ms", end - start);
    
    result
}

// 性能基准测试
class WasmBenchmark {
    constructor() {
        this.results = new Map();
    }
    
    async benchmark(name, wasmFn, jsFn, testData, iterations = 1000) {
        // 预热
        for (let i = 0; i < 10; i++) {
            wasmFn(testData);
            jsFn(testData);
        }
        
        // WASM 测试
        const wasmStart = performance.now();
        for (let i = 0; i < iterations; i++) {
            wasmFn(testData);
        }
        const wasmTime = performance.now() - wasmStart;
        
        // JavaScript 测试
        const jsStart = performance.now();
        for (let i = 0; i < iterations; i++) {
            jsFn(testData);
        }
        const jsTime = performance.now() - jsStart;
        
        const result = {
            wasmTime,
            jsTime,
            speedup: jsTime / wasmTime,
            iterations
        };
        
        this.results.set(name, result);
        
        console.log(`${name} Benchmark:`);
        console.log(`  WASM: ${wasmTime.toFixed(2)}ms`);
        console.log(`  JS: ${jsTime.toFixed(2)}ms`);
        console.log(`  Speedup: ${result.speedup.toFixed(2)}x`);
        
        return result;
    }
    
    generateReport() {
        const report = Array.from(this.results.entries()).map(([name, result]) => ({
            name,
            ...result
        }));
        
        console.table(report);
        return report;
    }
}

// 使用示例
async function runBenchmarks() {
    const wasm = await loadWasmModule();
    const benchmark = new WasmBenchmark();
    
    // 数学计算测试
    const mathData = new Float64Array(10000).map(() => Math.random());
    await benchmark.benchmark(
        'Matrix Multiplication',
        (data) => wasm.matrix_multiply(data),
        (data) => jsMatrixMultiply(data),
        mathData
    );
    
    // 图像处理测试
    const imageData = new Uint8Array(1920 * 1080 * 4).map(() => Math.floor(Math.random() * 256));
    await benchmark.benchmark(
        'Image Blur',
        (data) => wasm.apply_blur(data),
        (data) => jsApplyBlur(data),
        imageData,
        100
    );
    
    benchmark.generateReport();
}