hakorune/src/backend/mir_interpreter/handlers/extern_provider.rs

use super::*;
use serde_json::Value as JsonValue;

impl MirInterpreter {
    fn patch_mir_json_version(s: &str) -> String {
        match serde_json::from_str::<JsonValue>(s) {
            Ok(mut v) => {
                if let JsonValue::Object(ref mut m) = v {
                    if !m.contains_key("version") {
                        m.insert("version".to_string(), JsonValue::from(0));
                        if let Ok(out) = serde_json::to_string(&v) { return out; }
                    }
                }
                s.to_string()
            }
            Err(_) => s.to_string(),
        }
    }

    /// Central extern dispatcher used by both execute_extern_function (calls.rs)
    /// and handle_extern_call (externals.rs). Returns a VMValue; callers are
    /// responsible for writing it to registers when needed.
    pub(super) fn extern_provider_dispatch(
        &mut self,
        extern_name: &str,
        args: &[ValueId],
    ) -> Option<Result<VMValue, VMError>> {
        match extern_name {
            // Console/print family (minimal)
            "nyash.console.log" | "env.console.log" | "print" | "nyash.builtin.print" => {
                let s = if let Some(a0) = args.get(0) { self.reg_load(*a0).ok() } else { None };
                if let Some(v) = s { println!("{}", v.to_string()); } else { println!(""); }
                Some(Ok(VMValue::Void))
            }
            // Extern providers (env.mirbuilder / env.codegen)
            "env.mirbuilder.emit" => {
                if args.is_empty() { return Some(Err(VMError::InvalidInstruction("env.mirbuilder.emit expects 1 arg".into()))); }
                let program_json = match self.reg_load(args[0]) { Ok(v) => v.to_string(), Err(e) => return Some(Err(e)) };
                let res = match crate::host_providers::mir_builder::program_json_to_mir_json(&program_json) {
                    Ok(s) => Ok(VMValue::String(Self::patch_mir_json_version(&s))),
                    Err(e) => Err(VMError::InvalidInstruction(format!("env.mirbuilder.emit: {}", e))),
                };
                Some(res)
            }
            "env.codegen.emit_object" => {
                if args.is_empty() { return Some(Err(VMError::InvalidInstruction("env.codegen.emit_object expects 1 arg".into()))); }
                let mir_json = match self.reg_load(args[0]) { Ok(v) => v.to_string(), Err(e) => return Some(Err(e)) };
                let opts = crate::host_providers::llvm_codegen::Opts {
                    out: None,
                    nyrt: std::env::var("NYASH_EMIT_EXE_NYRT").ok().map(std::path::PathBuf::from),
                    opt_level: std::env::var("HAKO_LLVM_OPT_LEVEL").ok(),
                    timeout_ms: None,
                };
                let res = match crate::host_providers::llvm_codegen::mir_json_to_object(&mir_json, opts) {
                    Ok(p) => Ok(VMValue::String(p.to_string_lossy().into_owned())),
                    Err(e) => Err(VMError::InvalidInstruction(format!("env.codegen.emit_object: {}", e))),
                };
                Some(res)
            }
            // Environment
            "env.get" => {
                if args.is_empty() { return Some(Err(VMError::InvalidInstruction("env.get expects 1 arg".into()))); }
                let key = match self.reg_load(args[0]) { Ok(v) => v.to_string(), Err(e) => return Some(Err(e)) };
                let val = std::env::var(&key).ok();
                Some(Ok(match val { Some(s) => VMValue::String(s), None => VMValue::Void }))
            }
            // Legacy global-call form: hostbridge.extern_invoke(name, method, args?)
            "hostbridge.extern_invoke" => {
                if args.len() < 2 {
                    return Some(Err(VMError::InvalidInstruction(
                        "extern_invoke expects at least 2 args".into(),
                    )));
                }
                let name = match self.reg_load(args[0]) { Ok(v) => v.to_string(), Err(e) => return Some(Err(e)) };
                let method = match self.reg_load(args[1]) { Ok(v) => v.to_string(), Err(e) => return Some(Err(e)) };
                // Extract first payload arg (optional)
                let mut first_arg_str: Option<String> = None;
                if let Some(a2) = args.get(2) {
                    let v = match self.reg_load(*a2) { Ok(v) => v, Err(e) => return Some(Err(e)) };
                    match v {
                        VMValue::BoxRef(b) => {
                            if let Some(ab) = b.as_any().downcast_ref::<crate::boxes::array::ArrayBox>() {
                                let idx: Box<dyn crate::box_trait::NyashBox> =
                                    Box::new(crate::box_trait::IntegerBox::new(0));
                                let elem = ab.get(idx);
                                first_arg_str = Some(elem.to_string_box().value);
                            } else {
                                first_arg_str = Some(b.to_string_box().value);
                            }
                        }
                        _ => first_arg_str = Some(v.to_string()),
                    }
                }
                // Dispatch to known providers
                let out = match (name.as_str(), method.as_str()) {
                    ("env.mirbuilder", "emit") => {
                        if let Some(s) = first_arg_str {
                            match crate::host_providers::mir_builder::program_json_to_mir_json(&s) {
                                Ok(out) => Ok(VMValue::String(Self::patch_mir_json_version(&out))),
                                Err(e) => Err(VMError::InvalidInstruction(format!(
                                    "env.mirbuilder.emit: {}",
                                    e
                                ))),
                            }
                        } else {
                            Err(VMError::InvalidInstruction(
                                "extern_invoke env.mirbuilder.emit expects 1 arg".into(),
                            ))
                        }
                    }
                    ("env.codegen", "emit_object") => {
                        if let Some(s) = first_arg_str {
                            let opts = crate::host_providers::llvm_codegen::Opts {
                                out: None,
                                nyrt: std::env::var("NYASH_EMIT_EXE_NYRT").ok().map(std::path::PathBuf::from),
                                opt_level: std::env::var("HAKO_LLVM_OPT_LEVEL").ok(),
                                timeout_ms: None,
                            };
                            match crate::host_providers::llvm_codegen::mir_json_to_object(&s, opts) {
                                Ok(p) => Ok(VMValue::String(p.to_string_lossy().into_owned())),
                                Err(e) => Err(VMError::InvalidInstruction(format!(
                                    "env.codegen.emit_object: {}",
                                    e
                                ))),
                            }
                        } else {
                            Err(VMError::InvalidInstruction(
                                "extern_invoke env.codegen.emit_object expects 1 arg".into(),
                            ))
                        }
                    }
                    _ => Err(VMError::InvalidInstruction(format!(
                        "hostbridge.extern_invoke unsupported for {}.{}",
                        name, method
                    ))),
                };
                Some(out)
            }
            _ => None,
        }
    }
}