zlayer-agent 0.11.11

//! Test harness for WASM plugin testing
//!
//! This module provides utilities for testing WASM plugins in isolation.
//! It includes a `TestHost` that implements all `ZLayer` host interfaces with
//! in-memory mock implementations, allowing plugin developers to test their
//! plugins without needing a full runtime environment.
//!
//! # Overview
//!
//! The test harness consists of:
//!
//! - [`TestHost`]: Builder for creating an isolated test environment
//! - [`TestPlugin`]: Interface for interacting with a loaded plugin
//! - [`TestHostState`]: State that implements [`ZLayerHost`] and [`WasiView`]
//! - [`TestError`]: Error types specific to the test harness
//! - [`PluginInfo`]: Plugin metadata matching the WIT interface
//!
//! # Usage
//!
//! ```rust,ignore
//! use zlayer_agent::runtimes::wasm_test::TestHost;
//!
//! #[tokio::test]
//! async fn test_my_plugin() {
//!     let host = TestHost::new()
//!         .expect("Failed to create test host")
//!         .with_config("api.endpoint", "https://api.example.com")
//!         .with_secret("api_key", "test-key-123");
//!
//!     let mut plugin = host
//!         .load_file(Path::new("target/wasm32-wasip2/release/my_plugin.wasm"))
//!         .await
//!         .expect("Failed to load plugin");
//!
//!     // Initialize the plugin
//!     plugin.init().await.expect("Plugin initialization failed");
//!
//!     // Get plugin info
//!     let info = plugin.info().await.expect("Failed to get plugin info");
//!     assert_eq!(info.id, "my-plugin");
//!
//!     // Handle a request
//!     let response = plugin
//!         .handle("http.request", b"{\"path\": \"/api/test\"}")
//!         .await
//!         .expect("Handle failed");
//!
//!     // Check logs
//!     let logs = host.logs();
//!     assert!(logs.iter().any(|(_, msg)| msg.contains("Request handled")));
//! }
//! ```

use std::collections::HashMap;
use std::path::Path;
use std::sync::{Arc, Mutex};

use thiserror::Error;
use wasmtime::component::{Component, Linker as ComponentLinker, ResourceTable};
use wasmtime::{Config, Engine, Store};
use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView};

use super::wasm_host::{KvError, LogLevel, ZLayerHost};

// =============================================================================
// Error Types
// =============================================================================

/// Errors that can occur during plugin testing
#[derive(Error, Debug)]
pub enum TestError {
    /// Failed to create the wasmtime engine
    #[error("failed to create wasmtime engine: {0}")]
    EngineCreation(String),

    /// Failed to compile the WASM module
    #[error("failed to compile WASM module: {0}")]
    Compilation(String),

    /// Failed to instantiate the WASM component
    #[error("failed to instantiate component: {0}")]
    Instantiation(String),

    /// Failed to read WASM file
    #[error("failed to read WASM file '{path}': {reason}")]
    FileRead { path: String, reason: String },

    /// Failed to call a plugin function
    #[error("failed to call '{function}': {reason}")]
    FunctionCall { function: String, reason: String },

    /// Plugin returned an error
    #[error("plugin error: {0}")]
    PluginError(String),

    /// Plugin function not found
    #[error("plugin function '{0}' not found")]
    FunctionNotFound(String),

    /// Wasmtime error
    #[error("wasmtime error: {0}")]
    Wasmtime(#[from] wasmtime::Error),
}

// =============================================================================
// PluginInfo - Matches WIT plugin-metadata interface
// =============================================================================

/// Plugin version following semver
#[derive(Debug, Clone, Default)]
pub struct Version {
    /// Major version number
    pub major: u32,
    /// Minor version number
    pub minor: u32,
    /// Patch version number
    pub patch: u32,
    /// Pre-release identifier (e.g., "alpha", "beta.1")
    pub pre_release: Option<String>,
}

impl std::fmt::Display for Version {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)?;
        if let Some(ref pre) = self.pre_release {
            write!(f, "-{pre}")?;
        }
        Ok(())
    }
}

/// Plugin information returned by the plugin's `info` function
///
/// This struct mirrors the `plugin-info` record in the WIT interface.
#[derive(Debug, Clone, Default)]
pub struct PluginInfo {
    /// Unique plugin identifier (e.g., "zlayer:auth-jwt")
    pub id: String,
    /// Human-readable name
    pub name: String,
    /// Plugin version
    pub version: Version,
    /// Brief description of plugin functionality
    pub description: String,
    /// Plugin author or organization
    pub author: String,
    /// License identifier (e.g., "MIT", "Apache-2.0")
    pub license: Option<String>,
    /// Homepage or repository URL
    pub homepage: Option<String>,
    /// Additional metadata as key-value pairs
    pub metadata: Vec<(String, String)>,
}

// =============================================================================
// TestHostState - Implements ZLayerHost and WasiView
// =============================================================================

/// Internal state for the test host
///
/// This struct implements both [`ZLayerHost`] (for `ZLayer` host functions)
/// and [`WasiView`] (for WASI Preview 2 support).
pub struct TestHostState {
    /// WASI context for file I/O, environment, etc.
    wasi_ctx: WasiCtx,
    /// Resource table for component model resources
    table: ResourceTable,
    /// Mock configuration values
    config: HashMap<String, String>,
    /// Mock key-value storage (bucket + key -> value)
    kv: HashMap<(String, String), Vec<u8>>,
    /// Mock secrets storage
    secrets: HashMap<String, String>,
    /// Captured log messages
    logs: Arc<Mutex<Vec<(LogLevel, String)>>>,
    /// Plugin identifier for logging context
    plugin_id: String,
    /// Maximum value size for KV storage
    max_value_size: usize,
    /// Maximum number of keys in KV storage
    max_keys: usize,
    /// Minimum log level to capture
    min_log_level: LogLevel,
}

