zoi_cli/cmd/

migrate.rs

//! Implementation of the `zoi migrate` command.
//!
//! This command facilitates migrating packages from other formats (like Scoop)
//! to Zoi.

use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Write;
use std::path::{Path, PathBuf};

use anyhow::{Result, anyhow};
use clap::{Parser, Subcommand, ValueHint};
use colored::Colorize;
use serde_json::Value;

/// Arguments for the `migrate` command.
#[derive(Parser, Debug)]
pub struct MigrateCommand {
    /// The migration sub-command to run.
    #[command(subcommand)]
    command: Commands
}

/// Available migration sub-commands.
#[derive(Subcommand, Debug)]
enum Commands {
    /// Convert a Scoop manifest (scoop.json) into a Zoi .pkg.lua package file
    Scoop(ScoopCommand)
}

/// Arguments for the Scoop migration sub-command.
#[derive(Parser, Debug)]
pub struct ScoopCommand {
    /// Path to Scoop manifest JSON/JSON5 file
    #[arg(required = true, value_hint = ValueHint::FilePath)]
    input: PathBuf,
    /// Output path for generated .pkg.lua (default: <package-name>.pkg.lua)
    #[arg(long, short = 'o', value_hint = ValueHint::FilePath)]
    output: Option<PathBuf>,
    /// Repository tier to set in metadata.repo
    #[arg(long, default_value = "community")]
    repo: String,
    /// Override package name (default: from filename stem)
    #[arg(long)]
    name: Option<String>,
    /// Override version (default: Scoop manifest version)
    #[arg(long)]
    version: Option<String>,
    /// Maintainer name in generated metadata
    #[arg(long, default_value = "Scoop Migration")]
    maintainer_name: String,
    /// Maintainer email in generated metadata
    #[arg(long, default_value = "noreply@example.com")]
    maintainer_email: String,
    /// Print generated pkg.lua instead of writing a file
    #[arg(long)]
    dry_run: bool
}

/// Represents a binary mapping from source path to target name.
#[derive(Debug, Clone)]
struct BinMapping {
    /// The source path of the binary.
    source: String,
    /// The target name of the binary.
    target: String,
    /// Arguments to be passed to the binary.
    args: Vec<String>
}

/// Represents a download specification for a package.
#[derive(Debug, Clone)]
struct DownloadSpec {
    /// The architecture key (e.g. "64bit", "arm64", "default").
    arch_key: String,
    /// The download URLs.
    urls: Vec<String>,
    /// The hashes of the downloaded files.
    hashes: Vec<String>,
    /// The directory within the archive to extract.
    extract_dir: Option<String>,
    /// The directory to extract to.
    extract_to: Option<String>
}

/// Represents hook scripts for different stages of the package lifecycle.
#[derive(Debug, Clone, Default)]
struct HookScripts {
    /// Scripts to run before installation.
    pre_install: Vec<String>,
    /// Scripts to run after installation.
    post_install: Vec<String>,
    /// Scripts to run before removal.
    pre_remove: Vec<String>,
    /// Scripts to run after removal.
    post_remove: Vec<String>
}

/// Represents the generated package metadata and content.
#[derive(Debug, Clone)]
struct Generated {
    /// Package name.
    name: String,
    /// Package repository.
    repo: String,
    /// Package version.
    version: String,
    /// Package description.
    description: String,
    /// Package website.
    website: String,
    /// Package license.
    license: String,
    /// Maintainer name.
    maintainer_name: String,
    /// Maintainer email.
    maintainer_email: String,
    /// Binary mappings.
    bins: Vec<BinMapping>,
    /// Runtime dependencies.
    runtime_deps: Vec<String>,
    /// Backup paths.
    backups: Vec<String>,
    /// Download specifications.
    downloads: Vec<DownloadSpec>,
    /// Hook scripts.
    hooks: HookScripts,
    /// Migration notes.
    notes: Vec<String>,
    /// The original manifest.
    manifest: Value
}

/// Runs the `migrate` command.
///
/// # Errors
///
/// Returns an error if:
/// - The Scoop migration sub-command fails.
pub fn run(args: MigrateCommand) -> Result<()> {
    match args.command {
        Commands::Scoop(cmd) => run_scoop(&cmd)
    }
}

