pub mod wasm {
  pub struct WasmRegistry {
    runtime: wasmtime::Engine,
    instances: HashMap<String, WasmInstance>,
    policies: HashMap<String, Box<dyn WasmPolicy>>,
    middleware: HashMap<String, Box<dyn WasmMiddleware>>,
    routers: HashMap<String, Box<dyn WasmRouter>>,
  }

  pub trait WasmPolicy: Send + Sync {
    fn select_worker(&self, workers: &[Arc<dyn Worker>], request: &Request) -> Option<usize>;
    fn name(&self) -> &str;
    fn version(&self) -> &str;
  }

  pub trait WasmMiddleware: Send + Sync {
    fn process(&self, request: &mut Request, context: &mut Context) -> Result<(), MiddlewareError>;
    fn name(&self) -> &str;
  }

  /// TODO
}

// Host functions exposed to WASM modules (just an example — might change later)
pub mod host_functions {
    // Worker management
    pub fn get_worker_count() -> u32;
    pub fn get_worker_url(index: u32) -> String;
    pub fn get_worker_load(index: u32) -> u32;
    pub fn get_worker_health(index: u32) -> bool;
    
    // Request information
    pub fn get_request_text() -> String;
    pub fn get_request_headers() -> String; // JSON
    pub fn get_request_model() -> String;
    
    // Metrics and logging
    pub fn log_info(message: String);
    pub fn log_error(message: String);
    pub fn record_metric(name: String, value: f64);
    
    // External data access
    pub fn get_config(key: String) -> String;
    pub fn http_request(url: String, method: String, body: String) -> String;
}

use crate::policies::wasm::{WasmManager, WasmPolicyAdapter};

impl PolicyRegistry {
    pub async fn register_wasm_random_policy(&mut self) -> Result<(), WasmError> {
        let mut wasm_manager = WasmManager::new();
        
        // Load Wasm module from local fs
        wasm_manager.load_module(WasmModuleConfig {
            name: "wasm_random".to_string(),
            path: "/path/to/wasm-random-policy.wasm".to_string(),
            module_type: WasmModuleType::Policy,
            config: serde_json::json!({}),
        }).await?;
        
        let wasm_policy = WasmPolicyAdapter::new(wasm_manager, "wasm_random");
        self.policies.insert("wasm_random".to_string(), Arc::new(wasm_policy));
        
        Ok(())
    }
}

struct WasmPolicyAdapter {
    wasm_manager: WasmManager,
    policy_name: String,
}

impl LoadBalancingPolicy for WasmPolicyAdapter {
    fn select_worker(&self, workers: &[Arc<dyn Worker>], _request_text: Option<&str>) -> Option<usize> {
        // Worker info in JSON format, just for example now
        let worker_infos: Vec<WorkerInfo> = workers
            .iter()
            .map(|worker| WorkerInfo {
                url: worker.url().to_string(),
                health: worker.is_healthy(),
            })
            .collect();
        
        let workers_json = serde_json::to_string(&worker_infos).ok()?;
        
        // Execute
        let selected_index = self.wasm_manager.execute_policy(
            &self.policy_name,
            &workers_json,
            None,
        )?;
        
        if selected_index >= 0 && (selected_index as usize) < workers.len() {
            Some(selected_index as usize)
        } else {
            None
        }
    }
    
    fn name(&self) -> &'static str {
        "wasm_random"
    }
}