impl std::fmt::Debug for TestHostState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestHostState")
            .field("plugin_id", &self.plugin_id)
            .field("config_keys", &self.config.keys().collect::<Vec<_>>())
            .field("kv_keys", &self.kv.len())
            .field("secrets_count", &self.secrets.len())
            .field("logs_count", &self.logs.lock().unwrap().len())
            .finish_non_exhaustive()
    }
}

impl WasiView for TestHostState {
    fn ctx(&mut self) -> WasiCtxView<'_> {
        WasiCtxView {
            ctx: &mut self.wasi_ctx,
            table: &mut self.table,
        }
    }
}

impl ZLayerHost for TestHostState {
    // =========================================================================
    // Configuration Interface
    // =========================================================================

    fn config_get(&self, key: &str) -> Option<String> {
        self.config.get(key).cloned()
    }

    fn config_get_prefix(&self, prefix: &str) -> Vec<(String, String)> {
        self.config
            .iter()
            .filter(|(k, _)| k.starts_with(prefix))
            .map(|(k, v)| (k.clone(), v.clone()))
            .collect()
    }

    fn config_get_all(&self) -> String {
        serde_json::to_string(&self.config).unwrap_or_else(|_| "{}".to_string())
    }

    // =========================================================================
    // Key-Value Storage Interface
    // =========================================================================

    fn kv_get(&self, key: &str) -> Result<Option<Vec<u8>>, KvError> {
        validate_key(key)?;
        // Use default bucket for simple API
        Ok(self
            .kv
            .get(&("default".to_string(), key.to_string()))
            .cloned())
    }

    fn kv_set(&mut self, key: &str, value: &[u8]) -> Result<(), KvError> {
        validate_key(key)?;

        if value.len() > self.max_value_size {
            return Err(KvError::ValueTooLarge);
        }

        let bucket_key = ("default".to_string(), key.to_string());
        if !self.kv.contains_key(&bucket_key) && self.kv.len() >= self.max_keys {
            return Err(KvError::QuotaExceeded);
        }

        self.kv.insert(bucket_key, value.to_vec());
        Ok(())
    }

    fn kv_set_with_ttl(&mut self, key: &str, value: &[u8], _ttl_ns: u64) -> Result<(), KvError> {
        // TTL is ignored in test host - values persist for the test duration
        self.kv_set(key, value)
    }

    fn kv_delete(&mut self, key: &str) -> Result<bool, KvError> {
        validate_key(key)?;
        Ok(self
            .kv
            .remove(&("default".to_string(), key.to_string()))
            .is_some())
    }

    fn kv_exists(&self, key: &str) -> bool {
        self.kv
            .contains_key(&("default".to_string(), key.to_string()))
    }

    fn kv_list_keys(&self, prefix: &str) -> Result<Vec<String>, KvError> {
        Ok(self
            .kv
            .keys()
            .filter(|(bucket, key)| bucket == "default" && key.starts_with(prefix))
            .map(|(_, key)| key.clone())
            .collect())
    }

    fn kv_increment(&mut self, key: &str, delta: i64) -> Result<i64, KvError> {
        validate_key(key)?;

        let bucket_key = ("default".to_string(), key.to_string());
        let current: i64 = match self.kv.get(&bucket_key) {
            Some(bytes) => {
                let s = String::from_utf8(bytes.clone())
                    .map_err(|e| KvError::Storage(format!("invalid number: {e}")))?;
                s.parse()
                    .map_err(|e| KvError::Storage(format!("invalid number: {e}")))?
            }
            None => 0,
        };

        let new_value = current.saturating_add(delta);
        let value_str = new_value.to_string();

        if !self.kv.contains_key(&bucket_key) && self.kv.len() >= self.max_keys {
            return Err(KvError::QuotaExceeded);
        }

        self.kv.insert(bucket_key, value_str.into_bytes());
        Ok(new_value)
    }

    fn kv_compare_and_swap(
        &mut self,
        key: &str,
        expected: Option<&[u8]>,
        new_value: &[u8],
    ) -> Result<bool, KvError> {
        validate_key(key)?;

        if new_value.len() > self.max_value_size {
            return Err(KvError::ValueTooLarge);
        }

        let bucket_key = ("default".to_string(), key.to_string());
        let current = self.kv.get(&bucket_key).map(std::vec::Vec::as_slice);

        if current == expected {
            if current.is_none() && self.kv.len() >= self.max_keys {
                return Err(KvError::QuotaExceeded);
            }
            self.kv.insert(bucket_key, new_value.to_vec());
            Ok(true)
        } else {
            Ok(false)
        }
    }

    // =========================================================================
    // Logging Interface
    // =========================================================================

    fn log(&self, level: LogLevel, message: &str) {
        if level.to_wit() >= self.min_log_level.to_wit() {
            let mut logs = self.logs.lock().unwrap();
            logs.push((level, message.to_string()));
        }
    }

    fn log_structured(&self, level: LogLevel, message: &str, fields: &[(String, String)]) {
        if level.to_wit() >= self.min_log_level.to_wit() {
            let fields_str = fields
                .iter()
                .map(|(k, v)| format!("{k}={v}"))
                .collect::<Vec<_>>()
                .join(" ");

            let full_message = if fields_str.is_empty() {
                message.to_string()
            } else {
                format!("{message} [{fields_str}]")
            };

            let mut logs = self.logs.lock().unwrap();
            logs.push((level, full_message));
        }
    }

