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

use super::*;

impl MirInterpreter {
    pub(super) fn handle_extern_call(
        &mut self,
        dst: Option<ValueId>,
        iface: &str,
        method: &str,
        args: &[ValueId],
    ) -> Result<(), VMError> {
        match (iface, method) {
            ("env", "get") => {
                if let Some(a0) = args.get(0) {
                    let key = self.reg_load(*a0)?.to_string();
                    let val = std::env::var(&key).ok();
                    if let Some(d) = dst {
                        if let Some(s) = val {
                            self.regs.insert(d, VMValue::String(s));
                        } else {
                            // Represent missing env as null-equivalent (Void)
                            self.regs.insert(d, VMValue::Void);
                        }
                    }
                }
                Ok(())
            }
            ("env.console", "log") => {
                if let Some(a0) = args.get(0) {
                    let v = self.reg_load(*a0)?;
                    // Dev-only: mirror print-trace for extern console.log
                    if Self::print_trace_enabled() { self.print_trace_emit(&v); }
                    // Treat VM Void and BoxRef(VoidBox) as JSON null for dev ergonomics
                    match &v {
                        VMValue::Void => { println!("null"); if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(()); }
                        VMValue::BoxRef(bx) => {
                            if bx.as_any().downcast_ref::<crate::box_trait::VoidBox>().is_some() {
                                println!("null"); if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(());
                            }
                            if let Some(sb) = bx.as_any().downcast_ref::<crate::box_trait::StringBox>() {
                                println!("{}", sb.value); if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(());
                            }
                        }
                        VMValue::String(s) => { println!("{}", s); if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(()); }
                        _ => {}
                    }
                    // Operator Box (Stringify) – dev flag gated
                    if std::env::var("NYASH_OPERATOR_BOX_STRINGIFY").ok().as_deref() == Some("1") {
                        if let Some(op) = self.functions.get("StringifyOperator.apply/1").cloned() {
                            let out = self.exec_function_inner(&op, Some(&[v.clone()]))?;
                            println!("{}", out.to_string());
                        } else {
                            println!("{}", v.to_string());
                        }
                    } else {
                        println!("{}", v.to_string());
                    }
                }
                if let Some(d) = dst { self.regs.insert(d, VMValue::Void); }
                Ok(())
            }
            ("env.future", "new") => {
                let fut = crate::boxes::future::NyashFutureBox::new();
                if let Some(a0) = args.get(0) {
                    let v = self.reg_load(*a0)?;
                    fut.set_result(v.to_nyash_box());
                }
                if let Some(d) = dst {
                    self.regs.insert(d, VMValue::Future(fut));
                }
                Ok(())
            }
            ("env.future", "set") => {
                if args.len() >= 2 {
                    let f = self.reg_load(args[0])?;
                    let v = self.reg_load(args[1])?;
                    if let VMValue::Future(fut) = f {
                        fut.set_result(v.to_nyash_box());
                    } else {
                        return Err(VMError::TypeError("env.future.set expects Future".into()));
                    }
                }
                if let Some(d) = dst {
                    self.regs.insert(d, VMValue::Void);
                }
                Ok(())
            }
            ("env.future", "await") => {
                if let Some(a0) = args.get(0) {
                    let f = self.reg_load(*a0)?;
                    match f {
                        VMValue::Future(fut) => {
                            let v = fut.get();
                            if let Some(d) = dst {
                                self.regs.insert(d, VMValue::from_nyash_box(v));
                            }
                        }
                        _ => {
                            return Err(VMError::TypeError("await expects Future".into()));
                        }
                    }
                }
                Ok(())
            }
            ("env.runtime", "checkpoint") => {
                crate::runtime::global_hooks::safepoint_and_poll();
                if let Some(d) = dst {
                    self.regs.insert(d, VMValue::Void);
                }
                Ok(())
            }
            ("env.modules", "set") => {
                if args.len() >= 2 {
                    let k = self.reg_load(args[0])?.to_string();
                    let v = self.reg_load(args[1])?.to_nyash_box();
                    crate::runtime::modules_registry::set(k, v);
                }
                if let Some(d) = dst {
                    self.regs.insert(d, VMValue::Void);
                }
                Ok(())
            }
            ("env.modules", "get") => {
                if let Some(a0) = args.get(0) {
                    let k = self.reg_load(*a0)?.to_string();
                    let vb = crate::runtime::modules_registry::get(&k)
                        .unwrap_or_else(|| Box::new(crate::box_trait::VoidBox::new()));
                    if let Some(d) = dst {
                        self.regs.insert(d, VMValue::from_nyash_box(vb));
                    }
                }
                Ok(())
            }
            ("env", "get") => {
                // env.get(key) - get environment variable
                if let Some(a0) = args.get(0) {
                    let k = self.reg_load(*a0)?.to_string();
                    let val = std::env::var(&k).ok();
                    if let Some(d) = dst {
                        if let Some(v) = val {
                            self.regs.insert(d, VMValue::String(v));
                        } else {
                            self.regs.insert(d, VMValue::from_nyash_box(Box::new(crate::box_trait::VoidBox::new())));
                        }
                    }
                }
                Ok(())
            }
            ("env.mirbuilder", "emit") => {
                // program_json -> mir_json (delegate provider)
                if let Some(a0) = args.get(0) {
                    let program_json = self.reg_load(*a0)?.to_string();
                    match crate::host_providers::mir_builder::program_json_to_mir_json(&program_json) {
                        Ok(s) => {
                            if let Some(d) = dst { self.regs.insert(d, VMValue::String(s)); }
                            Ok(())
                        }
                        Err(e) => Err(VMError::InvalidInstruction(format!("env.mirbuilder.emit: {}", e))),
                    }
                } else {
                    Err(VMError::InvalidInstruction("env.mirbuilder.emit expects 1 arg".into()))
                }
            }
            ("env.codegen", "emit_object") => {
                // mir_json -> object path (ny-llvmc or harness)
                if let Some(a0) = args.get(0) {
                    let mir_json = self.reg_load(*a0)?.to_string();
                    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(&mir_json, opts) {
                        Ok(p) => {
                            if let Some(d) = dst { self.regs.insert(d, VMValue::String(p.to_string_lossy().into_owned())); }
                            Ok(())
                        }
                        Err(e) => Err(VMError::InvalidInstruction(format!("env.codegen.emit_object: {}", e))),
                    }
                } else {
                    Err(VMError::InvalidInstruction("env.codegen.emit_object expects 1 arg".into()))
                }
            }
            ("hostbridge", "extern_invoke") => {
                // hostbridge.extern_invoke(name, method, args?)
                if args.len() < 2 {
                    return Err(VMError::InvalidInstruction(
                        "extern_invoke expects at least 2 args".into(),
                    ));
                }
                let name = self.reg_load(args[0])?.to_string();
                let method = self.reg_load(args[1])?.to_string();

                // Extract first payload argument as string if provided.
                // MirBuilder uses: extern_invoke("env.mirbuilder","emit", [program_json])
                let mut first_arg_str: Option<String> = None;
                if let Some(a2) = args.get(2) {
                    let v = self.reg_load(*a2)?;
                    match v {
                        VMValue::BoxRef(b) => {
                            // If it's an ArrayBox, read element[0]
                            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 {
                                // Fallback: stringify the box
                                first_arg_str = Some(b.to_string_box().value);
                            }
                        }
                        // For primitive VM values, use their string form
                        _ => first_arg_str = Some(v.to_string()),
                    }
                }

                // Dispatch to known providers
                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) => {
                                    if let Some(d) = dst {
                                        self.regs.insert(d, VMValue::String(out));
                                    }
                                    Ok(())
                                }
                                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) => {
                                    if let Some(d) = dst {
                                        self.regs.insert(
                                            d,
                                            VMValue::String(p.to_string_lossy().into_owned()),
                                        );
                                    }
                                    Ok(())
                                }
                                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
                    ))),
                }
            }
            _ => Err(VMError::InvalidInstruction(format!(
                "ExternCall {}.{} not supported",
                iface, method
            ))),
        }
    }
}