// host-api/src/lib.rs — 定义插件需要实现的接口

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct PluginRequest {
    pub action: String,
    pub payload: Vec<u8>,
}

#[derive(Serialize, Deserialize)]
pub struct PluginResponse {
    pub success: bool,
    pub data: Vec<u8>,
    pub error: Option<String>,
}

// 宿主提供给插件的 API
pub trait HostApi {
    fn log(&self, level: LogLevel, message: &str);
    fn read_file(&self, path: &str) -> Result<Vec<u8>, String>;
    fn write_file(&self, path: &str, data: &[u8]) -> Result<(), String>;
    fn http_request(&self, url: &str, body: &[u8]) -> Result<Vec<u8>, String>;
    fn storage_get(&self, key: &str) -> Option<Vec<u8>>;
    fn storage_set(&self, key: &str, value: &[u8]);
}

// plugin-sdk/src/lib.rs — 插件 SDK
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct Plugin {
    name: String,
    version: String,
}

#[wasm_bindgen]
impl Plugin {
    #[wasm_bindgen(constructor)]
    pub fn new() -> Plugin {
        Plugin {
            name: "my-plugin".to_string(),
            version: "1.0.0".to_string(),
        }
    }

    #[wasm_bindgen(getter)]
    pub fn name(&self) -> String {
        self.name.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn version(&self) -> String {
        self.version.clone()
    }

    pub fn handle_request(&self, action: &str, payload: &[u8]) -> Vec<u8> {
        match action {
            "transform" => self.transform(payload),
            "validate" => self.validate(payload),
            _ => Vec::new(),
        }
    }

    fn transform(&self, data: &[u8]) -> Vec<u8> {
        // 插件业务逻辑
        data.to_vec().into_iter().rev().collect()
    }

    fn validate(&self, data: &[u8]) -> Vec<u8> {
        vec![if data.len() > 0 { 1 } else { 0 }]
    }
}

// host/src/main.rs — 宿主程序
use wasmtime::*;
use wasmtime_wasi::WasiCtxBuilder;

fn main() -> anyhow::Result<()> {
    let engine = Engine::default();
    let mut linker = Linker::new(&engine);
    
    // 注入 WASI
    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
    
    // 注入自定义宿主函数
    linker.func_wrap("env", "log", |caller: Caller<'_, WasiCtx>, ptr: i32, len: i32| {
        let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
        let data = &memory.data(&caller)[ptr as usize..(ptr + len) as usize];
        let msg = std::str::from_utf8(data).unwrap();
        println!("[Plugin] {}", msg);
    })?;
    
    linker.func_wrap("env", "storage_get", |caller: Caller<'_, WasiCtx>, key_ptr: i32, key_len: i32| -> i32 {
        // 从存储中读取
        0 // 返回指针（0 表示未找到）
    })?;
    
    linker.func_wrap("env", "http_fetch", |caller: Caller<'_, WasiCtx>, url_ptr: i32, url_len: i32| -> i32 {
        // 发起 HTTP 请求
        0 // 返回结果指针
    })?;
    
    // 加载并运行插件
    let module = Module::from_file(&engine, "plugin.wasm")?;
    let wasi = WasiCtxBuilder::new()
        .inherit_stdio()
        .build();
    let mut store = Store::new(&engine, wasi);
    
    let instance = linker.instantiate(&mut store, &module)?;
    
    // 调用插件函数
    let process = instance.get_typed_func::<(i32, i32), i32>(&mut store, "process")?;
    let result = process.call(&mut store, (42, 100))?;
    println!("Result: {}", result);
    
    Ok(())
}

use std::collections::HashMap;
use wasmtime::*;

struct PluginManager {
    engine: Engine,
    plugins: HashMap<String, Instance>,
    plugin_meta: HashMap<String, PluginMetadata>,
}

struct PluginMetadata {
    name: String,
    version: String,
    enabled: bool,
    loaded_at: std::time::Instant,
}

impl PluginManager {
    fn new() -> Self {
        PluginManager {
            engine: Engine::new(&Config::new()).unwrap(),
            plugins: HashMap::new(),
            plugin_meta: HashMap::new(),
        }
    }
    
    fn load_plugin(&mut self, name: &str, wasm_bytes: &[u8]) -> anyhow::Result<()> {
        let module = Module::new(&self.engine, wasm_bytes)?;
        let mut store = Store::new(&self.engine, ());
        let instance = Instance::new(&mut store, &module, &[])?;
        
        // 获取插件元数据
        let get_name = instance.get_typed_func::<(), i32>(&mut store, "get_name_ptr")?;
        let get_version = instance.get_typed_func::<(), i32>(&mut store, "get_version_ptr")?;
        
        self.plugins.insert(name.to_string(), instance);
        self.plugin_meta.insert(name.to_string(), PluginMetadata {
            name: name.to_string(),
            version: "1.0.0".to_string(),
            enabled: true,
            loaded_at: std::time::Instant::now(),
        });
        
        println!("Loaded plugin: {}", name);
        Ok(())
    }
    
    fn unload_plugin(&mut self, name: &str) {
        self.plugins.remove(name);
        self.plugin_meta.remove(name);
        println!("Unloaded plugin: {}", name);
    }
    