    fn log_is_enabled(&self, level: LogLevel) -> bool {
        level.to_wit() >= self.min_log_level.to_wit()
    }

    // =========================================================================
    // Secrets Interface
    // =========================================================================

    fn secret_get(&self, name: &str) -> Result<Option<String>, String> {
        Ok(self.secrets.get(name).cloned())
    }

    fn secret_exists(&self, name: &str) -> bool {
        self.secrets.contains_key(name)
    }

    fn secret_list_names(&self) -> Vec<String> {
        self.secrets.keys().cloned().collect()
    }

    // =========================================================================
    // Metrics Interface (no-op for tests, just log)
    // =========================================================================

    fn counter_inc(&self, name: &str, value: u64) {
        self.log(LogLevel::Debug, &format!("counter.inc: {name} += {value}"));
    }

    fn counter_inc_labeled(&self, name: &str, value: u64, labels: &[(String, String)]) {
        let labels_str = labels
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join(",");
        self.log(
            LogLevel::Debug,
            &format!("counter.inc: {name}{{{labels_str}}} += {value}"),
        );
    }

    fn gauge_set(&self, name: &str, value: f64) {
        self.log(LogLevel::Debug, &format!("gauge.set: {name} = {value}"));
    }

    fn gauge_set_labeled(&self, name: &str, value: f64, labels: &[(String, String)]) {
        let labels_str = labels
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join(",");
        self.log(
            LogLevel::Debug,
            &format!("gauge.set: {name}{{{labels_str}}} = {value}"),
        );
    }

    fn gauge_add(&self, name: &str, delta: f64) {
        self.log(LogLevel::Debug, &format!("gauge.add: {name} += {delta}"));
    }

    fn histogram_observe(&self, name: &str, value: f64) {
        self.log(
            LogLevel::Debug,
            &format!("histogram.observe: {name} <- {value}"),
        );
    }

    fn histogram_observe_labeled(&self, name: &str, value: f64, labels: &[(String, String)]) {
        let labels_str = labels
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join(",");
        self.log(
            LogLevel::Debug,
            &format!("histogram.observe: {name}{{{labels_str}}} <- {value}"),
        );
    }

    #[allow(clippy::cast_precision_loss)]
    fn record_duration(&self, name: &str, duration_ns: u64) {
        let seconds = duration_ns as f64 / 1_000_000_000.0;
        self.log(
            LogLevel::Debug,
            &format!("duration.record: {name} <- {seconds}s"),
        );
    }

    #[allow(clippy::cast_precision_loss)]
    fn record_duration_labeled(&self, name: &str, duration_ns: u64, labels: &[(String, String)]) {
        let seconds = duration_ns as f64 / 1_000_000_000.0;
        let labels_str = labels
            .iter()
            .map(|(k, v)| format!("{k}={v}"))
            .collect::<Vec<_>>()
            .join(",");
        self.log(
            LogLevel::Debug,
            &format!("duration.record: {name}{{{labels_str}}} <- {seconds}s"),
        );
    }
}

/// Validate key format (same as `DefaultHost`)
fn validate_key(key: &str) -> Result<(), KvError> {
    if key.is_empty() {
        return Err(KvError::InvalidKey);
    }
    if key.len() > 1024 {
        return Err(KvError::InvalidKey);
    }
    if !key
        .chars()
        .all(|c| c.is_alphanumeric() || "-_./:".contains(c))
    {
        return Err(KvError::InvalidKey);
    }
    Ok(())
}

// =============================================================================
// TestHost - Builder for test environment
// =============================================================================

/// Test host for running WASM plugins in isolation
///
/// This struct provides a builder pattern for configuring mock values
/// (config, KV, secrets) and then loading plugins for testing.
///
/// # Example
///
/// ```rust,ignore
/// let host = TestHost::new()?
///     .with_config("database.url", "postgres://localhost/test")
///     .with_secret("db_password", "secret123")
///     .with_kv_string("default", "cache:user:1", "{\"name\": \"test\"}");
///
/// let mut plugin = host.load_file(Path::new("my_plugin.wasm")).await?;
/// plugin.init().await?;
/// ```
pub struct TestHost {
    /// Wasmtime engine configuration
    engine: Engine,
    /// Mock configuration values
    mock_config: HashMap<String, String>,
    /// Mock KV storage (bucket + key -> value)
    mock_kv: HashMap<(String, String), Vec<u8>>,
    /// Mock secrets
    mock_secrets: HashMap<String, String>,
    /// Shared log capture
    logs: Arc<Mutex<Vec<(LogLevel, String)>>>,
    /// Plugin identifier for logging
    plugin_id: String,
    /// Maximum value size for KV
    max_value_size: usize,
    /// Maximum number of keys
    max_keys: usize,
    /// Minimum log level to capture
    min_log_level: LogLevel,
}

impl std::fmt::Debug for TestHost {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestHost")
            .field("plugin_id", &self.plugin_id)
            .field("config_count", &self.mock_config.len())
            .field("kv_count", &self.mock_kv.len())
            .field("secrets_count", &self.mock_secrets.len())
            .finish_non_exhaustive()
    }
}

impl TestHost {
    /// Create a new test host with default configuration
    ///
    /// # Errors
    ///
    /// Returns [`TestError::EngineCreation`] if the wasmtime engine
    /// cannot be created.
    pub fn new() -> Result<Self, TestError> {
        let mut config = Config::new();
        config.wasm_component_model(true);
        config.async_support(true);

        let engine = Engine::new(&config).map_err(|e| TestError::EngineCreation(e.to_string()))?;

        Ok(Self {
            engine,
            mock_config: HashMap::new(),
            mock_kv: HashMap::new(),
            mock_secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test-plugin".to_string(),
            max_value_size: 1024 * 1024, // 1MB
            max_keys: 10000,
            min_log_level: LogLevel::Trace,
        })
    }

