hakorune/src/bin/test_plugin_loader_v2.rs

//! Test program for v2 plugin loader (Phase 12 prep)

use nyash_rust::config::NyashConfigV2;
use nyash_rust::runtime::{get_global_loader_v2, init_global_loader_v2};

fn main() {
    env_logger::init();

    println!("=== v2 Plugin Loader Test (Phase 12 prep) ===\n");

    // Load configuration
    let config_path = "test_nyash_v2.toml";
    println!("Loading configuration from: {}", config_path);

    let config = match NyashConfigV2::from_file(config_path) {
        Ok(cfg) => cfg,
        Err(e) => {
            eprintln!("Failed to load config: {}", e);
            return;
        }
    };

    println!("Configuration loaded successfully!");
    println!("Is v2 format: {}", config.is_v2_format());

    if let Some(libs) = &config.plugins.libraries {
        println!("\nLibraries found:");
        for (name, lib) in libs {
            println!("  {} -> {}", name, lib.plugin_path);
            println!("    Provides: {:?}", lib.provides);
        }
    }

    // Initialize and load plugins
    println!("\nLoading plugins...");
    if let Err(e) = init_global_loader_v2(config_path) {
        eprintln!("Failed to init loader: {:?}", e);
        return;
    }
    let loader = get_global_loader_v2();
    let loader = loader.read().unwrap();

    // Test box type resolution
    println!("\nTesting box type resolution:");
    for box_type in ["StringBox", "FileBox", "MapBox"] {
        match config.find_library_for_box(box_type) {
            Some((name, lib)) => {
                println!("  {} -> library: {} (path={})", box_type, name, lib.path)
            }
            None => println!("  {} -> not found in config", box_type),
        }
    }

    // Optional: try creating a simple box via loader API (if present)
    if let Ok(bx) = loader.create_box("StringBox", &[]) {
        println!("Created box: {}", bx.to_string_box().value);
    } else {
        println!("create_box(StringBox) not available or failed (ok for stub)");
    }

    // Simple reverse host-call exercise (simulate plugin calling host via C ABI by-slot)
    println!("\nReverse host-call (by-slot) quick test:");
    // Create ArrayBox and obtain HostHandle
    let mut arr = nyash_rust::boxes::ArrayBox::new();
    arr.push(Box::new(nyash_rust::box_trait::StringBox::new("init"))
        as Box<dyn nyash_rust::box_trait::NyashBox>);
    let handle = nyash_rust::runtime::host_handles::to_handle_box(Box::new(arr));
    // Call Array.set(0, "hello") via slot=101
    let mut tlv = nyash_rust::runtime::plugin_ffi_common::encode_tlv_header(2);
    nyash_rust::runtime::plugin_ffi_common::encode::i64(&mut tlv, 0);
    nyash_rust::runtime::plugin_ffi_common::encode::string(&mut tlv, "hello");
    let mut out = vec![0u8; 256];
    let mut out_len: usize = out.len();
    let code = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            handle,
            101,
            tlv.as_ptr(),
            tlv.len(),
            out.as_mut_ptr(),
            &mut out_len,
        )
    };
    println!("  set(slot=101) -> code={}, out_len={}", code, out_len);
    // Call Array.get(0) via slot=100 and decode
    let mut tlv2 = nyash_rust::runtime::plugin_ffi_common::encode_tlv_header(1);
    nyash_rust::runtime::plugin_ffi_common::encode::i64(&mut tlv2, 0);
    let mut out2 = vec![0u8; 256];
    let mut out2_len: usize = out2.len();
    let code2 = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            handle,
            100,
            tlv2.as_ptr(),
            tlv2.len(),
            out2.as_mut_ptr(),
            &mut out2_len,
        )
    };
    if code2 == 0 {
        if let Some((tag, _sz, payload)) =
            nyash_rust::runtime::plugin_ffi_common::decode::tlv_first(&out2[..out2_len])
        {
            if tag == 6 || tag == 7 {
                // string/bytes
                let s = nyash_rust::runtime::plugin_ffi_common::decode::string(payload);
                println!("  get(slot=100) -> tag={}, value='{}'", tag, s);
            } else if tag == 3 {
                // i64
                let v = nyash_rust::runtime::plugin_ffi_common::decode::i32(payload)
                    .unwrap_or_default();
                println!("  get(slot=100) -> tag={}, i32={}", tag, v);
            } else {
                println!("  get(slot=100) -> tag={}, size={}", tag, _sz);
            }
        }
    } else {
        println!("  get(slot=100) failed with code {}", code2);
    }

    // MapBox slots test: set/get/has/size
    println!("\nReverse host-call (by-slot) MapBox test:");
    let map = nyash_rust::boxes::map_box::MapBox::new();
    let map_h = nyash_rust::runtime::host_handles::to_handle_box(Box::new(map));
    // set("k","v") → slot=204
    let mut tlv_set = nyash_rust::runtime::plugin_ffi_common::encode_tlv_header(2);
    nyash_rust::runtime::plugin_ffi_common::encode::string(&mut tlv_set, "k");
    nyash_rust::runtime::plugin_ffi_common::encode::string(&mut tlv_set, "v");
    let mut out_s = vec![0u8; 256];
    let mut out_s_len: usize = out_s.len();
    let code_s = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            map_h,
            204,
            tlv_set.as_ptr(),
            tlv_set.len(),
            out_s.as_mut_ptr(),
            &mut out_s_len,
        )
    };
    println!("  set(slot=204) -> code={}, out_len={}", code_s, out_s_len);
    // get("k") → slot=203
    let mut tlv_get = nyash_rust::runtime::plugin_ffi_common::encode_tlv_header(1);
    nyash_rust::runtime::plugin_ffi_common::encode::string(&mut tlv_get, "k");
    let mut out_g = vec![0u8; 256];
    let mut out_g_len: usize = out_g.len();
    let code_g = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            map_h,
            203,
            tlv_get.as_ptr(),
            tlv_get.len(),
            out_g.as_mut_ptr(),
            &mut out_g_len,
        )
    };
    if code_g == 0 {
        if let Some((tag, _sz, payload)) =
            nyash_rust::runtime::plugin_ffi_common::decode::tlv_first(&out_g[..out_g_len])
        {
            if tag == 6 || tag == 7 {
                let s = nyash_rust::runtime::plugin_ffi_common::decode::string(payload);
                println!("  get(slot=203) -> '{}'", s);
            } else {
                println!("  get(slot=203) -> tag={}, size={}", tag, _sz);
            }
        }
    }
    // has("k") → slot=202
    let mut out_hb = vec![0u8; 16];
    let mut out_hb_len: usize = out_hb.len();
    let code_hb = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            map_h,
            202,
            tlv_get.as_ptr(),
            tlv_get.len(),
            out_hb.as_mut_ptr(),
            &mut out_hb_len,
        )
    };
    println!(
        "  has(slot=202) -> code={}, out_len={}",
        code_hb, out_hb_len
    );
    // size() → slot=200
    let mut out_sz = vec![0u8; 32];
    let mut out_sz_len: usize = out_sz.len();
    let code_sz = unsafe {
        nyash_rust::runtime::host_api::nyrt_host_call_slot(
            map_h,
            200,
            std::ptr::null(),
            0,
            out_sz.as_mut_ptr(),
            &mut out_sz_len,
        )
    };
    println!(
        "  size(slot=200) -> code={}, out_len={}",
        code_sz, out_sz_len
    );

    println!("\nTest completed!");
}