/// Runs the Scoop migration sub-command.
fn run_scoop(args: &ScoopCommand) -> Result<()> {
    let content = std::fs::read_to_string(&args.input).map_err(|e| {
        anyhow!("Failed to read '{}': {}", args.input.display(), e)
    })?;
    let manifest: Value = json5::from_str(&content).map_err(|e| {
        anyhow!(
            "Failed to parse Scoop manifest '{}': {}",
            args.input.display(),
            e
        )
    })?;
    let manifest_obj = manifest
        .as_object()
        .ok_or_else(|| anyhow!("Scoop manifest root must be a JSON object."))?;

    let default_name = derive_name_from_path(&args.input)?;
    let name = normalize_name(args.name.as_deref().unwrap_or(&default_name));
    if name.is_empty() {
        return Err(anyhow!("Resolved package name is empty."));
    }

    let version = args
        .version
        .clone()
        .or_else(|| get_string_field(manifest_obj, "version"))
        .unwrap_or_else(|| "0.0.0".to_string());
    let description = get_string_field(manifest_obj, "description")
        .unwrap_or_else(|| format!("Migrated from Scoop: {name}"));
    let website = get_string_field(manifest_obj, "homepage")
        .unwrap_or_else(|| "https://scoop.sh/".to_string());
    let license = get_license_field(manifest_obj)
        .unwrap_or_else(|| "NOASSERTION".to_string());

    let runtime_deps = parse_depends(manifest_obj.get("depends"));
    let bins = collect_bins(manifest_obj);
    let backups = parse_persist(manifest_obj.get("persist"));
    let downloads = collect_download_specs(manifest_obj)?;
    let hooks = collect_hook_scripts(manifest_obj);
    let notes = collect_migration_notes(manifest_obj, &bins, &downloads);

    let generated = Generated {
        name: name.clone(),
        repo: args.repo.clone(),
        version,
        description,
        website,
        license,
        maintainer_name: args.maintainer_name.clone(),
        maintainer_email: args.maintainer_email.clone(),
        bins,
        runtime_deps,
        backups,
        downloads,
        hooks,
        notes,
        manifest: manifest.clone()
    };

    let lua = render_pkg_lua(&generated);
    if args.dry_run {
        println!("{lua}");
        return Ok(());
    }

    let output = args
        .output
        .clone()
        .unwrap_or_else(|| default_output_path(&args.input, &name));
    std::fs::write(&output, lua).map_err(|e| {
        anyhow!("Failed to write '{}': {}", output.display(), e)
    })?;

    println!(
        "{} Generated {} from {}.",
        "::".bold().green(),
        output.display().to_string().cyan(),
        args.input.display().to_string().cyan()
    );

    Ok(())
}

/// Derives a package name from the input file path.
fn derive_name_from_path(path: &Path) -> Result<String> {
    let stem = path.file_stem().and_then(|s| s.to_str()).ok_or_else(|| {
        anyhow!("Failed to derive package name from '{}'.", path.display())
    })?;
    Ok(stem.to_string())
}

/// Returns the default output path for the generated package file.
fn default_output_path(input: &Path, name: &str) -> PathBuf {
    match input.parent() {
        Some(parent) => parent.join(format!("{name}.pkg.lua")),
        None => PathBuf::from(format!("{name}.pkg.lua"))
    }
}

/// Normalizes a package name by trimming, lowercasing, and replacing spaces
/// with hyphens.
fn normalize_name(name: &str) -> String {
    name.trim().to_lowercase().replace(' ', "-")
}