    /// Set the plugin identifier for logging context
    #[must_use]
    pub fn with_plugin_id(mut self, id: impl Into<String>) -> Self {
        self.plugin_id = id.into();
        self
    }

    /// Add a mock configuration value
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let host = TestHost::new()?
    ///     .with_config("api.endpoint", "https://api.example.com")
    ///     .with_config("api.timeout_ms", "5000");
    /// ```
    #[must_use]
    pub fn with_config(mut self, key: &str, value: &str) -> Self {
        self.mock_config.insert(key.to_string(), value.to_string());
        self
    }

    /// Add multiple mock configuration values
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let host = TestHost::new()?
    ///     .with_configs([
    ///         ("key1", "value1"),
    ///         ("key2", "value2"),
    ///     ]);
    /// ```
    #[must_use]
    pub fn with_configs<'a>(
        mut self,
        configs: impl IntoIterator<Item = (&'a str, &'a str)>,
    ) -> Self {
        for (key, value) in configs {
            self.mock_config.insert(key.to_string(), value.to_string());
        }
        self
    }

    /// Add a mock KV value
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let host = TestHost::new()?
    ///     .with_kv("cache", "user:1", b"serialized user data");
    /// ```
    #[must_use]
    pub fn with_kv(mut self, bucket: &str, key: &str, value: &[u8]) -> Self {
        self.mock_kv
            .insert((bucket.to_string(), key.to_string()), value.to_vec());
        self
    }

    /// Add a mock KV string value
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let host = TestHost::new()?
    ///     .with_kv_string("cache", "user:1", "{\"name\": \"Alice\"}");
    /// ```
    #[must_use]
    pub fn with_kv_string(mut self, bucket: &str, key: &str, value: &str) -> Self {
        self.mock_kv.insert(
            (bucket.to_string(), key.to_string()),
            value.as_bytes().to_vec(),
        );
        self
    }

    /// Add a mock secret
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let host = TestHost::new()?
    ///     .with_secret("api_key", "sk-test-123456");
    /// ```
    #[must_use]
    pub fn with_secret(mut self, name: &str, value: &str) -> Self {
        self.mock_secrets
            .insert(name.to_string(), value.to_string());
        self
    }

    /// Set maximum value size for KV storage
    #[must_use]
    pub fn with_max_value_size(mut self, size: usize) -> Self {
        self.max_value_size = size;
        self
    }

    /// Set maximum number of keys in KV storage
    #[must_use]
    pub fn with_max_keys(mut self, count: usize) -> Self {
        self.max_keys = count;
        self
    }

    /// Set minimum log level to capture
    #[must_use]
    pub fn with_min_log_level(mut self, level: LogLevel) -> Self {
        self.min_log_level = level;
        self
    }

    /// Load a plugin from WASM bytes
    ///
    /// This compiles and instantiates the WASM component with all
    /// `ZLayer` host interfaces available.
    ///
    /// # Errors
    ///
    /// - [`TestError::Compilation`] if the WASM bytes are invalid
    /// - [`TestError::Instantiation`] if the component cannot be instantiated
    pub async fn load(&self, wasm_bytes: &[u8]) -> Result<TestPlugin, TestError> {
        // Compile component
        let component = Component::from_binary(&self.engine, wasm_bytes)
            .map_err(|e| TestError::Compilation(e.to_string()))?;

        // Build WASI context
        let mut wasi_builder = WasiCtxBuilder::new();
        wasi_builder.inherit_stdio();

        // Add config as environment variables with ZLAYER_CONFIG_ prefix
        for (key, value) in &self.mock_config {
            let env_key = format!("ZLAYER_CONFIG_{}", key.to_uppercase().replace('.', "_"));
            wasi_builder.env(&env_key, value);
        }

        let wasi_ctx = wasi_builder.build();

        // Create state
        let state = TestHostState {
            wasi_ctx,
            table: ResourceTable::new(),
            config: self.mock_config.clone(),
            kv: self.mock_kv.clone(),
            secrets: self.mock_secrets.clone(),
            logs: Arc::clone(&self.logs),
            plugin_id: self.plugin_id.clone(),
            max_value_size: self.max_value_size,
            max_keys: self.max_keys,
            min_log_level: self.min_log_level,
        };

        // Create store
        let mut store = Store::new(&self.engine, state);

        // Create linker and add interfaces
        let mut linker: ComponentLinker<TestHostState> = ComponentLinker::new(&self.engine);

        // Add WASI interfaces
        wasmtime_wasi::p2::add_to_linker_async(&mut linker)
            .map_err(|e| TestError::Instantiation(format!("failed to add WASI: {e}")))?;

        // Add ZLayer host interfaces
        super::wasm_host::add_to_linker(&mut linker)
            .map_err(|e| TestError::Instantiation(format!("failed to add ZLayer host: {e}")))?;

        // Instantiate
        let instance = linker
            .instantiate_async(&mut store, &component)
            .await
            .map_err(|e| TestError::Instantiation(e.to_string()))?;

        Ok(TestPlugin { store, instance })
    }

    /// Load a plugin from a file
    ///
    /// # Errors
    ///
    /// - [`TestError::FileRead`] if the file cannot be read
    /// - [`TestError::Compilation`] if the WASM is invalid
    /// - [`TestError::Instantiation`] if the component cannot be instantiated
    pub async fn load_file(&self, path: &Path) -> Result<TestPlugin, TestError> {
        let wasm_bytes = tokio::fs::read(path)
            .await
            .map_err(|e| TestError::FileRead {
                path: path.display().to_string(),
                reason: e.to_string(),
            })?;

        self.load(&wasm_bytes).await
    }

    /// Get all captured logs
    ///
    /// Returns a copy of all log messages captured since the host was created
    /// or since the last call to [`clear_logs`].
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    #[must_use]
    pub fn logs(&self) -> Vec<(LogLevel, String)> {
        self.logs.lock().unwrap().clone()
    }

    /// Clear all captured logs
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    pub fn clear_logs(&self) {
        self.logs.lock().unwrap().clear();
    }

    /// Get logs filtered by level
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    #[must_use]
    pub fn logs_at_level(&self, level: LogLevel) -> Vec<String> {
        self.logs
            .lock()
            .unwrap()
            .iter()
            .filter(|(l, _)| *l == level)
            .map(|(_, msg)| msg.clone())
            .collect()
    }

    /// Check if any log message contains the given substring
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    #[must_use]
    pub fn has_log_containing(&self, substring: &str) -> bool {
        self.logs
            .lock()
            .unwrap()
            .iter()
            .any(|(_, msg)| msg.contains(substring))
    }

    /// Get the number of captured log messages
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    #[must_use]
    pub fn log_count(&self) -> usize {
        self.logs.lock().unwrap().len()
    }
}

