launcher/pages/mods/

tasks.rs

use std::path::{Path, PathBuf};

use supreme_fs::GameStorage;
use supreme_hook_config::{
    DEFAULT_MODS_DIR_NAME, HookConfigError, MOD_FILE_NAME, ModConfig, ModsPreset, load_mods_state,
    save_mods_state,
};

use super::types::LoadedMod;

pub(super) fn mods_dir(storage: &GameStorage) -> PathBuf {
    storage.game_path().join(DEFAULT_MODS_DIR_NAME)
}

/// Scans `.supreme/mods/`, loads every mod's `mod.json`, and pairs each one
/// with its current values from the active configuration in
/// `mods.json`.
///
/// Ordering: [`ModsPreset::order`] (of the active configuration) is the
/// single, stable source of list position, toggling a mod's enabled state
/// never changes it. A mod folder found on disk but not yet in `order`
/// (new install, or a mod a just-applied preset didn't mention, see
/// [`supreme_hook_config::ModsState::apply_preset`]) is appended at the
/// end, alphabetically among any other new-this-scan folders; a name in
/// `order` no longer found on disk is dropped. The reconciled order is
/// written straight back so `order` never drifts from what's actually on
/// disk between scans. For the active configuration, display order and
/// DLL merge priority are the same list, `order` filtered to what's
/// enabled (see [`ModsPreset::priority_order`]), so there's nothing else
/// to reconcile. A mod that fails to load or validate still gets a row,
/// see [`LoadedMod::load_error`], rather than disappearing from the list.
pub fn discover_mods(storage: &GameStorage) -> Vec<LoadedMod> {
    let dir = mods_dir(storage);
    let mut state = load_mods_state(&dir).unwrap_or_default();

    let mut found_names: Vec<String> = std::fs::read_dir(&dir)
        .ok()
        .into_iter()
        .flatten()
        .flatten()
        .filter(|entry| entry.path().is_dir())
        .filter_map(|entry| entry.file_name().into_string().ok())
        .collect();
    found_names.sort();

    state.sync_active_order(found_names);
    let enabled_set: std::collections::HashSet<&str> =
        state.active.enabled.iter().map(String::as_str).collect();

    let mods: Vec<LoadedMod> = state
        .active
        .order
        .iter()
        .map(|name| {
            let enabled = enabled_set.contains(name.as_str());
            load_one_mod(&dir, name, enabled, &state.active)
        })
        .collect();

    // Persist the reconciled order/enabled-set so a subsequent scan (or
    // the DLL's own load) sees exactly what was just shown, even if this
    // was the first time a new mod folder was ever seen.
    if let Err(e) = save_mods_state(&dir, &state) {
        eprintln!("Failed to save reconciled mods state: {e}");
    }

    mods
}

fn load_one_mod(mods_dir: &Path, dir_name: &str, enabled: bool, active: &ModsPreset) -> LoadedMod {
    let path = mods_dir.join(dir_name).join(MOD_FILE_NAME);
    let configuration = active
        .configuration
        .get(dir_name)
        .cloned()
        .unwrap_or_default();
    match ModConfig::load_from_path_with_warnings(&path) {
        Ok((config, warnings)) => {
            let load_error = config.validate().err().map(|errors| errors.join("; "));
            LoadedMod {
                dir_name: dir_name.to_string(),
                config,
                configuration,
                enabled,
                load_error,
                warnings,
            }
        }
        Err(e) => LoadedMod {
            dir_name: dir_name.to_string(),
            // A placeholder so the row still has a name to display,
            // `dir_name` is the best guess available since the real
            // `mod.json` couldn't be read.
            config: ModConfig {
                name: dir_name.to_string(),
                ..ModConfig::default()
            },
            configuration,
            enabled,
            load_error: Some(format!("Couldn't load mod.json: {e}")),
            warnings: Vec::new(),
        },
    }
}

/// Persists the current display order and enabled set of `mods` to
/// `mods.json`: `active.order` is set directly from `mods`' current
/// list order, this is what makes reordering in the UI stick, and, since
/// display order *is* DLL merge priority for the active configuration,
/// what makes a drag-reorder change priority too. `active.enabled` is set
/// to the checked subset (membership only; its effective order always
/// comes from `active.order` via [`ModsPreset::priority_order`], never
/// stored separately). A single call covers both a checkbox toggle and a
/// drag-reorder, since `mods` already reflects whichever just happened.
/// Called after every checkbox toggle or reorder.
///
/// # Errors
///
/// Returns an error if the mods directory can't be created or the file
/// can't be written.
pub fn save_enabled_order(
    storage: &GameStorage,
    mods: &[LoadedMod],
) -> Result<(), HookConfigError> {
    let dir = mods_dir(storage);
    let mut state = load_mods_state(&dir).unwrap_or_default();

    state.active.order = mods.iter().map(|m| m.dir_name.clone()).collect();
    let enabled: Vec<&str> = mods
        .iter()
        .filter(|m| m.enabled)
        .map(|m| m.dir_name.as_str())
        .collect();
    state.active.set_enabled(enabled);

    save_mods_state(&dir, &state)
}

/// Persists every currently-loaded mod's in-memory `configuration`
/// (overrides only, never a mod's `mod.json` defaults) into the active
/// configuration in `mods.json`. Merges with whatever's already
/// there rather than replacing it wholesale, so a mod not currently in
/// `mods` (temporarily removed, or failed to load this session) keeps its
/// saved overrides rather than losing them the next time anything else
/// gets persisted. Never touches any mod's own `mod.json`, so an edit
/// here can't clobber a mod author's rules/parameters/defaults, and
/// replacing a mod's whole directory (e.g. an update) can't take a
/// person's overrides for it along with it.
///
/// # Errors
///
/// Returns an error if the mods directory can't be created or the file
/// can't be written.
pub fn persist_mod_configurations(
    storage: &GameStorage,
    mods: &[LoadedMod],
) -> Result<(), HookConfigError> {
    let dir = mods_dir(storage);
    let mut state = load_mods_state(&dir).unwrap_or_default();

    for m in mods {
        state
            .active
            .configuration
            .insert(m.dir_name.clone(), m.configuration.clone());
    }

    save_mods_state(&dir, &state)
}