    fn call_plugin(&self, name: &str, func: &str, args: &[Val]) -> anyhow::Result<Vec<Val>> {
        let instance = self.plugins.get(name)
            .ok_or_else(|| anyhow::anyhow!("Plugin not found: {}", name))?;
        
        let mut store = Store::new(&self.engine, ());
        let func = instance.get_func(&mut store, func)
            .ok_or_else(|| anyhow::anyhow!("Function not found: {}", func))?;
        
        let mut results = vec![Val::I32(0); func.ty(&store).results().len()];
        func.call(&mut store, args, &mut results)?;
        
        Ok(results)
    }
    
    fn list_plugins(&self) -> Vec<&PluginMetadata> {
        self.plugin_meta.values().collect()
    }
}

impl PluginManager {
    fn hot_reload(&mut self, name: &str, new_wasm: &[u8]) -> anyhow::Result<()> {
        // 保存旧版本
        let old_instance = self.plugins.remove(name);
        
        // 尝试加载新版本
        match self.load_plugin(name, new_wasm) {
            Ok(()) => {
                println!("Hot reloaded: {}", name);
                Ok(())
            }
            Err(e) => {
                // 回滚到旧版本
                if let Some(old) = old_instance {
                    self.plugins.insert(name.to_string(), old);
                    println!("Rolled back: {} (error: {})", name, e);
                }
                Err(e)
            }
        }
    }
}

// 每个插件独立的 Store 和 Memory
struct IsolatedPlugin {
    store: Store<PluginState>,
    instance: Instance,
}

struct PluginState {
    memory_limit: usize,
    call_limit: usize,
    calls_made: usize,
}

// 资源限制
impl PluginState {
    fn check_limits(&mut self) -> anyhow::Result<()> {
        self.calls_made += 1;
        if self.calls_made > self.call_limit {
            return Err(anyhow::anyhow!("Call limit exceeded"));
        }
        Ok(())
    }
}

fn create_sandboxed_engine() -> Engine {
    let mut config = Config::new();
    
    // 内存限制
    config.max_wasm_stack(1024 * 1024);  // 1MB 栈
    
    // 禁用危险特性
    config.wasm_threads(false);
    config.wasm_simd(false);
    
    // 启用 fuel 消耗限制
    config.consume_fuel(true);
    
    Engine::new(&config).unwrap()
}

fn run_with_fuel(store: &mut Store<PluginState>, func: &Func, args: &[Val]) -> anyhow::Result<()> {
    // 设置燃料限制（防止无限循环）
    store.set_fuel(1_000_000)?;
    
    let mut results = vec![Val::I32(0)];
    func.call(store, args, &mut results)?;
    
    let remaining = store.get_fuel()?;
    println!("Fuel remaining: {}", remaining);
    
    Ok(())
}

wit_bindgen::generate!({
    world: "plugin",
});

struct MyPlugin;

impl Guest for MyPlugin {
    fn process(req: Request) -> Response {
        host::log(0, &format!("Processing: {}", req.action));
        
        match req.action.as_str() {
            "reverse" => {
                let mut data = req.payload.clone();
                data.reverse();
                Response { success: true, data, error: None }
            }
            _ => Response {
                success: false,
                data: vec![],
                error: Some(format!("Unknown action: {}", req.action)),
            }
        }
    }
    
    fn get_name() -> String {
        "my-rust-plugin".to_string()
    }
    
    fn get_version() -> String {
        "1.0.0".to_string()
    }
}

export!(MyPlugin);

// 同一个接口，C 语言实现
#include "plugin.h"

response_t process(request_t req) {
    response_t resp;
    
    if (strcmp(req.action, "reverse") == 0) {
        resp.success = true;
        resp.data = req.payload;
        reverse_array(resp.data, req.payload_len);
        resp.error = NULL;
    } else {
        resp.success = false;
        resp.error = "Unknown action";
    }
    
    return resp;
}

// 宿主程序
struct TextProcessor {
    plugins: PluginManager,
}

impl TextProcessor {
    fn process_text(&self, text: &str, pipeline: &[&str]) -> String {
        let mut current = text.as_bytes().to_vec();
        
        for plugin_name in pipeline {
            let result = self.plugins.call_plugin(
                plugin_name,
                "process_text",
                &[Val::I32(current.as_ptr() as i32), Val::I32(current.len() as i32)],
            );
            // 更新 current...
        }
        
        String::from_utf8(current).unwrap_or_default()
    }
}

// 使用
fn main() {
    let mut processor = TextProcessor {
        plugins: PluginManager::new(),
    };
    
    processor.plugins.load_plugin("trim", include_bytes!("plugins/trim.wasm")).unwrap();
    processor.plugins.load_plugin("uppercase", include_bytes!("plugins/uppercase.wasm")).unwrap();
    processor.plugins.load_plugin("sanitize", include_bytes!("plugins/sanitize.wasm")).unwrap();
    
    let result = processor.process_text(
        "  Hello, World!  ",
        &["trim", "uppercase", "sanitize"],
    );
    println!("{}", result);  // "HELLO, WORLD!"
}