/// Extracts a string field from a JSON map.
fn get_string_field(
    map: &serde_json::Map<String, Value>,
    key: &str
) -> Option<String> {
    map.get(key)
        .and_then(Value::as_str)
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

/// Extracts the license field from a JSON map, handling both string and object
/// formats.
fn get_license_field(map: &serde_json::Map<String, Value>) -> Option<String> {
    let value = map.get("license")?;
    if let Some(s) = value.as_str() {
        let trimmed = s.trim();
        if !trimmed.is_empty() {
            return Some(trimmed.to_string());
        }
    }
    if let Some(obj) = value.as_object() {
        for key in ["identifier", "id", "name"] {
            if let Some(v) = obj.get(key).and_then(Value::as_str) {
                let trimmed = v.trim();
                if !trimmed.is_empty() {
                    return Some(trimmed.to_string());
                }
            }
        }
    }
    None
}

/// Converts a JSON value (string or array) into a list of strings.
fn value_to_string_list(value: Option<&Value>) -> Vec<String> {
    let Some(v) = value else {
        return Vec::new();
    };

    match v {
        Value::String(s) => {
            let t = s.trim();
            if t.is_empty() {
                Vec::new()
            } else {
                vec![t.to_string()]
            }
        }
        Value::Array(items) => items
            .iter()
            .filter_map(|item| match item {
                Value::String(s) => Some(s.trim().to_string()),
                Value::Number(n) => Some(n.to_string()),
                Value::Bool(b) => Some(b.to_string()),
                _ => None
            })
            .filter(|s| !s.is_empty())
            .collect(),
        _ => Vec::new()
    }
}

/// Parses the `depends` field from a Scoop manifest.
fn parse_depends(depends: Option<&Value>) -> Vec<String> {
    value_to_string_list(depends)
        .into_iter()
        .map(|dep| {
            if dep.contains(':') {
                dep
            } else {
                format!("scoop:{dep}")
            }
        })
        .collect()
}

/// Parses the `persist` field from a Scoop manifest.
fn parse_persist(persist: Option<&Value>) -> Vec<String> {
    let Some(value) = persist else {
        return Vec::new();
    };
    let mut result = Vec::new();

    match value {
        Value::String(s) => {
            let t = s.trim();
            if !t.is_empty() {
                result.push(t.to_string());
            }
        }
        Value::Array(items) => {
            for item in items {
                match item {
                    Value::String(s) => {
                        let t = s.trim();
                        if !t.is_empty() {
                            result.push(t.to_string());
                        }
                    }
                    Value::Array(arr) => {
                        if let Some(first) = arr.first().and_then(Value::as_str)
                        {
                            let t = first.trim();
                            if !t.is_empty() {
                                result.push(t.to_string());
                            }
                        }
                    }
                    _ => {}
                }
            }
        }
        _ => {}
    }

    result
}

/// Collects binary mappings from a Scoop manifest.
fn collect_bins(manifest: &serde_json::Map<String, Value>) -> Vec<BinMapping> {
    let mut all = Vec::new();
    all.extend(parse_bin_value(manifest.get("bin")));

    if let Some(arch_obj) =
        manifest.get("architecture").and_then(Value::as_object)
    {
        let mut keys: Vec<_> = arch_obj.keys().cloned().collect();
        keys.sort();
        for key in keys {
            if let Some(bin_val) = arch_obj
                .get(&key)
                .and_then(Value::as_object)
                .and_then(|o| o.get("bin"))
            {
                all.extend(parse_bin_value(Some(bin_val)));
            }
        }
    }

    let mut seen = BTreeSet::new();
    all.into_iter()
        .filter(|bin| seen.insert((bin.source.clone(), bin.target.clone())))
        .collect()
}

/// Parses a `bin` value from a Scoop manifest.
fn parse_bin_value(value: Option<&Value>) -> Vec<BinMapping> {
    let Some(value) = value else {
        return Vec::new();
    };

    let mut mappings = Vec::new();
    match value {
        Value::String(path) => {
            let src = path.trim();
            if !src.is_empty() {
                let target = file_stem_or_basename(src);
                mappings.push(BinMapping {
                    source: src.to_string(),
                    target,
                    args: Vec::new()
                });
            }
        }
        Value::Array(items) => {
            let all_strings = items.iter().all(serde_json::Value::is_string);
            if all_strings && items.len() >= 2 {
                let src = items
                    .first()
                    .and_then(Value::as_str)
                    .unwrap_or_default()
                    .trim()
                    .to_string();
                if !src.is_empty() {
                    let alias = items
                        .get(1)
                        .and_then(Value::as_str)
                        .map(|s| s.trim().to_string())
                        .filter(|s| !s.is_empty())
                        .unwrap_or_else(|| file_stem_or_basename(&src));
                    let args = items
                        .iter()
                        .skip(2)
                        .filter_map(Value::as_str)
                        .map(|s| s.trim().to_string())
                        .filter(|s| !s.is_empty())
                        .collect();
                    mappings.push(BinMapping {
                        source: src,
                        target: alias,
                        args
                    });
                }
                return mappings;
            }

            for item in items {
                mappings.extend(parse_bin_value(Some(item)));
            }
        }
        _ => {}
    }

    mappings
}

/// Returns the file stem or basename of a path, stripping common executable
/// extensions.
fn file_stem_or_basename(path: &str) -> String {
    let normalized = path.replace('\\', "/");
    let base = normalized.rsplit('/').next().unwrap_or(path).trim();
    let lower = base.to_lowercase();

    for ext in [".exe", ".cmd", ".bat", ".ps1"] {
        if lower.ends_with(ext) {
            return base[..base.len() - ext.len()].to_string();
        }
    }
    if let Some((stem, _)) = base.rsplit_once('.') {
        return stem.to_string();
    }
    base.to_string()
}

/// Collects download specifications from a Scoop manifest.
fn collect_download_specs(
    map: &serde_json::Map<String, Value>
) -> Result<Vec<DownloadSpec>> {
    let root_urls = value_to_string_list(map.get("url"));
    let root_hashes = value_to_string_list(map.get("hash"));
    let root_extract_dir = get_string_field(map, "extract_dir");
    let root_extract_to = get_string_field(map, "extract_to");

    let mut specs = Vec::new();

    if !root_urls.is_empty() {
        specs.push(DownloadSpec {
            arch_key: "default".to_string(),
            urls: root_urls.clone(),
            hashes: root_hashes.clone(),
            extract_dir: root_extract_dir.clone(),
            extract_to: root_extract_to.clone()
        });
    }

    if let Some(arch) = map.get("architecture").and_then(Value::as_object) {
        let mut keys: Vec<_> = arch.keys().cloned().collect();
        keys.sort();

        for key in keys {
            let arch_data =
                arch.get(&key).and_then(Value::as_object).ok_or_else(|| {
                    anyhow!("architecture.{key} must be an object.")
                })?;

            let urls = value_to_string_list(arch_data.get("url"));
            let hashes = value_to_string_list(arch_data.get("hash"));
            let extract_dir = get_string_field(arch_data, "extract_dir");
            let extract_to = get_string_field(arch_data, "extract_to");

            let merged_urls = if urls.is_empty() {
                root_urls.clone()
            } else {
                urls
            };
            let merged_hashes = if hashes.is_empty() {
                root_hashes.clone()
            } else {
                hashes
            };
            let merged_extract_dir = extract_dir.or(root_extract_dir.clone());
            let merged_extract_to = extract_to.or(root_extract_to.clone());

            if !merged_urls.is_empty() {
                specs.push(DownloadSpec {
                    arch_key: key,
                    urls: merged_urls,
                    hashes: merged_hashes,
                    extract_dir: merged_extract_dir,
                    extract_to: merged_extract_to
                });
            }
        }
    }

    if specs.is_empty() {
        return Err(anyhow!(
            "Scoop manifest is missing download URL fields (`url` or \
             `architecture.<arch>.url`)."
        ));
    }

    let mut by_key = BTreeMap::<String, DownloadSpec>::new();
    for spec in specs {
        by_key.insert(spec.arch_key.clone(), spec);
    }

    Ok(by_key.into_values().collect())
}

/// Collects hook scripts from a Scoop manifest.
fn collect_hook_scripts(map: &serde_json::Map<String, Value>) -> HookScripts {
    let mut hooks = HookScripts::default();

    hooks
        .pre_install
        .extend(value_to_string_list(map.get("pre_install")));
    hooks
        .post_install
        .extend(value_to_string_list(map.get("post_install")));
    hooks
        .pre_remove
        .extend(value_to_string_list(map.get("pre_uninstall")));
    hooks
        .post_remove
        .extend(value_to_string_list(map.get("post_uninstall")));

    if let Some(installer_obj) = map.get("installer").and_then(Value::as_object)
    {
        hooks
            .post_install
            .extend(value_to_string_list(installer_obj.get("script")));
    }
    if let Some(uninstaller_obj) =
        map.get("uninstaller").and_then(Value::as_object)
    {
        hooks
            .pre_remove
            .extend(value_to_string_list(uninstaller_obj.get("script")));
    }

    if let Some(arch) = map.get("architecture").and_then(Value::as_object) {
        for arch_data in arch.values().filter_map(Value::as_object) {
            hooks
                .pre_install
                .extend(value_to_string_list(arch_data.get("pre_install")));
            hooks
                .post_install
                .extend(value_to_string_list(arch_data.get("post_install")));
            hooks
                .pre_remove
                .extend(value_to_string_list(arch_data.get("pre_uninstall")));
            hooks
                .post_remove
                .extend(value_to_string_list(arch_data.get("post_uninstall")));

            if let Some(installer_obj) =
                arch_data.get("installer").and_then(Value::as_object)
            {
                hooks
                    .post_install
                    .extend(value_to_string_list(installer_obj.get("script")));
            }
            if let Some(uninstaller_obj) =
                arch_data.get("uninstaller").and_then(Value::as_object)
            {
                hooks.pre_remove.extend(value_to_string_list(
                    uninstaller_obj.get("script")
                ));
            }
        }
    }

    dedupe_strings(&mut hooks.pre_install);
    dedupe_strings(&mut hooks.post_install);
    dedupe_strings(&mut hooks.pre_remove);
    dedupe_strings(&mut hooks.post_remove);
    hooks
}

/// Dedupes a vector of strings while preserving order.
fn dedupe_strings(values: &mut Vec<String>) {
    let mut seen = BTreeSet::new();
    values.retain(|v| seen.insert(v.clone()));
}

/// Collects migration notes based on the Scoop manifest content.
fn collect_migration_notes(
    manifest: &serde_json::Map<String, Value>,
    bins: &[BinMapping],
    downloads: &[DownloadSpec]
) -> Vec<String> {
    let mut notes = Vec::new();

    if manifest.get("checkver").is_some() {
        notes.push(
            "`checkver` is preserved in `SCOOP_MANIFEST` for maintainer \
             automation, but has no direct runtime equivalent in Zoi."
                .to_string()
        );
    }
    if manifest.get("autoupdate").is_some() {
        notes.push(
            "`autoupdate` is preserved in `SCOOP_MANIFEST`; update automation \
             remains a maintainer workflow."
                .to_string()
        );
    }
    if manifest.get("shortcuts").is_some() {
        notes.push(
            "`shortcuts` are preserved in `SCOOP_MANIFEST`; shortcut creation \
             is not auto-generated in this migration."
                .to_string()
        );
    }
    if manifest.get("env_set").is_some()
        || manifest.get("env_add_path").is_some()
    {
        notes.push(
            "Environment modifications (`env_set` / `env_add_path`) are \
             preserved in `SCOOP_MANIFEST` and should be reviewed manually."
                .to_string()
        );
    }
    if manifest.get("suggest").is_some() {
        notes.push(
            "`suggest` is preserved in `SCOOP_MANIFEST` for manual review; it \
             is not mapped to hard dependencies."
                .to_string()
        );
    }
    if manifest.get("psmodule").is_some() {
        notes.push(
            "`psmodule` is preserved in `SCOOP_MANIFEST`; validate module \
             installation behavior manually."
                .to_string()
        );
    }
    if manifest.get("innosetup").is_some() || manifest.get("msi").is_some() {
        notes.push(
            "Installer metadata (`innosetup` / `msi`) is preserved in \
             `SCOOP_MANIFEST`; verify installer flow manually."
                .to_string()
        );
    }
    if let Some(installer) =
        manifest.get("installer").and_then(Value::as_object)
        && (installer.get("file").is_some() || installer.get("args").is_some())
    {
        notes.push(
            "`installer.file` / `installer.args` are preserved in \
             `SCOOP_MANIFEST`; they are not auto-translated into package() \
             steps."
                .to_string()
        );
    }
    if let Some(uninstaller) =
        manifest.get("uninstaller").and_then(Value::as_object)
        && (uninstaller.get("file").is_some()
            || uninstaller.get("args").is_some())
    {
        notes.push(
            "`uninstaller.file` / `uninstaller.args` are preserved in \
             `SCOOP_MANIFEST`; they are not auto-translated into uninstall \
             hooks."
                .to_string()
        );
    }
    if bins.iter().any(|b| !b.args.is_empty()) {
        notes.push(
            "Bin shim extra args are preserved in BIN_MAP but not \
             automatically applied in generated `bins` metadata."
                .to_string()
        );
    }
    if downloads.len() > 1 {
        notes.push(
            "Multiple architecture/source entries detected. Review generated \
             arch selection and extraction paths."
                .to_string()
        );
    }
    if manifest.get("cookie").is_some() {
        notes.push(
            "`cookie` is preserved in `SCOOP_MANIFEST`; authenticated \
             download behavior may require manual adaptation."
                .to_string()
        );
    }
    if notes.is_empty() {
        notes.push(
            "No major migration warnings detected. Review generated paths and \
             hooks before publishing."
                .to_string()
        );
    }

    notes
}

/// Renders a generated package into a `.pkg.lua` file.
fn render_pkg_lua(g: &Generated) -> String {
    use std::fmt::Write;
    let mut out = String::new();

    out.push_str("-- Generated by `zoi migrate scoop`\n");
    out.push_str("-- This attempts broad Scoop manifest coverage.\n");
    out.push_str("-- Review generated behavior before publishing.\n");
    out.push_str("-- Migration notes:\n");
    for note in &g.notes {
        let _ = writeln!(out, "-- - {note}");
    }
    out.push('\n');

    out.push_str("local SCOOP_MANIFEST = ");
    out.push_str(&json_to_lua(&g.manifest, 0));
    out.push_str("\n\n");

    out.push_str("local DOWNLOADS = {\n");
    for spec in &g.downloads {
        let _ = writeln!(out, "  [{}] = {{", lua_quote(&spec.arch_key));
        out.push_str("    urls = {");
        for (idx, url) in spec.urls.iter().enumerate() {
            if idx > 0 {
                out.push_str(", ");
            }
            out.push_str(&lua_quote(url));
        }
        out.push_str("},\n");

        out.push_str("    hashes = {");
        for (idx, hash) in spec.hashes.iter().enumerate() {
            if idx > 0 {
                out.push_str(", ");
            }
            out.push_str(&lua_quote(hash));
        }
        out.push_str("},\n");

        let _ = writeln!(
            out,
            "    extract_dir = {},",
            lua_optional(spec.extract_dir.as_deref())
        );
        let _ = writeln!(
            out,
            "    extract_to = {},",
            lua_optional(spec.extract_to.as_deref())
        );
        out.push_str("  },\n");
    }
    out.push_str("}\n\n");

    out.push_str("local BIN_MAP = {\n");
    for bin in &g.bins {
        out.push_str("  {\n");
        let _ = writeln!(out, "    source = {},", lua_quote(&bin.source));
        let _ = writeln!(out, "    target = {},", lua_quote(&bin.target));
        out.push_str("    args = {");
        for (idx, arg) in bin.args.iter().enumerate() {
            if idx > 0 {
                out.push_str(", ");
            }
            out.push_str(&lua_quote(arg));
        }
        out.push_str("},\n");
        out.push_str("  },\n");
    }
    out.push_str("}\n\n");

    out.push_str("local RUNTIME_DEPS = {");
    for (idx, dep) in g.runtime_deps.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(dep));
    }
    out.push_str("}\n\n");

    out.push_str("local HOOK_SCRIPTS = {\n");
    out.push_str("  pre_install = {");
    for (idx, line) in g.hooks.pre_install.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(line));
    }
    out.push_str("},\n");
    out.push_str("  post_install = {");
    for (idx, line) in g.hooks.post_install.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(line));
    }
    out.push_str("},\n");
    out.push_str("  pre_remove = {");
    for (idx, line) in g.hooks.pre_remove.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(line));
    }
    out.push_str("},\n");
    out.push_str("  post_remove = {");
    for (idx, line) in g.hooks.post_remove.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(line));
    }
    out.push_str("},\n");
    out.push_str("}\n\n");

    out.push_str("local function scoop_arch_key()\n");
    out.push_str("  if SYSTEM.ARCH == \"amd64\" then return \"64bit\" end\n");
    out.push_str("  if SYSTEM.ARCH == \"arm64\" then return \"arm64\" end\n");
    out.push_str(
        "  if SYSTEM.ARCH == \"386\" or SYSTEM.ARCH == \"i386\" then return \
         \"32bit\" end\n"
    );
    out.push_str("  return SYSTEM.ARCH\n");
    out.push_str("end\n\n");

    out.push_str("local function active_download()\n");
    out.push_str("  local arch = scoop_arch_key()\n");
    out.push_str("  if DOWNLOADS[arch] then return DOWNLOADS[arch] end\n");
    out.push_str("  if DOWNLOADS.default then return DOWNLOADS.default end\n");
    out.push_str(
        "  for _, key in ipairs({ \"64bit\", \"32bit\", \"arm64\" }) do\n"
    );
    out.push_str("    if DOWNLOADS[key] then return DOWNLOADS[key] end\n");
    out.push_str("  end\n");
    out.push_str("  for _, value in pairs(DOWNLOADS) do\n");
    out.push_str("    return value\n");
    out.push_str("  end\n");
    out.push_str("  return nil\n");
    out.push_str("end\n\n");

    out.push_str("local function powershell_cmd(line)\n");
    out.push_str(
        "  return \"powershell -NoProfile -ExecutionPolicy Bypass -Command \" \
         .. string.format(\"%q\", line)\n"
    );
    out.push_str("end\n\n");

    out.push_str("local function register_hooks()\n");
    out.push_str("  local generated = {}\n");
    out.push_str("  local function add(name, lines)\n");
    out.push_str("    if not lines or #lines == 0 then return end\n");
    out.push_str("    generated[name] = generated[name] or {}\n");
    out.push_str(
        "    generated[name].windows = generated[name].windows or {}\n"
    );
    out.push_str("    for _, line in ipairs(lines) do\n");
    out.push_str(
        "      table.insert(generated[name].windows, powershell_cmd(line))\n"
    );
    out.push_str("    end\n");
    out.push_str("  end\n");
    out.push_str("  add(\"pre_install\", HOOK_SCRIPTS.pre_install)\n");
    out.push_str("  add(\"post_install\", HOOK_SCRIPTS.post_install)\n");
    out.push_str("  add(\"pre_remove\", HOOK_SCRIPTS.pre_remove)\n");
    out.push_str("  add(\"post_remove\", HOOK_SCRIPTS.post_remove)\n");
    out.push_str("  if next(generated) then hooks(generated) end\n");
    out.push_str("end\n\n");
    out.push_str("register_hooks()\n\n");

    out.push_str("local function split_hash(hash)\n");
    out.push_str("  if not hash or hash == \"\" then return nil, nil end\n");
    out.push_str(
        "  local algo, digest = \
         hash:match(\"^(sha512|sha256|sha1)[:%-](.+)$\")\n"
    );
    out.push_str("  if algo and digest then return algo, digest end\n");
    out.push_str("  return \"sha256\", hash\n");
    out.push_str("end\n\n");

    out.push_str("local function sanitize_url_file_name(url)\n");
    out.push_str("  if not url then return nil end\n");
    out.push_str("  local cleaned = url:gsub(\"#.*$\", \"\")\n");
    out.push_str("  return cleaned:match(\"([^/]+)$\")\n");
    out.push_str("end\n\n");

    out.push_str("local function source_roots_for_download(dl)\n");
    out.push_str("  local roots = {}\n");
    out.push_str("  local base_roots = {}\n");
    out.push_str("  if dl.extract_to and dl.extract_to ~= \"\" then\n");
    out.push_str("    table.insert(base_roots, dl.extract_to)\n");
    out.push_str("  elseif #dl.urls <= 1 then\n");
    out.push_str("    table.insert(base_roots, \"source\")\n");
    out.push_str("  else\n");
    out.push_str(
        "    for i = 1, #dl.urls do table.insert(base_roots, \"source_\" .. \
         i) end\n"
    );
    out.push_str("  end\n");
    out.push_str(
        "  for _, root in ipairs(base_roots) do table.insert(roots, root) \
         end\n"
    );
    out.push_str("  if dl.extract_dir and dl.extract_dir ~= \"\" then\n");
    out.push_str(
        "    for _, root in ipairs(base_roots) do table.insert(roots, root .. \
         \"/\" .. dl.extract_dir) end\n"
    );
    out.push_str("  end\n");
    out.push_str("  return roots\n");
    out.push_str("end\n\n");

    out.push_str("local function resolve_bin_source(bin_source, roots)\n");
    out.push_str("  for _, root in ipairs(roots) do\n");
    out.push_str("    local candidate = root .. \"/\" .. bin_source\n");
    out.push_str(
        "    if UTILS.FS.exists(candidate) then return candidate end\n"
    );
    out.push_str("    local file_name = bin_source:match(\"([^/\\\\]+)$\")\n");
    out.push_str("    if file_name then\n");
    out.push_str("      local found = UTILS.FIND.file(root, file_name)\n");
    out.push_str(
        "      if found and UTILS.FS.exists(found) then return found end\n"
    );
    out.push_str("    end\n");
    out.push_str("  end\n");
    out.push_str("  return nil\n");
    out.push_str("end\n\n");

    out.push_str("metadata({\n");
    let _ = writeln!(out, "  name = {},", lua_quote(&g.name));
    let _ = writeln!(out, "  repo = {},", lua_quote(&g.repo));
    let _ = writeln!(out, "  version = {},", lua_quote(&g.version));
    let _ = writeln!(out, "  description = {},", lua_quote(&g.description));
    let _ = writeln!(out, "  website = {},", lua_quote(&g.website));
    let _ = writeln!(out, "  license = {},", lua_quote(&g.license));
    let _ = writeln!(
        out,
        "  maintainer = {{ name = {}, email = {} }},",
        lua_quote(&g.maintainer_name),
        lua_quote(&g.maintainer_email)
    );
    out.push_str("  types = { \"pre-compiled\" },\n");
    out.push_str("  bins = {");
    for (idx, bin) in g.bins.iter().enumerate() {
        if idx > 0 {
            out.push_str(", ");
        }
        out.push_str(&lua_quote(&bin.target));
    }
    out.push_str(" },\n");
    if !g.backups.is_empty() {
        out.push_str("  backup = {");
        for (idx, path) in g.backups.iter().enumerate() {
            if idx > 0 {
                out.push_str(", ");
            }
            out.push_str(&lua_quote(path));
        }
        out.push_str(" },\n");
    }
    out.push_str("})\n\n");

    if !g.runtime_deps.is_empty() {
        out.push_str("dependencies({\n");
        out.push_str("  runtime = {\n");
        out.push_str("    required = RUNTIME_DEPS,\n");
        out.push_str("  }\n");
        out.push_str("})\n\n");
    }

    out.push_str("function prepare()\n");
    out.push_str("  local dl = active_download()\n");
    out.push_str(
        "  if not dl then error(\"No download source matched current \
         architecture\") end\n"
    );
    out.push_str("  for i, url in ipairs(dl.urls) do\n");
    out.push_str("    local out_dir\n");
    out.push_str("    if dl.extract_to and dl.extract_to ~= \"\" then\n");
    out.push_str("      out_dir = dl.extract_to\n");
    out.push_str("    elseif #dl.urls <= 1 then\n");
    out.push_str("      out_dir = \"source\"\n");
    out.push_str("    else\n");
    out.push_str("      out_dir = \"source_\" .. i\n");
    out.push_str("    end\n");
    out.push_str("    UTILS.EXTRACT(url, out_dir)\n");
    out.push_str("  end\n");
    out.push_str("end\n\n");

    out.push_str("function package()\n");
    out.push_str("  local dl = active_download()\n");
    out.push_str(
        "  if not dl then error(\"No download source matched current \
         architecture\") end\n"
    );
    out.push_str("  local roots = source_roots_for_download(dl)\n");
    out.push_str("  for _, bin in ipairs(BIN_MAP) do\n");
    out.push_str(
        "    local source_path = resolve_bin_source(bin.source, roots)\n"
    );
    out.push_str("    if not source_path then\n");
    out.push_str(
        "      error(\"Could not locate bin source in extracted files: \" .. \
         bin.source)\n"
    );
    out.push_str("    end\n");
    out.push_str("    zcp(source_path, \"${pkgstore}/bin/\" .. bin.target)\n");
    out.push_str("  end\n");
    out.push_str("end\n\n");

    out.push_str("function verify()\n");
    out.push_str("  local dl = active_download()\n");
    out.push_str("  if not dl then return true end\n");
    out.push_str("  local roots = source_roots_for_download(dl)\n");
    out.push_str("  for i, hash in ipairs(dl.hashes or {}) do\n");
    out.push_str("    local algo, digest = split_hash(hash)\n");
    out.push_str("    if algo and digest then\n");
    out.push_str("      local url = dl.urls[i] or dl.urls[1]\n");
    out.push_str("      local file_name = sanitize_url_file_name(url)\n");
    out.push_str("      local file_path = nil\n");
    out.push_str("      if file_name then\n");
    out.push_str("        for _, root in ipairs(roots) do\n");
    out.push_str("          local candidate = root .. \"/\" .. file_name\n");
    out.push_str("          if UTILS.FS.exists(candidate) then\n");
    out.push_str("            file_path = candidate\n");
    out.push_str("            break\n");
    out.push_str("          end\n");
    out.push_str("          local found = UTILS.FIND.file(root, file_name)\n");
    out.push_str("          if found and UTILS.FS.exists(found) then\n");
    out.push_str("            file_path = found\n");
    out.push_str("            break\n");
    out.push_str("          end\n");
    out.push_str("        end\n");
    out.push_str("      end\n");
    out.push_str("      if file_path then\n");
    out.push_str("        verifyHash(file_path, algo .. \"-\" .. digest)\n");
    out.push_str("      end\n");
    out.push_str("    end\n");
    out.push_str("  end\n");
    out.push_str("  return true\n");
    out.push_str("end\n");

    out
}

