plum

// Functions are named camelCase across this project (matching plum-cli, which
// mirrors this file's host-import logic), not Rust's idiomatic snake_case.
#![allow(non_snake_case)]

// Embeds a Plum-compiled wasm module (path supplied via the PLUM_WASM_PATH
// env var at build time by `plum build`) and runs its `main` export under
// wasmtime, so the result is a single native executable with no runtime
// dependency on a `wasmtime` install or a separate .wasm file.
const WASM_BYTES: &[u8] = include_bytes!(env!("PLUM_WASM_PATH"));

/// Builds the `Extern`s that satisfy a compiled Plum module's host imports (today,
/// only `plum::printLn`) in declaration order, matching each one's exact `FuncType`
/// (its `Str` param is a concrete wasm-gc array type, so the host function must be
/// built from the module's own reported type rather than a generic `Rooted<ArrayRef>`
/// wrapper, which would carry the wrong, unrelated top-array type and fail to
/// instantiate).
fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Vec<wasmtime::Extern> {
    module.imports().map(|imp| {
        match (imp.module(), imp.name()) {
            ("plum", "printLn") => {
                let func_ty = imp.ty().func().cloned().expect("plum::printLn import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, _results| {
                    let wasmtime::Val::AnyRef(Some(s)) = &params[0] else {
                        return Err(wasmtime::Error::msg("printLn expects a Str argument"));
                    };
                    let arr = unwrapStrToArray(&mut caller, s)?;
                    let len = arr.len(&caller)?;
                    let mut buf = vec![0u8; len as usize];
                    arr.copy_to_i8_slice(&mut caller, &mut buf)?;
                    println!("{}", String::from_utf8_lossy(&buf));
                    Ok(())
                }))
            }
            ("plum", "rawRandomInt") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawRandomInt import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |_caller, _params, results| {
                    results[0] = wasmtime::Val::I64(randomI64());
                    Ok(())
                }))
            }
            ("plum", "rawNowMillis") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawNowMillis import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |_caller, _params, results| {
                    results[0] = wasmtime::Val::I64(nowMillis());
                    Ok(())
                }))
            }
            ("plum", "rawReadFile") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawReadFile import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let bytes = std::fs::read(&path).unwrap_or_default();
                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, &bytes)?));
                    Ok(())
                }))
            }
            ("plum", "rawWriteFile") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawWriteFile import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let data = readStrArg(&mut caller, &params[1])?;
                    results[0] = wasmtime::Val::I64(std::fs::write(&path, &data).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawExists") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawExists import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    // See the identical `rawExists` in plum-cli for why this uses
                    // `symlink_metadata` rather than `Path::exists`.
                    results[0] = wasmtime::Val::I64(std::fs::symlink_metadata(&path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawMkdir") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawMkdir import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    results[0] = wasmtime::Val::I64(std::fs::create_dir_all(&path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawRemove") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawRemove import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    results[0] = wasmtime::Val::I64(std::fs::remove_file(&path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawRemoveDir") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawRemoveDir import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    results[0] = wasmtime::Val::I64(std::fs::remove_dir(&path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawRename") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawRename import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let old_path = readStrArg(&mut caller, &params[0])?;
                    let new_path = readStrArg(&mut caller, &params[1])?;
                    results[0] = wasmtime::Val::I64(std::fs::rename(&old_path, &new_path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawTruncate") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawTruncate import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let wasmtime::Val::I64(len) = params[1] else {
                        return Err(wasmtime::Error::msg("rawTruncate expects an Int length argument"));
                    };
                    let ok = std::fs::OpenOptions::new().write(true).open(&path)
                        .and_then(|f| f.set_len(len.max(0) as u64)).is_ok();
                    results[0] = wasmtime::Val::I64(ok as i64);
                    Ok(())
                }))
            }
            ("plum", "rawLink") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawLink import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let existing_path = readStrArg(&mut caller, &params[0])?;
                    let new_path = readStrArg(&mut caller, &params[1])?;
                    results[0] = wasmtime::Val::I64(std::fs::hard_link(&existing_path, &new_path).is_ok() as i64);
                    Ok(())
                }))
            }
            ("plum", "rawSymlink") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawSymlink import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let target = readStrArg(&mut caller, &params[0])?;
                    let path = readStrArg(&mut caller, &params[1])?;
                    #[cfg(unix)]
                    let ok = std::os::unix::fs::symlink(&target, &path).is_ok();
                    #[cfg(not(unix))]
                    let ok = false;
                    results[0] = wasmtime::Val::I64(ok as i64);
                    Ok(())
                }))
            }
            ("plum", "rawReadlink") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawReadlink import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let target = std::fs::read_link(&path).ok()
                        .map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, target.as_bytes())?));
                    Ok(())
                }))
            }
            ("plum", "rawRealpath") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawRealpath import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let resolved = std::fs::canonicalize(&path).ok()
                        .map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, resolved.as_bytes())?));
                    Ok(())
                }))
            }
            ("plum", "rawChmod") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawChmod import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let wasmtime::Val::I64(mode) = params[1] else {
                        return Err(wasmtime::Error::msg("rawChmod expects an Int mode argument"));
                    };
                    #[cfg(unix)]
                    let ok = {
                        use std::os::unix::fs::PermissionsExt;
                        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(mode as u32)).is_ok()
                    };
                    #[cfg(not(unix))]
                    let ok = false;
                    results[0] = wasmtime::Val::I64(ok as i64);
                    Ok(())
                }))
            }
            ("plum", "rawReadDir") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawReadDir import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
                    let path = readStrArg(&mut caller, &params[0])?;
                    let joined = std::fs::read_dir(&path).ok().map(|entries| {
                        entries.filter_map(|e| e.ok())
                            .map(|e| e.file_name().to_string_lossy().into_owned())
                            .collect::<Vec<_>>()
                            .join("\n")
                    }).unwrap_or_default();
                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, joined.as_bytes())?));
                    Ok(())
                }))
            }
            ("plum", "rawHttpRequest") => {
                let func_ty = imp.ty().func().cloned().expect("plum::rawHttpRequest import should be a function");
                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
                    let method = readStrArg(&mut caller, &params[0])?;
                    let url = readStrArg(&mut caller, &params[1])?;
                    let headers = readStrArg(&mut caller, &params[2])?;
                    let body = readStrArg(&mut caller, &params[3])?;
                    let raw = performHttpRequest(&method, &url, &headers, &body);
                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, raw.as_bytes())?));
                    Ok(())
                }))
            }
            (m, n) => panic!("unsupported host import {m}::{n}"),
        }
    }).collect()
}

