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

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

[dependencies]
wasm-bindgen = "0.2"
js-sys = "0.3"
web-sys = "0.3"
wee_alloc = "0.4"
console_error_panic_hook = "0.1"

[dependencies.web-sys]
version = "0.3"
features = [
  "console",
  "Memory",
  "WebAssembly",
]

// src/lib.rs - 内存管理基础
use wasm_bindgen::prelude::*;
use std::alloc::{alloc, dealloc, Layout};
use std::ptr;

// 使用wee_alloc作为全局分配器
#[global_allocator]
static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;

// 设置panic hook
#[wasm_bindgen(start)]
pub fn main() {
    console_error_panic_hook::set_once();
}

// 内存信息结构
#[wasm_bindgen]
pub struct MemoryInfo {
    total_pages: u32,
    used_bytes: usize,
    free_bytes: usize,
}

#[wasm_bindgen]
impl MemoryInfo {
    #[wasm_bindgen(getter)]
    pub fn total_pages(&self) -> u32 {
        self.total_pages
    }
    
    #[wasm_bindgen(getter)]
    pub fn used_bytes(&self) -> usize {
        self.used_bytes
    }
    
    #[wasm_bindgen(getter)]
    pub fn free_bytes(&self) -> usize {
        self.free_bytes
    }
}

// 获取内存信息
#[wasm_bindgen]
pub fn get_memory_info() -> MemoryInfo {
    let memory = wasm_bindgen::memory();
    let buffer = memory.buffer();
    let total_bytes = buffer.byte_length() as usize;
    let total_pages = (total_bytes / 65536) as u32; // 64KB per page
    
    MemoryInfo {
        total_pages,
        used_bytes: total_bytes, // 简化示例
        free_bytes: 0,
    }
}

// 直接内存操作
#[wasm_bindgen]
pub fn allocate_memory(size: usize) -> *mut u8 {
    let layout = Layout::from_size_align(size, 1).unwrap();
    unsafe { alloc(layout) }
}

#[wasm_bindgen]
pub fn deallocate_memory(ptr: *mut u8, size: usize) {
    let layout = Layout::from_size_align(size, 1).unwrap();
    unsafe { dealloc(ptr, layout) };
}

// 内存拷贝操作
#[wasm_bindgen]
pub fn copy_memory(src: *const u8, dst: *mut u8, len: usize) {
    unsafe {
        ptr::copy_nonoverlapping(src, dst, len);
    }
}

// 内存填充操作
#[wasm_bindgen]
pub fn fill_memory(ptr: *mut u8, value: u8, len: usize) {
    unsafe {
        ptr::write_bytes(ptr, value, len);
    }
}

// src/data_transfer.rs - 数据传输优化
use wasm_bindgen::prelude::*;
use js_sys::{Array, Uint8Array, Float32Array, Float64Array};

// 字节数组处理
#[wasm_bindgen]
pub struct ByteBuffer {
    data: Vec<u8>,
}

#[wasm_bindgen]
impl ByteBuffer {
    #[wasm_bindgen(constructor)]
    pub fn new(capacity: usize) -> ByteBuffer {
        ByteBuffer {
            data: Vec::with_capacity(capacity),
        }
    }
    
    // 获取内部数据指针
    #[wasm_bindgen]
    pub fn as_ptr(&self) -> *const u8 {
        self.data.as_ptr()
    }
    
    // 获取数据长度
    #[wasm_bindgen]
    pub fn len(&self) -> usize {
        self.data.len()
    }
    
    // 从JavaScript接收数据
    #[wasm_bindgen]
    pub fn from_js_array(&mut self, array: &Uint8Array) {
        self.data.clear();
        self.data.reserve(array.length() as usize);
        
        // 直接从JavaScript数组复制数据
        array.copy_to(&mut self.data);
    }
    