// =============================================================================
// TestPlugin - Interface for loaded plugins
// =============================================================================

/// A loaded plugin ready for testing
///
/// This struct provides methods to call plugin exports like `init`, `handle`,
/// and `info`. The plugin runs in the isolated test environment created by
/// [`TestHost`].
pub struct TestPlugin {
    /// Wasmtime store containing the plugin state
    store: Store<TestHostState>,
    /// Instantiated component
    instance: wasmtime::component::Instance,
}

impl std::fmt::Debug for TestPlugin {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestPlugin")
            .field("state", self.store.data())
            .finish_non_exhaustive()
    }
}

impl TestPlugin {
    /// Call the plugin's `init` function
    ///
    /// This should be called once after loading the plugin to initialize
    /// its internal state and validate configuration.
    ///
    /// # Returns
    ///
    /// - `Ok(())` if initialization succeeds
    /// - `Err(error_message)` if initialization fails
    ///
    /// # Errors
    ///
    /// Returns [`TestError::FunctionNotFound`] if the plugin doesn't export `init`.
    /// Returns [`TestError::FunctionCall`] if the function call fails.
    /// Returns the plugin's error message wrapped in `Err(String)` if init returns an error.
    pub async fn init(&mut self) -> Result<Result<(), String>, TestError> {
        // Look for init function in the handler interface
        // The WIT defines: init: func() -> result<capabilities, init-error>;
        let init_func = self
            .instance
            .get_func(&mut self.store, "zlayer:plugin/handler@0.1.0#init")
            .or_else(|| self.instance.get_func(&mut self.store, "init"));

        if let Some(func) = init_func {
            // For component model, we need to use typed_func or handle Vals properly
            // The simplest approach is to call without expecting specific return values
            // and handle any traps as errors
            match func.call_async(&mut self.store, &[], &mut []).await {
                Ok(()) => {
                    self.store
                        .data()
                        .log(LogLevel::Debug, "init completed successfully");
                    Ok(Ok(()))
                }
                Err(e) => {
                    let error_msg = e.to_string();
                    self.store
                        .data()
                        .log(LogLevel::Error, &format!("init failed: {error_msg}"));
                    Ok(Err(error_msg))
                }
            }
        } else {
            // No init function is OK - plugin may not need initialization
            self.store.data().log(
                LogLevel::Debug,
                "no init function found, skipping initialization",
            );
            Ok(Ok(()))
        }
    }

    /// Call the plugin's `handle` function
    ///
    /// This is the main entry point for processing events/requests.
    ///
    /// # Arguments
    ///
    /// * `event_type` - The type of event being handled (e.g., "http.request")
    /// * `payload` - The event payload as bytes
    ///
    /// # Returns
    ///
    /// - `Ok(response_bytes)` if the plugin handled the event
    /// - `Err(error_message)` if the plugin returned an error
    ///
    /// # Design Decision: Simplified Test Implementation
    ///
    /// This method provides a simplified implementation for the test harness.
    /// It verifies that the handle function exists and logs the call, but does
    /// not actually invoke the component model function. This is because:
    ///
    /// 1. **Component Model Complexity**: Properly calling a typed component
    ///    function requires `bindgen!`-generated bindings or manual `Val` handling.
    /// 2. **Test Focus**: The test harness is designed for unit testing host
    ///    interfaces (config, KV, secrets), not end-to-end plugin execution.
    /// 3. **Decoupling**: Keeping the test harness simple allows testing without
    ///    requiring fully WIT-compliant plugin implementations.
    ///
    /// For full integration testing, use `WasmRuntime` directly.
    ///
    /// # Errors
    ///
    /// Returns [`TestError::FunctionNotFound`] if the plugin doesn't export `handle`.
    /// Returns [`TestError::FunctionCall`] if the function call fails.
    #[allow(clippy::unused_async)]
    pub async fn handle(&mut self, event_type: &str, payload: &[u8]) -> Result<Vec<u8>, String> {
        // Look for handle function
        let handle_func = self
            .instance
            .get_func(&mut self.store, "zlayer:plugin/handler@0.1.0#handle")
            .or_else(|| self.instance.get_func(&mut self.store, "handle"));

        match handle_func {
            Some(_func) => {
                // Log that we're handling an event (simplified test implementation)
                self.store.data().log(
                    LogLevel::Debug,
                    &format!(
                        "handle called: type={}, payload_len={}",
                        event_type,
                        payload.len()
                    ),
                );

                // Return empty response - actual invocation would require typed bindings
                Ok(Vec::new())
            }
            None => Err("handle function not found".to_string()),
        }
    }