/// Escapes a string for use in Lua.
fn lua_quote(value: &str) -> String {
    let escaped = value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n");
    format!("\"{escaped}\"")
}

/// Returns a Lua quoted string or `nil` if the value is empty or `None`.
fn lua_optional(value: Option<&str>) -> String {
    match value {
        Some(v) if !v.trim().is_empty() => lua_quote(v),
        _ => "nil".to_string()
    }
}

/// Converts a JSON value into a Lua table string.
fn json_to_lua(value: &Value, indent: usize) -> String {
    match value {
        Value::Null => "nil".to_string(),
        Value::Bool(b) => {
            if *b {
                "true".to_string()
            } else {
                "false".to_string()
            }
        }
        Value::Number(n) => n.to_string(),
        Value::String(s) => lua_quote(s),
        Value::Array(arr) => {
            if arr.is_empty() {
                return "{}".to_string();
            }
            let mut out = String::new();
            out.push_str("{\n");
            let next_indent = indent + 2;
            for item in arr {
                out.push_str(&" ".repeat(next_indent));
                out.push_str(&json_to_lua(item, next_indent));
                out.push_str(",\n");
            }
            out.push_str(&" ".repeat(indent));
            out.push('}');
            out
        }
        Value::Object(map) => {
            if map.is_empty() {
                return "{}".to_string();
            }
            let mut keys: Vec<_> = map.keys().cloned().collect();
            keys.sort();

            let mut out = String::new();
            out.push_str("{\n");
            let next_indent = indent + 2;
            for key in keys {
                if let Some(v) = map.get(&key) {
                    out.push_str(&" ".repeat(next_indent));
                    let _ = write!(out, "[{}] = ", lua_quote(&key));
                    out.push_str(&json_to_lua(v, next_indent));
                    out.push_str(",\n");
                }
            }
            out.push_str(&" ".repeat(indent));
            out.push('}');
            out
        }
    }
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    #[test]
    fn parse_bin_string_and_array() {
        let bins = parse_bin_value(Some(&json!([
            "pwsh.exe",
            ["tools/foo.exe", "foo", "--x"]
        ])));
        assert_eq!(bins.len(), 2);
        assert_eq!(
            bins.first()
                .expect("should have at least one binary")
                .target,
            "pwsh"
        );
        assert_eq!(
            bins.get(1).expect("should have a second binary").target,
            "foo"
        );
        assert_eq!(
            bins.get(1).expect("should have a second binary").args,
            vec!["--x".to_string()]
        );
    }

    #[test]
    fn collect_download_specs_arch_fallback() {
        let manifest = json!({
            "url": "https://example.com/default.zip",
            "hash": "abc",
            "architecture": {
                "64bit": {
                    "url": "https://example.com/x64.zip",
                    "hash": "def"
                },
                "arm64": {}
            }
        });
        let specs =
            collect_download_specs(manifest.as_object().expect("object"))
                .expect("download specs should parse");
        assert!(specs.iter().any(|s| s.arch_key == "64bit"));
        assert!(specs.iter().any(|s| s.arch_key == "arm64"));
        assert!(specs.iter().any(|s| s.arch_key == "default"));
    }
}