    // 向JavaScript返回数据
    #[wasm_bindgen]
    pub fn to_js_array(&self) -> Uint8Array {
        unsafe {
            Uint8Array::view(&self.data)
        }
    }
    
    // 追加数据
    #[wasm_bindgen]
    pub fn append(&mut self, data: &[u8]) {
        self.data.extend_from_slice(data);
    }
    
    // 清空缓冲区
    #[wasm_bindgen]
    pub fn clear(&mut self) {
        self.data.clear();
    }
}

// 浮点数组处理
#[wasm_bindgen]
pub struct FloatBuffer {
    data: Vec<f32>,
}

#[wasm_bindgen]
impl FloatBuffer {
    #[wasm_bindgen(constructor)]
    pub fn new(capacity: usize) -> FloatBuffer {
        FloatBuffer {
            data: Vec::with_capacity(capacity),
        }
    }
    
    #[wasm_bindgen]
    pub fn from_js_array(&mut self, array: &Float32Array) {
        self.data.clear();
        self.data.resize(array.length() as usize, 0.0);
        array.copy_to(&mut self.data);
    }
    
    #[wasm_bindgen]
    pub fn to_js_array(&self) -> Float32Array {
        unsafe {
            Float32Array::view(&self.data)
        }
    }
    
    #[wasm_bindgen]
    pub fn process_data(&mut self) {
        // 对数据进行处理
        for value in &mut self.data {
            *value = value.sin().cos().tan();
        }
    }
    
    #[wasm_bindgen]
    pub fn sum(&self) -> f32 {
        self.data.iter().sum()
    }
}

// 零拷贝字符串处理
#[wasm_bindgen]
pub fn process_string_zero_copy(input: &str) -> String {
    // 直接在原字符串上操作，避免不必要的拷贝
    input.chars()
        .map(|c| if c.is_ascii_lowercase() {
            c.to_ascii_uppercase()
        } else {
            c.to_ascii_lowercase()
        })
        .collect()
}

// 大数据块传输
#[wasm_bindgen]
pub struct DataChunk {
    data: Vec<u8>,
    offset: usize,
    total_size: usize,
}

#[wasm_bindgen]
impl DataChunk {
    #[wasm_bindgen(constructor)]
    pub fn new(total_size: usize) -> DataChunk {
        DataChunk {
            data: Vec::with_capacity(total_size),
            offset: 0,
            total_size,
        }
    }
    
    #[wasm_bindgen]
    pub fn append_chunk(&mut self, chunk: &[u8]) -> bool {
        if self.offset + chunk.len() <= self.total_size {
            self.data.extend_from_slice(chunk);
            self.offset += chunk.len();
            true
        } else {
            false
        }
    }
    
    #[wasm_bindgen]
    pub fn is_complete(&self) -> bool {
        self.offset == self.total_size
    }
    
    #[wasm_bindgen]
    pub fn get_progress(&self) -> f32 {
        self.offset as f32 / self.total_size as f32
    }
    
    #[wasm_bindgen]
    pub fn get_data(&self) -> Uint8Array {
        unsafe {
            Uint8Array::view(&self.data)
        }
    }
}

// src/complex_data.rs - 复杂数据结构处理
use wasm_bindgen::prelude::*;
use serde::{Serialize, Deserialize};

// 使用serde进行序列化
#[derive(Serialize, Deserialize)]
#[wasm_bindgen]
pub struct Person {
    name: String,
    age: u32,
    email: String,
}

#[wasm_bindgen]
impl Person {
    #[wasm_bindgen(constructor)]
    pub fn new(name: String, age: u32, email: String) -> Person {
        Person { name, age, email }
    }
    
    #[wasm_bindgen(getter)]
    pub fn name(&self) -> String {
        self.name.clone()
    }
    
    #[wasm_bindgen(getter)]
    pub fn age(&self) -> u32 {
        self.age
    }
    
    #[wasm_bindgen(getter)]
    pub fn email(&self) -> String {
        self.email.clone()
    }
    
