Function bodies 106 total

pub fn run(feature: &Feature, dir: &Path) -> Result<()> {
    match feature {
        Feature::Fabric => run_add_fabric(dir),
        Feature::Neoforge => run_add_neoforge(dir),
        Feature::Ci => run_add_ci(dir),
        Feature::Kotlin => run_add_kotlin(dir),
        Feature::Publishing => run_add_publishing(dir),
    }
}

fn run_add_fabric(dir: &Path) -> Result<()> {
    println!("{}", "\n  mcmod add fabric\n".bold().cyan());
    let mut config = McmodConfig::load(dir)?;

    if config.loaders.fabric {
        return Err(McmodError::AlreadyEnabled("fabric".to_string()));
    }

    let vars = build_vars_from_config(&config);

    add_fabric_files(dir, &vars, &config.mod_info.language)?;

    // Update settings.gradle
    gradle::add_include_to_settings(dir, "fabric")?;

    // Update gradle.properties enabled_platforms
    gradle::add_platform_to_gradle_properties(dir, "fabric")?;

    // Update config
    config.loaders.fabric = true;
    config.save(dir)?;

    println!("{}", "  Fabric module added successfully!".bold().green());
    Ok(())
}

fn run_add_neoforge(dir: &Path) -> Result<()> {
    println!("{}", "\n  mcmod add neoforge\n".bold().cyan());
    let mut config = McmodConfig::load(dir)?;

    if config.loaders.neoforge {
        return Err(McmodError::AlreadyEnabled("neoforge".to_string()));
    }

    let vars = build_vars_from_config(&config);

    add_neoforge_files(dir, &vars, &config.mod_info.language)?;

    // Update settings.gradle
    gradle::add_include_to_settings(dir, "neoforge")?;

    // Update gradle.properties enabled_platforms
    gradle::add_platform_to_gradle_properties(dir, "neoforge")?;

    // Update config
    config.loaders.neoforge = true;
    config.save(dir)?;

    println!("{}", "  NeoForge module added successfully!".bold().green());
    Ok(())
}

fn run_add_ci(dir: &Path) -> Result<()> {
    println!("{}", "\n  mcmod add ci\n".bold().cyan());
    let mut config = McmodConfig::load(dir)?;

    if config.features.ci {
        return Err(McmodError::AlreadyEnabled("ci".to_string()));
    }

    let vars = build_vars_from_config(&config);

    add_ci_files(dir, &vars)?;

    // Update config
    config.features.ci = true;
    config.save(dir)?;

    println!("{}", "  CI workflow added successfully!".bold().green());
    Ok(())
}

