use std::{io::Write, path::Path};
use wasmtime::{Config, Engine};

fn main() {
    let base = Path::new("../../plugins");

    // Find all files and folders that don't change when rebuilt
    let crates = std::fs::read_dir(base).expect("Could not find plugin directory");
    for dir in crates {
        let path = dir.unwrap().path();
        let name = path.file_name().and_then(|x| x.to_str());
        let is_dir = path.is_dir();
        if is_dir && name != Some("target") && name != Some("bin") {
            println!("cargo:rerun-if-changed={}", path.display());
        }
    }

    // Clear out and recreate the plugin bin directory
    let _ = std::fs::remove_dir_all(base.join("bin"));
    std::fs::create_dir_all(base.join("bin")).expect("Could not make plugins bin directory");

    // Compile the plugins using the same profile as the current Zed build
    let (profile_flags, profile_target) = match std::env::var("PROFILE").unwrap().as_str() {
        "debug" => (&[][..], "debug"),
        "release" => (&["--release"][..], "release"),
        unknown => panic!("unknown profile `{}`", unknown),
    };
    // Invoke cargo to build the plugins
    let build_successful = std::process::Command::new("cargo")
        .args([
            "build",
            "--target",
            "wasm32-wasi",
            "--manifest-path",
            base.join("Cargo.toml").to_str().unwrap(),
        ])
        .args(profile_flags)
        .status()
        .expect("Could not build plugins")
        .success();
    assert!(build_successful);

    // Get the target architecture for pre-cross-compilation of plugins
    // and create and engine with the appropriate config
    let target_triple = std::env::var("TARGET").unwrap();
    println!("cargo:rerun-if-env-changed=TARGET");
    let engine = create_default_engine(&target_triple);

    // Find all compiled binaries
    let binaries = std::fs::read_dir(base.join("target/wasm32-wasi").join(profile_target))
        .expect("Could not find compiled plugins in target");

    // Copy and precompile all compiled plugins we can find
    for file in binaries {
        let is_wasm = || {
            let path = file.ok()?.path();
            if path.extension()? == "wasm" {
                Some(path)
            } else {
                None
            }
        };

        if let Some(path) = is_wasm() {
            let out_path = base.join("bin").join(path.file_name().unwrap());
            std::fs::copy(&path, &out_path).expect("Could not copy compiled plugin to bin");
            precompile(&out_path, &engine);
        }
    }
}

/// Creates an engine with the default configuration.
/// N.B. This must create an engine with the same config as the one
/// in `plugin_runtime/src/plugin.rs`.
fn create_default_engine(target_triple: &str) -> Engine {
    let mut config = Config::default();
    config
        .target(target_triple)
        .unwrap_or_else(|_| panic!("Could not set target to `{}`", target_triple));
    config.async_support(true);
    config.consume_fuel(true);
    Engine::new(&config).expect("Could not create precompilation engine")
}

fn precompile(path: &Path, engine: &Engine) {
    let bytes = std::fs::read(path).expect("Could not read wasm module");
    let compiled = engine
        .precompile_module(&bytes)
        .expect("Could not precompile module");
    let out_path = path.parent().unwrap().join(&format!(
        "{}.pre",
        path.file_name().unwrap().to_string_lossy(),
    ));
    let mut out_file = std::fs::File::create(out_path)
        .expect("Could not create output file for precompiled module");
    out_file.write_all(&compiled).unwrap();
}