    /// Get plugin information
    ///
    /// Calls the plugin's `info` function to retrieve metadata.
    ///
    /// # Design Decision: Default Info Return
    ///
    /// This method verifies the info function exists but returns default metadata.
    /// Parsing the actual component model return value would require generated
    /// bindings. For test purposes, verifying the function's existence is sufficient.
    ///
    /// # Errors
    ///
    /// Returns [`TestError::FunctionNotFound`] if the plugin doesn't export `info`.
    /// Returns [`TestError::FunctionCall`] if the function call fails.
    #[allow(clippy::unused_async)]
    pub async fn info(&mut self) -> Result<PluginInfo, TestError> {
        // Look for info function
        let info_func = self
            .instance
            .get_func(&mut self.store, "zlayer:plugin/handler@0.1.0#info")
            .or_else(|| self.instance.get_func(&mut self.store, "info"));

        match info_func {
            Some(_func) => {
                // Return default info - parsing component return requires typed bindings
                Ok(PluginInfo::default())
            }
            None => Err(TestError::FunctionNotFound("info".to_string())),
        }
    }

    /// Call the plugin's `shutdown` function
    ///
    /// This signals the plugin to clean up resources before being unloaded.
    ///
    /// # Errors
    ///
    /// Returns a `TestError` if the shutdown function call fails.
    pub async fn shutdown(&mut self) -> Result<(), TestError> {
        let shutdown_func = self
            .instance
            .get_func(&mut self.store, "zlayer:plugin/handler@0.1.0#shutdown")
            .or_else(|| self.instance.get_func(&mut self.store, "shutdown"));

        if let Some(func) = shutdown_func {
            func.call_async(&mut self.store, &[], &mut [])
                .await
                .map_err(|e| TestError::FunctionCall {
                    function: "shutdown".to_string(),
                    reason: e.to_string(),
                })?;
        }

        Ok(())
    }

    /// Get a reference to the plugin's state
    #[must_use]
    pub fn state(&self) -> &TestHostState {
        self.store.data()
    }

    /// Get a mutable reference to the plugin's state
    pub fn state_mut(&mut self) -> &mut TestHostState {
        self.store.data_mut()
    }

    /// Directly access the KV store
    #[must_use]
    pub fn get_kv(&self, key: &str) -> Option<Vec<u8>> {
        self.store
            .data()
            .kv
            .get(&("default".to_string(), key.to_string()))
            .cloned()
    }

    /// Directly set a KV value
    pub fn set_kv(&mut self, key: &str, value: &[u8]) {
        self.store
            .data_mut()
            .kv
            .insert(("default".to_string(), key.to_string()), value.to_vec());
    }

    /// Get all logs from the plugin's execution
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    #[must_use]
    pub fn logs(&self) -> Vec<(LogLevel, String)> {
        self.store.data().logs.lock().unwrap().clone()
    }

    /// Clear all logs
    ///
    /// # Panics
    ///
    /// Panics if the internal mutex is poisoned.
    pub fn clear_logs(&self) {
        self.store.data().logs.lock().unwrap().clear();
    }
}