    // 序列化为JSON
    #[wasm_bindgen]
    pub fn to_json(&self) -> Result<String, JsValue> {
        serde_json::to_string(self)
            .map_err(|e| JsValue::from_str(&e.to_string()))
    }
    
    // 从JSON反序列化
    #[wasm_bindgen]
    pub fn from_json(json: &str) -> Result<Person, JsValue> {
        serde_json::from_str(json)
            .map_err(|e| JsValue::from_str(&e.to_string()))
    }
}

// 复杂嵌套结构
#[derive(Serialize, Deserialize)]
#[wasm_bindgen]
pub struct Company {
    name: String,
    employees: Vec<Person>,
    founded_year: u32,
}

#[wasm_bindgen]
impl Company {
    #[wasm_bindgen(constructor)]
    pub fn new(name: String, founded_year: u32) -> Company {
        Company {
            name,
            employees: Vec::new(),
            founded_year,
        }
    }
    
    #[wasm_bindgen]
    pub fn add_employee(&mut self, person: Person) {
        self.employees.push(person);
    }
    
    #[wasm_bindgen]
    pub fn employee_count(&self) -> usize {
        self.employees.len()
    }
    
    #[wasm_bindgen]
    pub fn to_json(&self) -> Result<String, JsValue> {
        serde_json::to_string(self)
            .map_err(|e| JsValue::from_str(&e.to_string()))
    }
    
    #[wasm_bindgen]
    pub fn from_json(json: &str) -> Result<Company, JsValue> {
        serde_json::from_str(json)
            .map_err(|e| JsValue::from_str(&e.to_string()))
    }
}

// 二进制数据结构
#[wasm_bindgen]
pub struct BinaryData {
    header: [u8; 16],
    payload: Vec<u8>,
    checksum: u32,
}

#[wasm_bindgen]
impl BinaryData {
    #[wasm_bindgen(constructor)]
    pub fn new() -> BinaryData {
        BinaryData {
            header: [0; 16],
            payload: Vec::new(),
            checksum: 0,
        }
    }
    
    #[wasm_bindgen]
    pub fn set_header(&mut self, data: &[u8]) {
        if data.len() == 16 {
            self.header.copy_from_slice(data);
        }
    }
    
    #[wasm_bindgen]
    pub fn set_payload(&mut self, data: &[u8]) {
        self.payload = data.to_vec();
        self.calculate_checksum();
    }
    
    fn calculate_checksum(&mut self) {
        self.checksum = self.header.iter()
            .chain(self.payload.iter())
            .fold(0u32, |acc, &byte| acc.wrapping_add(byte as u32));
    }
    
    #[wasm_bindgen]
    pub fn serialize(&self) -> Vec<u8> {
        let mut result = Vec::new();
        result.extend_from_slice(&self.header);
        result.extend_from_slice(&(self.payload.len() as u32).to_le_bytes());
        result.extend_from_slice(&self.payload);
        result.extend_from_slice(&self.checksum.to_le_bytes());
        result
    }
    
    #[wasm_bindgen]
    pub fn deserialize(data: &[u8]) -> Result<BinaryData, JsValue> {
        if data.len() < 24 { // 16 + 4 + 4 minimum
            return Err(JsValue::from_str("Data too short"));
        }
        
        let mut binary_data = BinaryData::new();
        
        // 读取header
        binary_data.header.copy_from_slice(&data[0..16]);
        
        // 读取payload长度
        let payload_len = u32::from_le_bytes([
            data[16], data[17], data[18], data[19]
        ]) as usize;
        
        if data.len() < 24 + payload_len {
            return Err(JsValue::from_str("Invalid payload length"));
        }
        
        // 读取payload
        binary_data.payload = data[20..20+payload_len].to_vec();
        
        // 读取checksum
        binary_data.checksum = u32::from_le_bytes([
            data[20+payload_len], 
            data[21+payload_len], 
            data[22+payload_len], 
            data[23+payload_len]
        ]);
        
        // 验证checksum
        let mut expected_checksum = 0u32;
        for &byte in &binary_data.header {
            expected_checksum = expected_checksum.wrapping_add(byte as u32);
        }
        for &byte in &binary_data.payload {
            expected_checksum = expected_checksum.wrapping_add(byte as u32);
        }
        
        if expected_checksum != binary_data.checksum {
            return Err(JsValue::from_str("Checksum mismatch"));
        }
        
        Ok(binary_data)
    }
    