fn run_add_kotlin(dir: &Path) -> Result<()> {
    println!("{}", "\n  mcmod add kotlin\n".bold().cyan());
    let mut config = McmodConfig::load(dir)?;

    if config.mod_info.language == "kotlin" {
        return Err(McmodError::AlreadyEnabled("kotlin".to_string()));
    }

    let vars = build_vars_from_config(&config);
    let package_path = package_to_path(&config.mod_info.package);
    let class_name = derive_class_name(&config.mod_info.mod_id);

    // Migrate common module
    migrate_to_kotlin(
        dir,
        "common",
        &package_path,
        &class_name,
        template::TMPL_COMMON_MOD_KT,
        &vars,
        None, // no mixin in common
    )?;

    // Migrate fabric module if present
    if config.loaders.fabric {
        migrate_to_kotlin(
            dir,
            "fabric",
            &format!("{package_path}/fabric"),
            &format!("{class_name}Fabric"),
            template::TMPL_FABRIC_MOD_KT,
            &vars,
            Some((&package_pa

fn run_add_publishing(dir: &Path) -> Result<()> {
    println!("{}", "\n  mcmod add publishing\n".bold().cyan());
    let mut config = McmodConfig::load(dir)?;

    if config.features.publishing {
        return Err(McmodError::AlreadyEnabled("publishing".to_string()));
    }

    let modrinth_id: String = dialoguer::Input::new()
        .with_prompt("  Modrinth project slug")
        .default(config.mod_info.mod_id.clone())
        .interact_text()
        .map_err(|e| McmodError::Other(e.to_string()))?;

    let cf_input: String = dialoguer::Input::new()
        .with_prompt("  CurseForge project ID (leave blank to skip)")
        .default(String::new())
        .interact_text()
        .map_err(|e| McmodError::Other(e.to_string()))?;
    let curseforge_id = if cf_input.is_empty() {
        None
    } else {
        Some(cf_input)
    };

    let mut vars = build_vars_from_config(&config);
    vars.insert("modrinth_id".to_string(), modrinth_id.clone());
    if let Some(ref id) = cur

pub fn add_publishing_files(
    dir: &Path,
    vars: &HashMap<String, String>,
    has_fabric: bool,
    has_neoforge: bool,
    has_curseforge: bool,
) -> Result<()> {
    // Render and strip conditional blocks from release.yml
    let rendered = render(template::TMPL_CI_RELEASE_YML, vars);
    let stripped = template::strip_conditional_blocks(
        &rendered,
        &[
            ("fabric", has_fabric),
            ("neoforge", has_neoforge),
            ("curseforge", has_curseforge),
        ],
    );
    write_file(&dir.join(".github/workflows/release.yml"), &stripped)?;

    // Starter changelog
    write_file(
        &dir.join("changelogs/v1.0.0.md"),
        "Initial release.\n",
    )?;

    // Starter MODPAGE.md
    let mod_name = vars.get("mod_name").map(|s| s.as_str()).unwrap_or("My Mod");
    let description = vars
        .get("description")
        .map(|s| s.as_str())
        .unwrap_or("A Minecraft mod");
    write_file(
        &dir.join("MODPAGE.md"),
       

fn cleanup_empty_dirs(path: &Path) -> Result<()> {
    let mut current = path.to_path_buf();
    while current.exists() {
        if std::fs::read_dir(&current)?.next().is_none() {
            std::fs::remove_dir(&current)?;
            if let Some(parent) = current.parent() {
                current = parent.to_path_buf();
            } else {
                break;
            }
        } else {
            break;
        }
    }
    Ok(())
}

pub fn add_fabric_files(
    dir: &Path,
    vars: &HashMap<String, String>,
    language: &str,
) -> Result<()> {
    let package_path = vars.get("package_path").unwrap();
    let class_name = vars.get("class_name").unwrap();

    // fabric/build.gradle
    write_file(
        &dir.join("fabric/build.gradle"),
        template::TMPL_FABRIC_BUILD_GRADLE,
    )?;

    // fabric/gradle.properties
    write_file(
        &dir.join("fabric/gradle.properties"),
        template::TMPL_FABRIC_GRADLE_PROPS,
    )?;

    // Source file
    let (tmpl, ext, source_dir) = if language == "kotlin" {
        (template::TMPL_FABRIC_MOD_KT, "kt", "kotlin")
    } else {
        (template::TMPL_FABRIC_MOD_JAVA, "java", "java")
    };
    write_file(
        &dir.join(format!(
            "fabric/src/main/{source_dir}/{package_path}/fabric/{class_name}Fabric.{ext}"
        )),
        &render(tmpl, vars),
    )?;

    // fabric.mod.json
    write_file(
        &dir.join("fabric/src/main/resources/fabric.m

pub fn add_neoforge_files(
    dir: &Path,
    vars: &HashMap<String, String>,
    language: &str,
) -> Result<()> {
    let package_path = vars.get("package_path").unwrap();
    let class_name = vars.get("class_name").unwrap();

    // neoforge/build.gradle
    write_file(
        &dir.join("neoforge/build.gradle"),
        template::TMPL_NEOFORGE_BUILD_GRADLE,
    )?;

    // neoforge/gradle.properties
    write_file(
        &dir.join("neoforge/gradle.properties"),
        template::TMPL_NEOFORGE_GRADLE_PROPS,
    )?;

    // Source file
    let (tmpl, ext, source_dir) = if language == "kotlin" {
        (template::TMPL_NEOFORGE_MOD_KT, "kt", "kotlin")
    } else {
        (template::TMPL_NEOFORGE_MOD_JAVA, "java", "java")
    };
    write_file(
        &dir.join(format!(
            "neoforge/src/main/{source_dir}/{package_path}/neoforge/{class_name}NeoForge.{ext}"
        )),
        &render(tmpl, vars),
    )?;

    // neoforge.mods.toml
    write_file(
        &dir.join("neoforg

pub fn add_ci_files(dir: &Path, vars: &HashMap<String, String>) -> Result<()> {
    write_file(
        &dir.join(".github/workflows/build.yml"),
        &render(template::TMPL_CI_BUILD_YML, vars),
    )?;
    Ok(())
}

fn build_vars_from_config(config: &McmodConfig) -> HashMap<String, String> {
    let class_name = derive_class_name(&config.mod_info.mod_id);
    let enabled_platforms = config.enabled_platforms().join(",");
    template::build_vars(&template::TemplateVars {
        mod_id: &config.mod_info.mod_id,
        mod_name: &config.mod_info.mod_name,
        package: &config.mod_info.package,
        class_name: &class_name,
        author: &config.mod_info.author,
        description: &config.mod_info.description,
        language: &config.mod_info.language,
        minecraft_version: &config.versions.minecraft,
        fabric_loader_version: &config.versions.fabric_loader,
        fabric_api_version: &config.versions.fabric_api,
        neoforge_version: &config.versions.neoforge,
        enabled_platforms: &enabled_platforms,
        modrinth_id: config.publishing.as_ref().map(|p| p.modrinth_id.as_str()),
        curseforge_id: config
            .publishing
            .as_ref()
          

pub fn run_set(key: &str, value: &str) -> Result<()> {
    let mut config = GlobalConfig::load()?;
    config.set(key, value)?;
    println!(
        "{}",
        format!("  Set {key} = {value}").green()
    );
    Ok(())
}

pub fn run_get(key: &str) -> Result<()> {
    let config = GlobalConfig::load()?;
    match config.get(key) {
        Some(value) => println!("  {value}"),
        None => println!("  {}", "(not set)".dimmed()),
    }
    Ok(())
}

pub fn run_list() -> Result<()> {
    let config = GlobalConfig::load()?;
    let dir = global_config::global_config_dir()?;

    println!("{}", "\n  mcmod global config\n".bold().cyan());
    println!("  {}", format!("Config directory: {}", dir.display()).dimmed());
    println!();

    let entries = config.list();
    let mut current_section = "";

    for (section, key, value) in &entries {
        if *section != current_section {
            if !current_section.is_empty() {
                println!();
            }
            println!("  {}", format!("[{section}]").bold());
            current_section = section;
        }
        println!("  {:<22} {}", format!("{key}:"), value);
    }
    println!();
    Ok(())
}

fn write_base_files(dir: &Path, vars: &HashMap<String, String>, language: &str) -> Result<()> {
    // build.gradle (root) — no placeholders, copy as-is
    write_file(
        &dir.join("build.gradle"),
        template::TMPL_BUILD_GRADLE_ROOT,
    )?;

    // settings.gradle — has {{mod_id}} placeholder
    write_file(
        &dir.join("settings.gradle"),
        &render(template::TMPL_SETTINGS_GRADLE, vars),
    )?;

    // gradle.properties
    let mut props = render(template::TMPL_GRADLE_PROPERTIES, vars);
    // Add language properties if kotlin
    if language == "kotlin" {
        props.push_str("\nmod_language=kotlin\nkotlin_version=2.1.0\n");
    }
    write_file(&dir.join("gradle.properties"), &props)?;

    // .gitignore
    write_file(&dir.join(".gitignore"), template::TMPL_GITIGNORE)?;

    // LICENSE
    write_file(&dir.join("LICENSE"), &render(template::TMPL_LICENSE, vars))?;

    // Gradle wrapper
    write_binary(
        &dir.join("gradle/wrapper/gradle-wrapper.jar

fn write_common_module(
    dir: &Path,
    vars: &HashMap<String, String>,
    language: &str,
) -> Result<()> {
    let package_path = vars.get("package_path").unwrap();

    // common/build.gradle
    write_file(
        &dir.join("common/build.gradle"),
        template::TMPL_COMMON_BUILD_GRADLE,
    )?;

    // Source file
    let (template, ext, source_dir) = if language == "kotlin" {
        (template::TMPL_COMMON_MOD_KT, "kt", "kotlin")
    } else {
        (template::TMPL_COMMON_MOD_JAVA, "java", "java")
    };

    let class_name = vars.get("class_name").unwrap();
    let source_path = dir.join(format!(
        "common/src/main/{source_dir}/{package_path}/{class_name}.{ext}"
    ));
    write_file(&source_path, &render(template, vars))?;

    // assets/<mod_id>/icon.png.txt
    let mod_id = vars.get("mod_id").unwrap();
    write_file(
        &dir.join(format!(
            "common/src/main/resources/assets/{mod_id}/icon.png.txt"
        )),
        "Replace this file with yo

fn prompt_input(prompt: &str, default: &str) -> Result<String> {
    let result = dialoguer::Input::<String>::new()
        .with_prompt(format!("  {prompt}"))
        .default(default.to_string())
        .interact_text()
        .map_err(|e| crate::error::McmodError::Other(e.to_string()))?;
    Ok(result)
}

fn prompt_select(prompt: &str, items: &[&str], default: usize) -> Result<String> {
    let selection = dialoguer::Select::new()
        .with_prompt(format!("  {prompt}"))
        .items(items)
        .default(default)
        .interact()
        .map_err(|e| crate::error::McmodError::Other(e.to_string()))?;
    Ok(items[selection].to_string())
}

fn prompt_multiselect(prompt: &str, items: &[&str]) -> Result<Vec<String>> {
    let defaults = vec![true; items.len()];
    let selections = dialoguer::MultiSelect::new()
        .with_prompt(format!("  {prompt}"))
        .items(items)
        .defaults(&defaults)
        .interact()
        .map_err(|e| crate::error::McmodError::Other(e.to_string()))?;
    Ok(selections.iter().map(|&i| items[i].to_string()).collect())
}

fn prompt_confirm(prompt: &str, default: bool) -> Result<bool> {
    let result = dialoguer::Confirm::new()
        .with_prompt(format!("  {prompt}"))
        .default(default)
        .interact()
        .map_err(|e| crate::error::McmodError::Other(e.to_string()))?;
    Ok(result)
}

fn create_run_options(project_dir: &Path, config: &crate::global_config::GlobalConfig) -> Result<()> {
    let run_dir = project_dir.join("run");
    crate::util::ensure_dir(&run_dir)?;
    crate::global_config::copy_options_to(&run_dir.join("options.txt"), config)
}

fn slugify_for_package(author: &str) -> String {
    let slug: String = author
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();

    if slug.is_empty() || slug.starts_with(|c: char| c.is_ascii_digit()) {
        "example".to_string()
    } else {
        slug
    }
}

fn slugify_dir_name(dir: &Path) -> String {
    let name = dir
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("mymod");

    let slug: String = name
        .chars()
        .map(|c| {
            if c.is_ascii_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '_'
            }
        })
        .collect();

    // Collapse consecutive underscores and trim leading/trailing ones
    let slug: String = slug
        .split('_')
        .filter(|s| !s.is_empty())
        .collect::<Vec<_>>()
        .join("_");

    // Must start with a letter; fall back if empty or starts with digit
    if slug.is_empty() || slug.starts_with(|c: char| c.is_ascii_digit()) {
        "mymod".to_string()
    } else {
        slug
    }
}

fn default_mod_name(mod_id: &str) -> String {
    mod_id
        .split('_')
        .filter(|s| !s.is_empty())
        .map(|part| {
            let mut chars = part.chars();
            match chars.next() {
                Some(c) => {
                    let mut s = c.to_uppercase().to_string();
                    s.extend(chars);
                    s
                }
                None => String::new(),
            }
        })
        .collect::<Vec<_>>()
        .join(" ")
}

pub fn run() -> Result<()> {
    let current_version = env!("CARGO_PKG_VERSION");
    println!(
        "{}",
        format!("  Current version: {current_version}").cyan()
    );

    println!("{}", "  Checking for updates...".cyan());
    let latest_version = fetch_latest_version()?;

    if current_version == latest_version {
        println!(
            "{}",
            format!("  Already up to date (v{current_version})").green()
        );
        return Ok(());
    }

    println!(
        "{}",
        format!("  New version available: v{latest_version}").yellow()
    );

    let asset_name = get_asset_name()?;
    let download_url = fetch_asset_url(&latest_version, &asset_name)?;

    println!("{}", format!("  Downloading {asset_name}...").cyan());
    let binary = http_get_bytes(&download_url)?;

    let target = global_config::install_path()?;
    install_binary(&target, &binary)?;

    println!(
        "{}",
        format!("  Updated mcmod: v{current_version} → v{latest

fn fetch_latest_version() -> Result<String> {
    let body = http_get(GITHUB_RELEASES_URL)?;
    let release: serde_json::Value = serde_json::from_str(&body)?;

    let tag = release
        .get("tag_name")
        .and_then(|v| v.as_str())
        .ok_or_else(|| McmodError::Other("No tag_name in release response".to_string()))?;

    // Strip leading 'v' if present
    let version = tag.strip_prefix('v').unwrap_or(tag);
    Ok(version.to_string())
}

fn fetch_asset_url(version: &str, asset_name: &str) -> Result<String> {
    let body = http_get(GITHUB_RELEASES_URL)?;
    let release: serde_json::Value = serde_json::from_str(&body)?;

    let assets = release
        .get("assets")
        .and_then(|v| v.as_array())
        .ok_or_else(|| McmodError::Other("No assets in release response".to_string()))?;

    for asset in assets {
        let name = asset.get("name").and_then(|v| v.as_str()).unwrap_or("");
        if name == asset_name {
            let url = asset
                .get("browser_download_url")
                .and_then(|v| v.as_str())
                .ok_or_else(|| {
                    McmodError::Other("No download URL for asset".to_string())
                })?;
            return Ok(url.to_string());
        }
    }

    Err(McmodError::Other(format!(
        "No release asset found matching '{asset_name}' for v{version}"
    )))
}

fn get_asset_name() -> Result<String> {
    let os = std::env::consts::OS;
    let arch = std::env::consts::ARCH;

    let name = match (os, arch) {
        ("linux", "x86_64") => "mcmod-linux-x86_64",
        ("macos", "x86_64") => "mcmod-macos-x86_64",
        ("macos", "aarch64") => "mcmod-macos-aarch64",
        ("windows", "x86_64") => "mcmod-windows-x86_64.exe",
        _ => {
            return Err(McmodError::Other(format!(
                "Unsupported platform: {os}/{arch}"
            )));
        }
    };

    Ok(name.to_string())
}

fn install_binary(target: &Path, new_binary: &[u8]) -> Result<()> {
    // Ensure the install directory exists
    if let Some(parent) = target.parent() {
        std::fs::create_dir_all(parent)?;
    }

    if cfg!(unix) {
        install_binary_unix(target, new_binary)
    } else {
        install_binary_windows(target, new_binary)
    }
}

fn install_binary_unix(target: &Path, new_binary: &[u8]) -> Result<()> {
    let temp_path = target.with_extension("new");

    std::fs::write(&temp_path, new_binary)?;

    // Set executable permission
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(&temp_path, std::fs::Permissions::from_mode(0o755))?;
    }

    // Atomic rename
    std::fs::rename(&temp_path, target)?;

    Ok(())
}

fn install_binary_windows(target: &Path, new_binary: &[u8]) -> Result<()> {
    let old_path = target.with_extension("exe.old");

    // Clean up any leftover old file from a previous update
    if old_path.exists() {
        let _ = std::fs::remove_file(&old_path);
    }

    if target.exists() {
        // Rename current exe out of the way
        std::fs::rename(target, &old_path)?;

        // Write new binary
        if let Err(e) = std::fs::write(target, new_binary) {
            // Try to restore the old binary
            let _ = std::fs::rename(&old_path, target);
            return Err(e.into());
        }

        // Clean up old binary
        let _ = std::fs::remove_file(&old_path);
    } else {
        // Target doesn't exist yet (first update without install script)
        std::fs::write(target, new_binary)?;
    }

    Ok(())
}

    pub fn new(
        mod_id: String,
        mod_name: String,
        package: String,
        author: String,
        description: String,
        language: String,
        fabric: bool,
        neoforge: bool,
        ci: bool,
        publishing: Option<Publishing>,
        versions: Versions,
    ) -> Self {
        Self {
            mod_info: ModInfo {
                mod_id,
                mod_name,
                package,
                author,
                description,
                language,
            },
            loaders: Loaders { fabric, neoforge },
            features: Features {
                ci,
                publishing: publishing.is_some(),
            },
            versions,
            publishing,
        }
    }

    pub fn enabled_platforms(&self) -> Vec<&str> {
        let mut platforms = Vec::new();
        if self.loaders.fabric {
            platforms.push("fabric");
        }
        if self.loaders.neoforge {
            platforms.push("neoforge");
        }
        platforms
    }

    pub fn load(dir: &Path) -> Result<Self> {
        let path = dir.join(CONFIG_FILE);
        if !path.exists() {
            return Err(McmodError::ConfigNotFound);
        }
        let content = std::fs::read_to_string(&path)?;
        let config: McmodConfig = toml::from_str(&content)?;
        Ok(config)
    }

    pub fn save(&self, dir: &Path) -> Result<()> {
        let path = dir.join(CONFIG_FILE);
        let content = toml::to_string_pretty(self)?;
        std::fs::write(&path, content)?;
        Ok(())
    }

    fn default() -> Self {
        Self {
            minecraft: "1.21.4".to_string(),
            fabric_loader: "0.16.9".to_string(),
            fabric_api: "0.111.0+1.21.4".to_string(),
            neoforge: "21.4.156".to_string(),
        }
    }

    fn test_config_roundtrip() {
        let config = McmodConfig::new(
            "mymod".to_string(),
            "My Mod".to_string(),
            "com.example.mymod".to_string(),
            "TestAuthor".to_string(),
            "A test mod".to_string(),
            "java".to_string(),
            true,
            true,
            false,
            None,
            Versions::default(),
        );

        let serialized = toml::to_string_pretty(&config).unwrap();
        let deserialized: McmodConfig = toml::from_str(&serialized).unwrap();

        assert_eq!(deserialized.mod_info.mod_id, "mymod");
        assert_eq!(deserialized.mod_info.mod_name, "My Mod");
        assert_eq!(deserialized.loaders.fabric, true);
        assert_eq!(deserialized.loaders.neoforge, true);
        assert_eq!(deserialized.features.ci, false);
    }

    fn test_enabled_platforms() {
        let config = McmodConfig::new(
            "mymod".to_string(),
            "My Mod".to_string(),
            "com.example.mymod".to_string(),
            "Author".to_string(),
            "Desc".to_string(),
            "java".to_string(),
            true,
            false,
            false,
            None,
            Versions::default(),
        );
        assert_eq!(config.enabled_platforms(), vec!["fabric"]);

        let config2 = McmodConfig::new(
            "mymod".to_string(),
            "My Mod".to_string(),
            "com.example.mymod".to_string(),
            "Author".to_string(),
            "Desc".to_string(),
            "java".to_string(),
            true,
            true,
            false,
            None,
            Versions::default(),
        );
        assert_eq!(config2.enabled_platforms(), vec!["fabric", "neoforge"]);
    }

    fn default() -> Self {
        Self {
            fullscreen: Some(true),
            pause_on_lost_focus: Some(false),
            auto_jump: Some(false),
            reduced_debug_info: Some(false),
            gamma: None,
        }
    }

    fn default() -> Self {
        Self {
            do_daylight_cycle: Some(false),
            do_weather_cycle: Some(false),
            time_of_day: Some("noon".to_string()),
        }
    }

pub fn global_config_dir() -> Result<PathBuf> {
    #[cfg(target_os = "windows")]
    {
        if let Ok(appdata) = std::env::var("APPDATA") {
            return Ok(PathBuf::from(appdata).join("mcmod"));
        }
    }

    #[cfg(not(target_os = "windows"))]
    {
        if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME") {
            return Ok(PathBuf::from(xdg).join("mcmod"));
        }
    }

    // Fallback: ~/.config/mcmod
    let home = std::env::var("HOME")
        .or_else(|_| std::env::var("USERPROFILE"))
        .map_err(|_| McmodError::Other("Could not determine home directory".to_string()))?;
    Ok(PathBuf::from(home).join(".config").join("mcmod"))
}

    pub fn load() -> Result<Self> {
        let dir = global_config_dir()?;
        let path = dir.join(CONFIG_FILENAME);
        if !path.exists() {
            return Ok(Self::default());
        }
        let content = std::fs::read_to_string(&path)?;
        let config: GlobalConfig = match toml::from_str(&content) {
            Ok(c) => c,
            Err(e) => {
                eprintln!(
                    "{}",
                    format!("  Warning: Could not parse {}: {e}; using defaults", path.display()).yellow()
                );
                Self::default()
            }
        };
        Ok(config)
    }

    pub fn save(&self) -> Result<()> {
        let dir = global_config_dir()?;
        std::fs::create_dir_all(&dir)?;
        let path = dir.join(CONFIG_FILENAME);
        let content = toml::to_string_pretty(self)
            .map_err(|e| McmodError::TomlSerialize(e))?;
        std::fs::write(&path, content)?;
        Ok(())
    }

    pub fn get(&self, key: &str) -> Option<String> {
        let normalized = normalize_key(key);
        match normalized.as_str() {
            "defaults.author" => self.defaults.author.clone(),
            "defaults.language" => self.defaults.language.clone(),
            "options.fullscreen" => self.options.fullscreen.map(|v| v.to_string()),
            "options.pause_on_lost_focus" => self.options.pause_on_lost_focus.map(|v| v.to_string()),
            "options.auto_jump" => self.options.auto_jump.map(|v| v.to_string()),
            "options.reduced_debug_info" => self.options.reduced_debug_info.map(|v| v.to_string()),
            "options.gamma" => self.options.gamma.map(|v| v.to_string()),
            "gamerules.do_daylight_cycle" => self.gamerules.do_daylight_cycle.map(|v| v.to_string()),
            "gamerules.do_weather_cycle" => self.gamerules.do_weather_cycle.map(|v| v.to_string()),
            "gamerules.time_of_day" => self.gamerules.time_of_day.clone(),
            _ => 

    pub fn set(&mut self, key: &str, value: &str) -> Result<()> {
        let normalized = normalize_key(key);
        match normalized.as_str() {
            "defaults.author" => {
                self.defaults.author = Some(value.to_string());
            }
            "defaults.language" => {
                let lower = value.to_lowercase();
                if lower != "java" && lower != "kotlin" {
                    return Err(McmodError::Other(format!(
                        "Invalid language '{value}': must be 'java' or 'kotlin'"
                    )));
                }
                self.defaults.language = Some(lower);
            }
            "options.fullscreen" => {
                self.options.fullscreen = Some(parse_bool(value)?);
            }
            "options.pause_on_lost_focus" => {
                self.options.pause_on_lost_focus = Some(parse_bool(value)?);
            }
            "options.auto_jump" => {
                self.options.auto_jump = Some(pars

    pub fn list(&self) -> Vec<(&'static str, String, String)> {
        let mut entries = Vec::new();

        let display = |v: &Option<String>| {
            v.clone().unwrap_or_else(|| "(not set)".to_string())
        };
        let display_bool = |v: &Option<bool>| match v {
            Some(b) => b.to_string(),
            None => "(not set)".to_string(),
        };
        let display_f64 = |v: &Option<f64>| match v {
            Some(f) => f.to_string(),
            None => "(not set)".to_string(),
        };

        // Defaults
        entries.push(("Defaults", "author".to_string(), display(&self.defaults.author)));
        entries.push(("Defaults", "language".to_string(), display(&self.defaults.language)));

        // Client Options
        entries.push(("Client Options", "fullscreen".to_string(), display_bool(&self.options.fullscreen)));
        entries.push(("Client Options", "pauseOnLostFocus".to_string(), display_bool(&self.options.pause_on_lost_focus)));
        entries

    pub fn render_options_txt(&self) -> String {
        let mut lines = Vec::new();
        lines.push("lang:en_us".to_string());

        if let Some(v) = self.options.fullscreen {
            lines.push(format!("fullscreen:{v}"));
        }
        if let Some(v) = self.options.pause_on_lost_focus {
            lines.push(format!("pauseOnLostFocus:{v}"));
        }
        if let Some(v) = self.options.auto_jump {
            lines.push(format!("autoJump:{v}"));
        }
        if let Some(v) = self.options.reduced_debug_info {
            lines.push(format!("reducedDebugInfo:{v}"));
        }
        if let Some(v) = self.options.gamma {
            lines.push(format!("gamma:{v}"));
        }

        lines.push(String::new()); // trailing newline
        lines.join("\n")
    }

fn normalize_key(key: &str) -> String {
    match key {
        // Defaults
        "author" => "defaults.author".to_string(),
        "language" => "defaults.language".to_string(),

        // Client Options — camelCase
        "fullscreen" => "options.fullscreen".to_string(),
        "pauseOnLostFocus" | "pause_on_lost_focus" => "options.pause_on_lost_focus".to_string(),
        "autoJump" | "auto_jump" => "options.auto_jump".to_string(),
        "reducedDebugInfo" | "reduced_debug_info" => "options.reduced_debug_info".to_string(),
        "gamma" => "options.gamma".to_string(),

        // Game Rules — camelCase and snake_case
        "doDaylightCycle" | "do_daylight_cycle" => "gamerules.do_daylight_cycle".to_string(),
        "doWeatherCycle" | "do_weather_cycle" => "gamerules.do_weather_cycle".to_string(),
        "timeOfDay" | "time_of_day" => "gamerules.time_of_day".to_string(),

        other => other.to_string(),
    }
}

fn parse_bool(value: &str) -> Result<bool> {
    match value.to_lowercase().as_str() {
        "true" | "yes" | "1" => Ok(true),
        "false" | "no" | "0" => Ok(false),
        _ => Err(McmodError::Other(format!(
            "Invalid boolean '{value}': must be true/false/yes/no/1/0"
        ))),
    }
}