// =============================================================================
// Tests
// =============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    // -------------------------------------------------------------------------
    // TestHost Builder Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_host_builder_new() {
        let host = TestHost::new();
        assert!(host.is_ok(), "Failed to create TestHost: {host:?}");
    }

    #[test]
    fn test_host_builder_with_config() {
        let host = TestHost::new()
            .unwrap()
            .with_config("key1", "value1")
            .with_config("key2", "value2");

        assert_eq!(host.mock_config.get("key1"), Some(&"value1".to_string()));
        assert_eq!(host.mock_config.get("key2"), Some(&"value2".to_string()));
    }

    #[test]
    fn test_host_builder_with_configs() {
        let host = TestHost::new()
            .unwrap()
            .with_configs([("a", "1"), ("b", "2"), ("c", "3")]);

        assert_eq!(host.mock_config.len(), 3);
        assert_eq!(host.mock_config.get("a"), Some(&"1".to_string()));
        assert_eq!(host.mock_config.get("b"), Some(&"2".to_string()));
        assert_eq!(host.mock_config.get("c"), Some(&"3".to_string()));
    }

    #[test]
    fn test_host_builder_with_kv() {
        let host = TestHost::new()
            .unwrap()
            .with_kv("bucket1", "key1", b"value1")
            .with_kv_string("bucket2", "key2", "value2");

        assert_eq!(
            host.mock_kv
                .get(&("bucket1".to_string(), "key1".to_string())),
            Some(&b"value1".to_vec())
        );
        assert_eq!(
            host.mock_kv
                .get(&("bucket2".to_string(), "key2".to_string())),
            Some(&b"value2".to_vec())
        );
    }

    #[test]
    fn test_host_builder_with_secret() {
        let host = TestHost::new()
            .unwrap()
            .with_secret("api_key", "secret123")
            .with_secret("db_password", "password456");

        assert_eq!(
            host.mock_secrets.get("api_key"),
            Some(&"secret123".to_string())
        );
        assert_eq!(
            host.mock_secrets.get("db_password"),
            Some(&"password456".to_string())
        );
    }

    #[test]
    fn test_host_builder_with_plugin_id() {
        let host = TestHost::new().unwrap().with_plugin_id("my-plugin");

        assert_eq!(host.plugin_id, "my-plugin");
    }

    #[test]
    fn test_host_builder_with_limits() {
        let host = TestHost::new()
            .unwrap()
            .with_max_value_size(1024)
            .with_max_keys(100);

        assert_eq!(host.max_value_size, 1024);
        assert_eq!(host.max_keys, 100);
    }

    #[test]
    fn test_host_builder_with_log_level() {
        let host = TestHost::new().unwrap().with_min_log_level(LogLevel::Warn);

        assert_eq!(host.min_log_level, LogLevel::Warn);
    }

    // -------------------------------------------------------------------------
    // Log Capture Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_host_log_capture() {
        let host = TestHost::new().unwrap();

        // Manually add logs via the shared Arc
        {
            let mut logs = host.logs.lock().unwrap();
            logs.push((LogLevel::Info, "test message 1".to_string()));
            logs.push((LogLevel::Warn, "test message 2".to_string()));
            logs.push((LogLevel::Error, "test message 3".to_string()));
        }

        let logs = host.logs();
        assert_eq!(logs.len(), 3);
        assert_eq!(logs[0], (LogLevel::Info, "test message 1".to_string()));
        assert_eq!(logs[1], (LogLevel::Warn, "test message 2".to_string()));
        assert_eq!(logs[2], (LogLevel::Error, "test message 3".to_string()));
    }

    #[test]
    fn test_host_clear_logs() {
        let host = TestHost::new().unwrap();

        {
            let mut logs = host.logs.lock().unwrap();
            logs.push((LogLevel::Info, "message".to_string()));
        }

        assert_eq!(host.log_count(), 1);
        host.clear_logs();
        assert_eq!(host.log_count(), 0);
    }

    #[test]
    fn test_host_logs_at_level() {
        let host = TestHost::new().unwrap();

        {
            let mut logs = host.logs.lock().unwrap();
            logs.push((LogLevel::Info, "info 1".to_string()));
            logs.push((LogLevel::Warn, "warn 1".to_string()));
            logs.push((LogLevel::Info, "info 2".to_string()));
            logs.push((LogLevel::Error, "error 1".to_string()));
        }

        let info_logs = host.logs_at_level(LogLevel::Info);
        assert_eq!(info_logs.len(), 2);
        assert_eq!(info_logs[0], "info 1");
        assert_eq!(info_logs[1], "info 2");

        let warn_logs = host.logs_at_level(LogLevel::Warn);
        assert_eq!(warn_logs.len(), 1);
        assert_eq!(warn_logs[0], "warn 1");
    }

    #[test]
    fn test_host_has_log_containing() {
        let host = TestHost::new().unwrap();

        {
            let mut logs = host.logs.lock().unwrap();
            logs.push((LogLevel::Info, "user login successful".to_string()));
            logs.push((LogLevel::Warn, "rate limit exceeded".to_string()));
        }

        assert!(host.has_log_containing("login"));
        assert!(host.has_log_containing("rate limit"));
        assert!(!host.has_log_containing("error"));
    }

    // -------------------------------------------------------------------------
    // TestHostState Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_host_state_config() {
        let mut config = HashMap::new();
        config.insert("key1".to_string(), "value1".to_string());
        config.insert("prefix.a".to_string(), "1".to_string());
        config.insert("prefix.b".to_string(), "2".to_string());

        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config,
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        assert_eq!(state.config_get("key1"), Some("value1".to_string()));
        assert_eq!(state.config_get("nonexistent"), None);

        let prefix_configs = state.config_get_prefix("prefix.");
        assert_eq!(prefix_configs.len(), 2);

        let all_config = state.config_get_all();
        assert!(all_config.contains("key1"));
    }

    #[test]
    fn test_host_state_kv() {
        let mut state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        // Set and get
        state.kv_set("key1", b"value1").unwrap();
        assert_eq!(state.kv_get("key1").unwrap(), Some(b"value1".to_vec()));
        assert!(state.kv_exists("key1"));

        // Delete
        assert!(state.kv_delete("key1").unwrap());
        assert!(!state.kv_exists("key1"));

        // List keys
        state.kv_set("prefix/a", b"1").unwrap();
        state.kv_set("prefix/b", b"2").unwrap();
        state.kv_set("other", b"3").unwrap();

        let keys = state.kv_list_keys("prefix/").unwrap();
        assert_eq!(keys.len(), 2);
    }

    #[test]
    fn test_host_state_kv_increment() {
        let mut state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        assert_eq!(state.kv_increment("counter", 5).unwrap(), 5);
        assert_eq!(state.kv_increment("counter", 3).unwrap(), 8);
        assert_eq!(state.kv_increment("counter", -2).unwrap(), 6);
    }

    #[test]
    fn test_host_state_kv_cas() {
        let mut state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        // CAS on non-existent key with None expected
        assert!(state.kv_compare_and_swap("key", None, b"value1").unwrap());

        // CAS with correct expected value
        assert!(state
            .kv_compare_and_swap("key", Some(b"value1"), b"value2")
            .unwrap());

        // CAS with wrong expected value
        assert!(!state
            .kv_compare_and_swap("key", Some(b"wrong"), b"value3")
            .unwrap());
    }

    #[test]
    fn test_host_state_secrets() {
        let mut secrets = HashMap::new();
        secrets.insert("api_key".to_string(), "secret123".to_string());

        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets,
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        assert_eq!(
            state.secret_get("api_key").unwrap(),
            Some("secret123".to_string())
        );
        assert_eq!(state.secret_get("nonexistent").unwrap(), None);
        assert!(state.secret_exists("api_key"));
        assert!(!state.secret_exists("nonexistent"));

        let names = state.secret_list_names();
        assert_eq!(names.len(), 1);
        assert!(names.contains(&"api_key".to_string()));
    }

    #[test]
    fn test_host_state_logging() {
        let logs = Arc::new(Mutex::new(Vec::new()));

        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::clone(&logs),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Debug,
        };

        // Log at various levels
        state.log(LogLevel::Trace, "trace message"); // Below min level
        state.log(LogLevel::Debug, "debug message");
        state.log(LogLevel::Info, "info message");
        state.log(LogLevel::Warn, "warn message");
        state.log(LogLevel::Error, "error message");

        let captured = logs.lock().unwrap();
        // Trace should be filtered out
        assert_eq!(captured.len(), 4);
        assert_eq!(captured[0], (LogLevel::Debug, "debug message".to_string()));
    }

    #[test]
    fn test_host_state_structured_logging() {
        let logs = Arc::new(Mutex::new(Vec::new()));

        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::clone(&logs),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        state.log_structured(
            LogLevel::Info,
            "request handled",
            &[
                ("method".to_string(), "GET".to_string()),
                ("path".to_string(), "/api".to_string()),
            ],
        );

        let captured = logs.lock().unwrap();
        assert_eq!(captured.len(), 1);
        assert!(captured[0].1.contains("request handled"));
        assert!(captured[0].1.contains("method=GET"));
        assert!(captured[0].1.contains("path=/api"));
    }

    #[test]
    fn test_host_state_log_is_enabled() {
        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Warn,
        };

        assert!(!state.log_is_enabled(LogLevel::Trace));
        assert!(!state.log_is_enabled(LogLevel::Debug));
        assert!(!state.log_is_enabled(LogLevel::Info));
        assert!(state.log_is_enabled(LogLevel::Warn));
        assert!(state.log_is_enabled(LogLevel::Error));
    }

    // -------------------------------------------------------------------------
    // Key Validation Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_validate_key_valid() {
        assert!(validate_key("simple").is_ok());
        assert!(validate_key("with-dash").is_ok());
        assert!(validate_key("with_underscore").is_ok());
        assert!(validate_key("with.dot").is_ok());
        assert!(validate_key("with/slash").is_ok());
        assert!(validate_key("with:colon").is_ok());
        assert!(validate_key("path/to/key:123").is_ok());
    }

    #[test]
    fn test_validate_key_invalid() {
        // Empty key
        assert!(matches!(validate_key(""), Err(KvError::InvalidKey)));

        // Key too long
        let long_key = "a".repeat(2000);
        assert!(matches!(validate_key(&long_key), Err(KvError::InvalidKey)));

        // Invalid characters
        assert!(matches!(
            validate_key("with space"),
            Err(KvError::InvalidKey)
        ));
        assert!(matches!(
            validate_key("with\ttab"),
            Err(KvError::InvalidKey)
        ));
        assert!(matches!(
            validate_key("with\nnewline"),
            Err(KvError::InvalidKey)
        ));
    }

    // -------------------------------------------------------------------------
    // Error Type Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_error_display() {
        let err = TestError::EngineCreation("test".to_string());
        assert!(err.to_string().contains("wasmtime engine"));

        let err = TestError::Compilation("syntax error".to_string());
        assert!(err.to_string().contains("compile"));

        let err = TestError::FileRead {
            path: "/test.wasm".to_string(),
            reason: "not found".to_string(),
        };
        assert!(err.to_string().contains("/test.wasm"));
        assert!(err.to_string().contains("not found"));

        let err = TestError::FunctionCall {
            function: "init".to_string(),
            reason: "trap".to_string(),
        };
        assert!(err.to_string().contains("init"));
        assert!(err.to_string().contains("trap"));
    }

    // -------------------------------------------------------------------------
    // PluginInfo Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_plugin_info_default() {
        let info = PluginInfo::default();
        assert!(info.id.is_empty());
        assert!(info.name.is_empty());
        assert_eq!(info.version.major, 0);
        assert!(info.license.is_none());
        assert!(info.metadata.is_empty());
    }

    #[test]
    fn test_version_display() {
        let version = Version {
            major: 1,
            minor: 2,
            patch: 3,
            pre_release: None,
        };
        assert_eq!(version.to_string(), "1.2.3");

        let version_pre = Version {
            major: 2,
            minor: 0,
            patch: 0,
            pre_release: Some("beta.1".to_string()),
        };
        assert_eq!(version_pre.to_string(), "2.0.0-beta.1");
    }

    // -------------------------------------------------------------------------
    // Debug Format Tests
    // -------------------------------------------------------------------------

    #[test]
    fn test_test_host_debug() {
        let host = TestHost::new()
            .unwrap()
            .with_config("key", "value")
            .with_plugin_id("my-plugin");

        let debug = format!("{host:?}");
        assert!(debug.contains("TestHost"));
        assert!(debug.contains("my-plugin"));
    }

    #[test]
    fn test_test_host_state_debug() {
        let state = TestHostState {
            wasi_ctx: WasiCtxBuilder::new().build(),
            table: ResourceTable::new(),
            config: HashMap::new(),
            kv: HashMap::new(),
            secrets: HashMap::new(),
            logs: Arc::new(Mutex::new(Vec::new())),
            plugin_id: "test".to_string(),
            max_value_size: 1024,
            max_keys: 100,
            min_log_level: LogLevel::Trace,
        };

        let debug = format!("{state:?}");
        assert!(debug.contains("TestHostState"));
        assert!(debug.contains("test"));
    }
}