hakorune/plugins/nyash-egui-plugin/src/lib.rs

//! Nyash EguiBox Plugin (TypeBox ABI skeleton)
//! - Provides a minimal window/UI placeholder via Nyash ABI
//! - Windows GUI integration (egui/eframe) can be enabled later via `with-egui` feature

use once_cell::sync::Lazy;
use std::{collections::HashMap, sync::{Mutex, atomic::{AtomicU32, Ordering}}};

// ===== Error/Status codes (BID-FFI v1 aligned) =====
const OK: i32 = 0;
const E_SHORT: i32 = -1;
const E_TYPE: i32 = -2;
const E_METHOD: i32 = -3;
const E_ARGS: i32 = -4;
const E_FAIL: i32 = -5;

// ===== IDs =====
const TID_EGUI: u32 = 70; // match nyash.toml [box_types]

// methods
const M_BIRTH: u32 = 0;
const M_OPEN: u32 = 1;       // open(width:int, height:int, title:str)
const M_UI_LABEL: u32 = 2;   // uiLabel(text:str)
const M_UI_BUTTON: u32 = 3;  // uiButton(text:str) -> future: events
const M_POLL_EVENT: u32 = 4; // pollEvent() -> Result.Ok(text) / Result.Err("none")
const M_RUN: u32 = 5;        // run() -> enters loop or no-op
const M_CLOSE: u32 = 6;      // close()
const M_FINI: u32 = u32::MAX;

#[derive(Default)]
struct EguiInstance {
    width: i32,
    height: i32,
    title: String,
    labels: Vec<String>,
}

static INST: Lazy<Mutex<HashMap<u32, EguiInstance>>> = Lazy::new(|| Mutex::new(HashMap::new()));
static NEXT_ID: AtomicU32 = AtomicU32::new(1);

// ===== TypeBox ABI (resolve/invoke_id) =====
#[repr(C)]
pub struct NyashTypeBoxFfi {
    pub abi_tag: u32,
    pub version: u16,
    pub struct_size: u16,
    pub name: *const std::os::raw::c_char,
    pub resolve: Option<extern "C" fn(*const std::os::raw::c_char) -> u32>,
    pub invoke_id: Option<extern "C" fn(u32, u32, *const u8, usize, *mut u8, *mut usize) -> i32>,
    pub capabilities: u64,
}

// This simple POD struct contains raw pointers; mark as Sync for static export
unsafe impl Sync for NyashTypeBoxFfi {}

const ABI_TAG: u32 = 0x58594254; // 'T''Y''B''X' little-endian (TYBX)

extern "C" fn tb_resolve(name: *const std::os::raw::c_char) -> u32 {
    unsafe {
        if name.is_null() { return 0; }
        let s = std::ffi::CStr::from_ptr(name).to_string_lossy();
        match s.as_ref() {
            "birth" => M_BIRTH,
            "open" => M_OPEN,
            "uiLabel" => M_UI_LABEL,
            "uiButton" => M_UI_BUTTON,
            "pollEvent" => M_POLL_EVENT,
            "run" => M_RUN,
            "close" => M_CLOSE,
            "fini" => M_FINI,
            _ => 0,
        }
    }
}

extern "C" fn tb_invoke_id(_method_id: u32, instance_id: u32, args: *const u8, args_len: usize, result: *mut u8, result_len: *mut usize) -> i32 {
    nyash_plugin_invoke(TID_EGUI, _method_id, instance_id, args, args_len, result, result_len)
}

static TYPE_NAME: &[u8] = b"EguiBox\0";
#[no_mangle]
pub static nyash_typebox_EguiBox: NyashTypeBoxFfi = NyashTypeBoxFfi {
    abi_tag: ABI_TAG,
    version: 1,
    struct_size: std::mem::size_of::<NyashTypeBoxFfi>() as u16,
    name: TYPE_NAME.as_ptr() as *const _,
    resolve: Some(tb_resolve),
    invoke_id: Some(tb_invoke_id),
    capabilities: 0,
};

// ===== Plugin entry points =====
#[no_mangle]
pub extern "C" fn nyash_plugin_abi() -> u32 { 1 }

#[no_mangle]
pub extern "C" fn nyash_plugin_init() -> i32 { OK }