    #[wasm_bindgen]
    pub fn get_header(&self) -> Vec<u8> {
        self.header.to_vec()
    }
    
    #[wasm_bindgen]
    pub fn get_payload(&self) -> Vec<u8> {
        self.payload.clone()
    }
    
    #[wasm_bindgen]
    pub fn get_checksum(&self) -> u32 {
        self.checksum
    }
}

// src/memory_pool.rs - 内存池实现
use wasm_bindgen::prelude::*;
use std::collections::VecDeque;

// 通用内存池
#[wasm_bindgen]
pub struct MemoryPool {
    pools: Vec<VecDeque<Vec<u8>>>,
    sizes: Vec<usize>,
}

#[wasm_bindgen]
impl MemoryPool {
    #[wasm_bindgen(constructor)]
    pub fn new() -> MemoryPool {
        let sizes = vec![64, 256, 1024, 4096, 16384, 65536];
        let mut pools = Vec::new();
        
        for _ in &sizes {
            pools.push(VecDeque::new());
        }
        
        MemoryPool { pools, sizes }
    }
    
    #[wasm_bindgen]
    pub fn get_buffer(&mut self, size: usize) -> Option<Vec<u8>> {
        // 找到合适的池
        for (i, &pool_size) in self.sizes.iter().enumerate() {
            if size <= pool_size {
                if let Some(mut buffer) = self.pools[i].pop_front() {
                    buffer.clear();
                    buffer.reserve(size);
                    return Some(buffer);
                } else {
                    // 创建新的缓冲区
                    return Some(Vec::with_capacity(pool_size));
                }
            }
        }
        
        // 如果没有合适的池，创建精确大小的缓冲区
        Some(Vec::with_capacity(size))
    }
    
    #[wasm_bindgen]
    pub fn return_buffer(&mut self, buffer: Vec<u8>) {
        let capacity = buffer.capacity();
        
        // 找到合适的池
        for (i, &pool_size) in self.sizes.iter().enumerate() {
            if capacity == pool_size && self.pools[i].len() < 10 {
                self.pools[i].push_back(buffer);
                return;
            }
        }
        
        // 如果没有合适的池或池已满，直接丢弃
    }
    
    #[wasm_bindgen]
    pub fn get_pool_stats(&self) -> Vec<usize> {
        self.pools.iter().map(|pool| pool.len()).collect()
    }
}

// 对象池示例
#[wasm_bindgen]
pub struct Point3D {
    pub x: f64,
    pub y: f64,
    pub z: f64,
}

#[wasm_bindgen]
impl Point3D {
    #[wasm_bindgen(constructor)]
    pub fn new(x: f64, y: f64, z: f64) -> Point3D {
        Point3D { x, y, z }
    }
    
    #[wasm_bindgen]
    pub fn reset(&mut self, x: f64, y: f64, z: f64) {
        self.x = x;
        self.y = y;
        self.z = z;
    }
    
    #[wasm_bindgen]
    pub fn distance_to(&self, other: &Point3D) -> f64 {
        let dx = self.x - other.x;
        let dy = self.y - other.y;
        let dz = self.z - other.z;
        (dx * dx + dy * dy + dz * dz).sqrt()
    }
}

#[wasm_bindgen]
pub struct Point3DPool {
    pool: VecDeque<Point3D>,
    max_size: usize,
}

