High-Performance Edge Computing with Rust and WebAssembly (Wasm): Executing Sub-Millisecond Rules

use wasm_bindgen::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct RuleEvaluationRequest {
    pub tenant_id: String,
    pub user_score: f64,
    pub country_code: String,
}

#[derive(Serialize, Deserialize)]
pub struct RuleEvaluationResult {
    pub allowed: bool,
    pub latency_us: u64,
    pub rule_applied: String,
}

#[wasm_bindgen]
pub fn evaluate_edge_policy(payload_json: &str) -> Result<String, JsValue> {
    let start_time = std::time::Instant::now();
    
    // 1. Zero-copy deserialization of JSON payload
    let req: RuleEvaluationRequest = serde_json::from_str(payload_json)
        .map_err(|e| JsValue::from_str(&e.to_string()))?;

    // 2. High-speed memory-bound business logic execution
    let mut allowed = true;
    let mut applied_rule = "DEFAULT_PASS";

    if req.user_score < 0.40 || req.country_code == "BLOCKED" {
        allowed = false;
        applied_rule = "RISK_SCORE_BLOCK";
    }

    let elapsed = start_time.elapsed().as_micros() as u64;

    let res = RuleEvaluationResult {
        allowed,
        latency_us: elapsed,
        rule_applied: applied_rule.to_string(),
    };

    // 3. Serialize output back to JSON string
    serde_json::to_string(&res).map_err(|e| JsValue::from_str(&e.to_string()))
}