#[no_mangle]
pub extern "C" fn nyash_plugin_invoke(
    type_id: u32,
    method_id: u32,
    instance_id: u32,
    args: *const u8,
    args_len: usize,
    result: *mut u8,
    result_len: *mut usize,
) -> i32 {
    if type_id != TID_EGUI { return E_TYPE; }
    unsafe {
        match method_id {
            M_BIRTH => {
                let need = 4; // instance_id (u32 LE)
                if result_len.is_null() { return E_ARGS; }
                if result.is_null() || *result_len < need { *result_len = need; return E_SHORT; }
                let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
                if let Ok(mut m) = INST.lock() { m.insert(id, EguiInstance::default()); } else { return E_FAIL; }
                let b = id.to_le_bytes(); std::ptr::copy_nonoverlapping(b.as_ptr(), result, 4); *result_len = 4; OK
            }
            M_FINI => { if let Ok(mut m) = INST.lock() { m.remove(&instance_id); OK } else { E_FAIL } }
            M_OPEN => {
                eprintln!("[EGUI] M_OPEN invoked");
                let (w, h, title) = match tlv_read_open_args(args, args_len) { Some(v) => v, None => return E_ARGS };
                if let Ok(mut m) = INST.lock() { if let Some(inst) = m.get_mut(&instance_id) { inst.width=w; inst.height=h; inst.title=title; } else { return E_FAIL; } } else { return E_FAIL; }
                write_tlv_void(result, result_len)
            }
            M_UI_LABEL => {
                eprintln!("[EGUI] M_UI_LABEL invoked");
                let text = match tlv_read_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
                if let Ok(mut m) = INST.lock() { if let Some(inst) = m.get_mut(&instance_id) { inst.labels.push(text); } else { return E_FAIL; } } else { return E_FAIL; }
                write_tlv_void(result, result_len)
            }
            M_UI_BUTTON => {
                eprintln!("[EGUI] M_UI_BUTTON invoked");
                // For now: stub, accept and return Void
                if tlv_read_string(args, args_len, 0).is_none() { return E_ARGS; }
                write_tlv_void(result, result_len)
            }
            M_POLL_EVENT => {
                eprintln!("[EGUI] M_POLL_EVENT invoked");
                // Stub: no events yet → return empty string "" (Ok)
                write_tlv_string("", result, result_len)
            }
            M_RUN => {
                eprintln!("[EGUI] M_RUN invoked");
                // with-egui: 実ウィンドウを表示（クロスプラットフォーム）
                #[cfg(feature = "with-egui")]
                {
                    if let Ok(m) = INST.lock() {
                        if let Some(inst) = m.get(&instance_id) {
                            guirun::run_window(inst.width, inst.height, &inst.title, inst.labels.clone());
                        }
                    }
                }
                // それ以外はスタブ
                write_tlv_void(result, result_len)
            }
            M_CLOSE => {
                // Stub: no-op close
                write_tlv_void(result, result_len)
            }
            _ => E_METHOD,
        }
    }
}

// ===== TLV helpers (version=1) =====
fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut usize) -> i32 {
    if result_len.is_null() { return E_ARGS; }
    let mut buf: Vec<u8> = Vec::with_capacity(4 + payloads.iter().map(|(_,p)| 4 + p.len()).sum::<usize>());
    buf.extend_from_slice(&1u16.to_le_bytes());
    buf.extend_from_slice(&(payloads.len() as u16).to_le_bytes());
    for (tag, payload) in payloads {
        buf.push(*tag); buf.push(0); buf.extend_from_slice(&(payload.len() as u16).to_le_bytes()); buf.extend_from_slice(payload);
    }
    unsafe {
        let need = buf.len();
        if result.is_null() || *result_len < need { *result_len = need; return E_SHORT; }
        std::ptr::copy_nonoverlapping(buf.as_ptr(), result, need);
        *result_len = need;
    }
    OK
}
fn write_tlv_void(result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(9u8, &[])], result, result_len) }
fn write_tlv_string(s: &str, result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(6u8, s.as_bytes())], result, result_len) }