/// See the identical helper in `plum-cli/src/main.rs` — this crate is built
/// fresh per `plum build` invocation, not linked against `plum-cli`, so the
/// logic is duplicated rather than shared.
fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> String {
    let agent = ureq::Agent::new();
    let mut req = agent.request(method, url);
    for line in headers.split('\n') {
        if let Some((k, v)) = line.split_once(": ") {
            req = req.set(k, v);
        }
    }
    let result = if body.is_empty() { req.call() } else { req.send_string(body) };
    match result {
        Ok(resp) | Err(ureq::Error::Status(_, resp)) => {
            let status = resp.status();
            let mut header_lines = String::new();
            for name in resp.headers_names() {
                if let Some(v) = resp.header(&name) {
                    if !header_lines.is_empty() {
                        header_lines.push('\n');
                    }
                    header_lines.push_str(&format!("{name}: {v}"));
                }
            }
            let body_text = resp.into_string().unwrap_or_default();
            format!("1\x01{status}\x01{header_lines}\x00{body_text}")
        }
        Err(e) => format!("0\x01\x01{e}\x00"),
    }
}

/// See the identical helper in `plum-cli/src/main.rs` — this crate is built
/// fresh per `plum build` invocation, not linked against `plum-cli`, so the
/// logic is duplicated rather than shared.
fn randomI64() -> i64 {
    let nanos = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_nanos() as u64)
        .unwrap_or(0);
    let mut x = nanos ^ 0x9E3779B97F4A7C15;
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    x as i64
}

/// See the identical helpers in `plum-cli/src/main.rs` — this crate is built
/// fresh per `plum build` invocation, not linked against `plum-cli`, so the
/// logic is duplicated rather than shared.
///
/// `Str` is a real two-level wasm-gc struct — `Str{data: Buffer{data: []Byte,
/// len: Int}}` (see `libs/std/str.plum`'s header comment) — not a raw
/// `array<i8>` directly. Unwraps a `Str` `AnyRef` down to that raw array.
fn unwrapStrToArray(
    mut store: impl wasmtime::AsContextMut,
    s: &wasmtime::Rooted<wasmtime::AnyRef>,
) -> wasmtime::Result<wasmtime::Rooted<wasmtime::ArrayRef>> {
    let str_struct = s.unwrap_struct(&store)?;
    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 0)? else {
        return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
    };
    let buffer_struct = buffer_ref.unwrap_struct(&store)?;
    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 0)? else {
        return Err(wasmtime::Error::msg("Buffer.data is not a []Byte reference"));
    };
    bytes_ref.unwrap_array(&store)
}