#[wasm_bindgen]
impl Point3DPool {
    #[wasm_bindgen(constructor)]
    pub fn new(max_size: usize) -> Point3DPool {
        Point3DPool {
            pool: VecDeque::new(),
            max_size,
        }
    }
    
    #[wasm_bindgen]
    pub fn get_point(&mut self, x: f64, y: f64, z: f64) -> Point3D {
        if let Some(mut point) = self.pool.pop_front() {
            point.reset(x, y, z);
            point
        } else {
            Point3D::new(x, y, z)
        }
    }
    
    #[wasm_bindgen]
    pub fn return_point(&mut self, point: Point3D) {
        if self.pool.len() < self.max_size {
            self.pool.push_back(point);
        }
    }
    
    #[wasm_bindgen]
    pub fn pool_size(&self) -> usize {
        self.pool.len()
    }
}

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Rust-Wasm Memory Management Demo</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .demo-section { margin: 20px 0; padding: 15px; border: 1px solid #ddd; }
        button { padding: 10px; margin: 5px; }
        .result { background: #f0f0f0; padding: 10px; margin: 10px 0; }
    </style>
</head>
<body>
    <h1>Rust-Wasm Memory Management Demo</h1>
    
    <div class="demo-section">
        <h2>内存信息</h2>
        <button onclick="showMemoryInfo()">获取内存信息</button>
        <div id="memory-info" class="result"></div>
    </div>
    
    <div class="demo-section">
        <h2>数据传输测试</h2>
        <button onclick="testByteBuffer()">字节缓冲区测试</button>
        <button onclick="testFloatBuffer()">浮点缓冲区测试</button>
        <div id="transfer-result" class="result"></div>
    </div>
    
    <div class="demo-section">
        <h2>复杂数据结构</h2>
        <button onclick="testComplexData()">测试复杂数据</button>
        <button onclick="testBinaryData()">测试二进制数据</button>
        <div id="complex-result" class="result"></div>
    </div>
    
    <div class="demo-section">
        <h2>内存池测试</h2>
        <button onclick="testMemoryPool()">内存池测试</button>
        <button onclick="testObjectPool()">对象池测试</button>
        <div id="pool-result" class="result"></div>
    </div>

    <script type="module">
        import init, { 
            get_memory_info,
            ByteBuffer,
            FloatBuffer,
            Person,
            Company,
            BinaryData,
            MemoryPool,
            Point3DPool
        } from './pkg/wasm_memory_demo.js';

        let memoryPool;
        let objectPool;

        async function run() {
            await init();
            
            memoryPool = new MemoryPool();
            objectPool = new Point3DPool(100);
            
            console.log('Memory management demo loaded!');
        }

        window.showMemoryInfo = function() {
            const info = get_memory_info();
            document.getElementById('memory-info').innerHTML = `
                <strong>内存信息:</strong><br>
                总页数: ${info.total_pages}<br>
                已使用字节: ${info.used_bytes}<br>
                空闲字节: ${info.free_bytes}
            `;
        };

        window.testByteBuffer = function() {
            const buffer = new ByteBuffer(1024);
            
            // 创建测试数据
            const testData = new Uint8Array(256);
            for (let i = 0; i < 256; i++) {
                testData[i] = i;
            }
            
            // 传输数据到Rust
            buffer.from_js_array(testData);
            
            // 从Rust获取数据
            const result = buffer.to_js_array();
            
            document.getElementById('transfer-result').innerHTML = `
                <strong>字节缓冲区测试:</strong><br>
                原始数据长度: ${testData.length}<br>
                传输后长度: ${result.length}<br>
                数据一致性: ${testData.every((val, i) => val === result[i]) ? '✓' : '✗'}
            `;
        };

        window.testFloatBuffer = function() {
            const buffer = new FloatBuffer(1000);
            
            // 创建测试数据
            const testData = new Float32Array(1000);
            for (let i = 0; i < 1000; i++) {
                testData[i] = Math.sin(i * 0.01);
            }
            
            const start = performance.now();
            
            // 传输数据并处理
            buffer.from_js_array(testData);
            buffer.process_data();
            const result = buffer.to_js_array();
            const sum = buffer.sum();
            
            const end = performance.now();
            
            document.getElementById('transfer-result').innerHTML += `
                <br><strong>浮点缓冲区测试:</strong><br>
                处理时间: ${(end - start).toFixed(2)}ms<br>
                数据总和: ${sum.toFixed(6)}<br>
                结果长度: ${result.length}
            `;
        };

        window.testComplexData = function() {
            // 创建复杂数据结构
            const person1 = new Person("Alice", 30, "alice@example.com");
            const person2 = new Person("Bob", 25, "bob@example.com");
            
            const company = new Company("Tech Corp", 2020);
            company.add_employee(person1);
            company.add_employee(person2);
            
            // 序列化和反序列化
            const json = company.to_json();
            const restored = Company.from_json(json);
            
            document.getElementById('complex-result').innerHTML = `
                <strong>复杂数据结构测试:</strong><br>
                员工数量: ${company.employee_count()}<br>
                JSON长度: ${json.length}<br>
                反序列化成功: ${restored ? '✓' : '✗'}
            `;
        };

        window.testBinaryData = function() {
            const binaryData = new BinaryData();
            
            // 设置header和payload
            const header = new Uint8Array(16);
            header.fill(0xAA);
            
            const payload = new Uint8Array(100);
            for (let i = 0; i < 100; i++) {
                payload[i] = i % 256;
            }
            
            binaryData.set_header(header);
            binaryData.set_payload(payload);
            
            // 序列化和反序列化
            const serialized = binaryData.serialize();
            const restored = BinaryData.deserialize(serialized);
            
            document.getElementById('complex-result').innerHTML += `
                <br><strong>二进制数据测试:</strong><br>
                序列化长度: ${serialized.length}<br>
                校验和: 0x${binaryData.get_checksum().toString(16)}<br>
                反序列化成功: ${restored ? '✓' : '✗'}
            `;
        };

        window.testMemoryPool = function() {
            const start = performance.now();
            
            // 测试内存池性能
            const buffers = [];
            for (let i = 0; i < 1000; i++) {
                const buffer = memoryPool.get_buffer(1024);
                if (buffer) {
                    buffers.push(buffer);
                }
            }
            
            // 归还缓冲区
            for (const buffer of buffers) {
                memoryPool.return_buffer(buffer);
            }
            
            const end = performance.now();
            const stats = memoryPool.get_pool_stats();
            
            document.getElementById('pool-result').innerHTML = `
                <strong>内存池测试:</strong><br>
                操作时间: ${(end - start).toFixed(2)}ms<br>
                池统计: ${stats.join(', ')}<br>
                测试完成: ✓
            `;
        };

        window.testObjectPool = function() {
            const start = performance.now();
            
            // 测试对象池
            const points = [];
            for (let i = 0; i < 1000; i++) {
                const point = objectPool.get_point(i, i * 2, i * 3);
                points.push(point);
            }
            
            // 计算一些距离
            let totalDistance = 0;
            for (let i = 1; i < points.length; i++) {
                totalDistance += points[i].distance_to(points[i-1]);
            }
            
            // 归还对象
            for (const point of points) {
                objectPool.return_point(point);
            }
            
            const end = performance.now();
            
            document.getElementById('pool-result').innerHTML += `
                <br><strong>对象池测试:</strong><br>
                操作时间: ${(end - start).toFixed(2)}ms<br>
                总距离: ${totalDistance.toFixed(2)}<br>
                池大小: ${objectPool.pool_size()}
            `;
        };

        run();
    </script>
</body>
</html>