unsafe fn tlv_parse_header(data: *const u8, len: usize) -> Option<(u16,u16,usize)> {
    if data.is_null() || len < 4 { return None; }
    let b = std::slice::from_raw_parts(data, len);
    let ver = u16::from_le_bytes([b[0], b[1]]);
    let argc = u16::from_le_bytes([b[2], b[3]]);
    if ver != 1 { return None; }
    Some((ver, argc, 4))
}
unsafe fn tlv_read_entry_at(data: *const u8, len: usize, mut pos: usize) -> Option<(u8, usize, usize)> {
    let b = std::slice::from_raw_parts(data, len);
    if pos + 4 > len { return None; }
    let tag = b[pos]; let _ = b[pos+1]; let size = u16::from_le_bytes([b[pos+2], b[pos+3]]) as usize; pos += 4;
    if pos + size > len { return None; }
    Some((tag, size, pos))
}
unsafe fn tlv_read_i64(data: *const u8, len: usize, index: usize) -> Option<i64> {
    let (_, argc, mut pos) = tlv_parse_header(data, len)?; if argc < (index as u16 + 1) { return None; }
    for i in 0..=index { let (tag, size, p) = tlv_read_entry_at(data, len, pos)?; if tag == 3 && size == 8 { if i == index { let b = std::slice::from_raw_parts(data.add(p), 8); let mut t=[0u8;8]; t.copy_from_slice(b); return Some(i64::from_le_bytes(t)); } } pos = p + size; }
    None
}
unsafe fn tlv_read_string(data: *const u8, len: usize, index: usize) -> Option<String> {
    let (_, argc, mut pos) = tlv_parse_header(data, len)?; if argc < (index as u16 + 1) { return None; }
    for i in 0..=index { let (tag, size, p) = tlv_read_entry_at(data, len, pos)?; if tag == 6 || tag == 7 { if i == index { let s = std::slice::from_raw_parts(data.add(p), size); return Some(String::from_utf8_lossy(s).to_string()); } } pos = p + size; }
    None
}
unsafe fn tlv_read_open_args(args: *const u8, len: usize) -> Option<(i32,i32,String)> {
    let w = tlv_read_i64(args, len, 0)? as i32;
    let h = tlv_read_i64(args, len, 1)? as i32;
    let t = tlv_read_string(args, len, 2)?;
    Some((w,h,t))
}

// ===== GUI 実行（with-egui, クロスプラットフォーム） =====
#[cfg(feature = "with-egui")]
mod guirun {
    use super::*;
    use eframe::egui;

    pub fn run_window(w: i32, h: i32, title: &str, labels: Vec<String>) {
        eprintln!("[EGUI] run_window: w={} h={} title='{}'", w, h, title);
        let diag = std::env::var("NYASH_EGUI_DIAG").ok().as_deref() == Some("1");
        let scale_override = std::env::var("NYASH_EGUI_SCALE").ok().and_then(|s| s.parse::<f32>().ok());
        let options = eframe::NativeOptions {
            viewport: egui::ViewportBuilder::default()
                .with_inner_size([w.max(100) as f32, h.max(100) as f32])
                .with_title(title.to_string()),
            ..Default::default()
        };

        struct App { labels: Vec<String>, diag: bool, printed: bool, init_w: i32, init_h: i32, scale: Option<f32> }
        impl eframe::App for App {
            fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
                if self.diag && !self.printed {
                    let ppp = ctx.pixels_per_point();
                    let rect = ctx.screen_rect();
                    let (lw, lh) = (rect.width(), rect.height());
                    let (pw, ph) = ((lw * ppp).round() as i32, (lh * ppp).round() as i32);
                    eprintln!("[EGUI][diag] ppp={:.3} logical={:.1}x{:.1} physical={}x{} init={}x{} scale_override={}",
                        ppp, lw, lh, pw, ph, self.init_w, self.init_h,
                        self.scale.map(|v| format!("{:.3}", v)).unwrap_or_else(|| "<none>".into())
                    );
                    self.printed = true;
                }
                egui::TopBottomPanel::top("diag_bar").show(ctx, |ui| {
                    if self.diag {
                        let ppp = ctx.pixels_per_point();
                        let rect = ctx.screen_rect();
                        ui.small(format!(
                            "DPI: ppp={:.3} logical={:.1}x{:.1} init={}x{} scale={}",
                            ppp, rect.width(), rect.height(), self.init_w, self.init_h,
                            self.scale.map(|v| format!("{:.2}", v)).unwrap_or_else(|| "auto".into())
                        ));
                    }
                });
                egui::CentralPanel::default().show(ctx, |ui| {
                    for s in &self.labels { ui.label(s); }
                });
            }
        }

        let res = eframe::run_native(
            title,
            options,
            Box::new({
                let labels = labels;
                let diag = diag;
                let init_w = w;
                let init_h = h;
                let scale_override = scale_override;
                move |cc| {
                    if let Some(ppp) = scale_override {
                        cc.egui_ctx.set_pixels_per_point(ppp);
                        eprintln!("[EGUI][diag] override pixels_per_point to {:.3}", ppp);
                    }
                    Box::new(App { labels, diag, printed: false, init_w, init_h, scale: scale_override })
                }
            }),
        );
        eprintln!("[EGUI] run_native returned: {:?}", res);
    }
}