fn readStrArg(caller: &mut wasmtime::Caller<'_, ()>, val: &wasmtime::Val) -> wasmtime::Result<String> {
    let wasmtime::Val::AnyRef(Some(s)) = val else {
        return Err(wasmtime::Error::msg("expected a Str argument"));
    };
    let arr = unwrapStrToArray(&mut *caller, s)?;
    let len = arr.len(&caller)?;
    let mut buf = vec![0u8; len as usize];
    arr.copy_to_i8_slice(caller, &mut buf)?;
    Ok(String::from_utf8_lossy(&buf).into_owned())
}

/// Builds a new `Str` value from raw bytes — allocates the raw `array<i8>`
/// (needs the import's own reported `FuncType` to find the concrete nested
/// array type — a generic `ArrayRef` type would be the wrong, unrelated top
/// array type), then wraps it in a fresh `Buffer` struct and a `Str` struct
/// around that, mirroring `str.plum`'s real shape.
fn makeStrResult(
    mut caller: impl wasmtime::AsContextMut,
    func_ty: &wasmtime::FuncType,
    bytes: &[u8],
) -> wasmtime::Result<wasmtime::Rooted<wasmtime::AnyRef>> {
    let result_ty = func_ty.results().next()
        .ok_or_else(|| wasmtime::Error::msg("expected a Str-returning function"))?;
    let wasmtime::ValType::Ref(ref_ty) = result_ty else {
        return Err(wasmtime::Error::msg("expected a Str (ref) return type"));
    };
    let str_ty = ref_ty.heap_type().as_concrete_struct()
        .ok_or_else(|| wasmtime::Error::msg("expected a concrete struct return type"))?
        .clone();
    let buffer_ty = str_ty.field(0)
        .and_then(|f| match f.element_type() {
            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_struct().cloned(),
            _ => None,
        })
        .ok_or_else(|| wasmtime::Error::msg("expected Str.data to be a concrete Buffer struct type"))?;
    let array_ty = buffer_ty.field(0)
        .and_then(|f| match f.element_type() {
            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_array().cloned(),
            _ => None,
        })
        .ok_or_else(|| wasmtime::Error::msg("expected Buffer.data to be a concrete []Byte array type"))?;

    let array_pre = wasmtime::ArrayRefPre::new(&mut caller, array_ty);
    let arr = wasmtime::ArrayRef::new_from_i8_slice(&mut caller, &array_pre, bytes)?;

    let buffer_pre = wasmtime::StructRefPre::new(&mut caller, buffer_ty);
    let buffer = wasmtime::StructRef::new(
        &mut caller,
        &buffer_pre,
        &[wasmtime::Val::AnyRef(Some(arr.to_anyref())), wasmtime::Val::I64(bytes.len() as i64)],
    )?;

    let str_pre = wasmtime::StructRefPre::new(&mut caller, str_ty);
    let str_val = wasmtime::StructRef::new(&mut caller, &str_pre, &[wasmtime::Val::AnyRef(Some(buffer.to_anyref()))])?;
    Ok(str_val.to_anyref())
}

fn nowMillis() -> i64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_millis() as i64)
        .unwrap_or(0)
}

fn main() {
    // GC + typed function references are required to load modules containing
    // Plum's structs/enums/strings/closures (see docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).
    let mut config = wasmtime::Config::new();
    config.wasm_gc(true);
    config.wasm_function_references(true);
    let engine = wasmtime::Engine::new(&config).expect("engine with GC config should construct");

    let module = wasmtime::Module::new(&engine, WASM_BYTES).expect("embedded wasm should be valid");
    let mut store = wasmtime::Store::new(&engine, ());
    let imports = hostImports(&mut store, &module);
    let instance = wasmtime::Instance::new(&mut store, &module, &imports).expect("module should instantiate");

    // `main` returns `i64` unless it's declared `Unit` (no return value), in
    // which case codegen gives it an empty wasm result type instead.
    if let Ok(main) = instance.get_typed_func::<(), i64>(&mut store, "main") {
        match main.call(&mut store, ()) {
            Ok(result) => println!("{result}"),
            Err(trap) => {
                eprintln!("error: {trap}");
                std::process::exit(1);
            }
        }
        return;
    }

    let main = instance
        .get_typed_func::<(), ()>(&mut store, "main")
        .expect("module has no `main` export with signature () -> i64 or () -> ()");
    if let Err(trap) = main.call(&mut store, ()) {
        eprintln!("error: {trap}");
        std::process::exit(1);
    }
}