launcher/pages/mods/

ui.rs

use std::collections::HashMap;
use std::path::Path;

use eframe::egui;
use egui::{Align, Layout, RichText, Stroke, StrokeKind, WidgetInfo, WidgetText, WidgetType};
use egui_commonmark::{CommonMarkCache, CommonMarkViewer};
use serde_json::Value;
use supreme_fs::GameStorage;
use supreme_hook_config::{ModParameter, ParameterKind};

use super::account;
use super::tasks;
use super::tournament;
use super::types::ModsPageState;
use super::watch;
use crate::launcher_config::LauncherConfig;

pub fn mods_page(
    ui: &mut egui::Ui,
    storage: &GameStorage,
    state: &mut ModsPageState,
    launcher_config: &mut LauncherConfig,
) -> bool {
    let mut config_changed = false;

    if !state.is_initialized {
        state.is_initialized = true;
        state.mods = tasks::discover_mods(storage);
        tournament::prefill_tournament_player(storage, &mut state.mods, &mut config_changed);
        // After the prefill: a stored account enforces its identity
        // (nickname + hidden push-URL params) over whatever the prefill
        // or a hand-edited mods.json put there.
        config_changed |= account::adopt_stored_account(storage, state, launcher_config);
        state.watcher = watch::ModsWatcher::start(&tasks::mods_dir(storage), ui.ctx().clone());
    }

    // Live-reload: a mod folder was added/removed, or some file inside one
    // (most importantly mod.json) changed on disk. `selected` is left
    // alone, it's just a `dir_name`, so it naturally survives a rescan,
    // and if the selected mod is now gone the details pane below simply
    // won't find it anymore. This also catches our own writes below,
    // as it's a fallback for the immediate signals those actions already
    // return, not the only way this fires.
    if state.watcher.as_ref().is_some_and(watch::ModsWatcher::poll) {
        state.mods = tasks::discover_mods(storage);
        config_changed = true;
    }

    // Tournament: land finished room tasks before rendering, the
    // list slot refreshes the `{room_count}` cache / room_list popup, the
    // action slot persists a create/join result (selection + parameter
    // overrides, flagged via `config_changed` so the caller refreshes the
    // hook resolver). Page (re)activation then refreshes the room cache.
    config_changed |= tournament::poll_tasks(ui.ctx(), storage, state);
    tournament::on_page_activation(ui.ctx(), storage, state);

    ui.horizontal(|ui| {
        ui.heading("Mods");
        if ui
            .button(RichText::new("📂").size(16.0))
            .on_hover_text("Open mods folder")
            .clicked()
        {
            let _ = open::that(tasks::mods_dir(storage));
        }
    });
    ui.add_space(10.0);

    if state.mods.is_empty() {
        let mut cache = CommonMarkCache::default();
        CommonMarkViewer::new().show(ui, &mut cache, "No mods installed yet. Drop a mod folder (with its own mod.json) into the `mods` folder using the `📂` button at the top of this page.\n\nThis page will refresh automatically.");
        return config_changed;
    }

    egui::Panel::left("mods_list_panel")
        .resizable(true)
        .min_size(220.0)
        .max_size(320.0)
        .show(ui, |ui| {
            egui::ScrollArea::vertical().show(ui, |ui| {
                if render_mod_list(ui, storage, state) {
                    config_changed = true;
                }
            });
        });

    egui::CentralPanel::default().show(ui, |ui| match state.selected.clone() {
        Some(dir_name) => {
            if render_mod_details(ui, storage, state, &dir_name) {
                config_changed = true;
            }
        }
        None => {
            ui.centered_and_justified(|ui| {
                ui.weak("Select a mod to see its details.");
            });
        }
    });

    // Open tournament/ui-schema popup + error window, drawn above the
    // panels (same layer mechanism as the news/board windows). The
    // account popup's Log out changes the mod configuration too.
    config_changed |= tournament::render_popups(ui.ctx(), storage, state);

    // Flush a changed account record into the launcher's own config,
    // AFTER the popups so a logout click lands in the same frame.
    account::sync_stored_account(state, launcher_config);

    config_changed
}

enum RowAction {
    None,
    ToggleEnabled(usize),
    Select(String),
    MoveUp(usize),
    MoveDown(usize),
}

fn render_mod_list(ui: &mut egui::Ui, storage: &GameStorage, state: &mut ModsPageState) -> bool {
    let len = state.mods.len();
    let mut action = RowAction::None;

    for i in 0..len {
        let m = &state.mods[i];
        let is_selected = state.selected.as_deref() == Some(m.dir_name.as_str());
        let mut enabled = m.enabled;

        ui.horizontal(|ui| {
            if ui.checkbox(&mut enabled, "").changed() {
                action = RowAction::ToggleEnabled(i);
            }

            let display_text = if m.load_error.is_some() {
                RichText::new(&m.dir_name).color(egui::Color32::RED)
            } else {
                RichText::new(&m.config.name)
            };
            let mut label_response = ui.selectable_label(is_selected, display_text);
            if let Some(err) = &m.load_error {
                label_response = label_response.on_hover_text(err);
            }
            if label_response.clicked() {
                action = RowAction::Select(m.dir_name.clone());
            }

            ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                if ui
                    .add_enabled(i + 1 < len, egui::Button::new("⬇"))
                    .clicked()
                {
                    action = RowAction::MoveDown(i);
                }
                if ui.add_enabled(i > 0, egui::Button::new("⬆")).clicked() {
                    action = RowAction::MoveUp(i);
                }
            });
        });
    }

    match action {
        RowAction::None => false,
        RowAction::ToggleEnabled(i) => {
            state.mods[i].enabled = !state.mods[i].enabled;
            persist_order(storage, state)
        }
        RowAction::Select(dir_name) => {
            state.selected = Some(dir_name);
            false
        }
        RowAction::MoveUp(i) => {
            state.mods.swap(i, i - 1);
            persist_order(storage, state)
        }
        RowAction::MoveDown(i) => {
            state.mods.swap(i, i + 1);
            persist_order(storage, state)
        }
    }
}

/// Persists the mods list's current order/enabled state. Returns whether
/// it actually landed on disk, so the caller knows whether the active
/// redirection rules (and thus e.g. `supreme_fs::GameStorage`'s cached
/// hook resolver) need refreshing, not just on toggle/reorder failure,
/// but also so a no-op frame doesn't trigger a refresh for nothing.
fn persist_order(storage: &GameStorage, state: &ModsPageState) -> bool {
    if let Err(e) = tasks::save_enabled_order(storage, &state.mods) {
        eprintln!("Failed to save enabled mods: {e}");
        false
    } else {
        true
    }
}

fn render_mod_details(
    ui: &mut egui::Ui,
    storage: &GameStorage,
    state: &mut ModsPageState,
    dir_name: &str,
) -> bool {
    // Wrap entire details view in a scroll area so long parameter lists
    // or descriptions don't get clipped. The closure returns whether a
    // parameter edit was persisted this frame, propagated out via
    // `ScrollAreaOutput::inner`: same signal `render_mod_list` gives for
    // a toggle/reorder, so the caller can refresh the active redirection
    // rules (and anything derived from them, like the Display page's
    // renderer list) either way.
    egui::ScrollArea::vertical()
        .show(ui, |ui| {
            let Some(m) = state.mods.iter_mut().find(|m| m.dir_name == dir_name) else {
                return false;
            };

            render_mod_header(
                ui,
                &m.config.name,
                m.config.version.as_deref(),
                m.config.author.as_deref(),
                m.config.license.as_deref(),
                &m.warnings,
            );

            if let Some(description) = &m.config.description {
                ui.add_space(6.0);
                // Render markdown instead of plain text.
                // egui_commonmark renders inline by default, so we use a vertical
                // layout to make it behave like a block-level paragraph.
                let mod_dir = tasks::mods_dir(storage).join(dir_name);
                let image_base_uri = path_to_file_uri_prefix(&mod_dir);
                ui.vertical(|ui| {
                    let mut cache = CommonMarkCache::default();
                    CommonMarkViewer::new()
                        .default_implicit_uri_scheme(image_base_uri)
                        .show(ui, &mut cache, description);
                });
            }

            if let Some(err) = &m.load_error {
                ui.add_space(10.0);
                ui.colored_label(egui::Color32::RED, err);
                return false;
            }

            let mut config_changed = false;

            if !m.config.parameters.is_empty() {
                ui.add_space(6.0);

                // Images in a mod's help_text/description are given relative to the
                // mod's own folder (e.g. `transparent-ground.png` or
                // `.supreme/mods/transparent-things/transparent-ground.png`), so
                // point egui_commonmark's implicit `file://` scheme straight at
                // that folder. Building an absolute `file://` prefix up front
                // avoids relying on egui_commonmark to resolve a relative path
                // itself, which is what produced malformed `file://.supreme/...`
                // URIs on Windows (parsed as a UNC host) and Wine.
                let mod_dir = tasks::mods_dir(storage).join(dir_name);
                let image_base_uri = path_to_file_uri_prefix(&mod_dir);

                let parameters = m.config.parameters.clone();
                let mut changed = false;

                // Build the effective configuration once for enable_if evaluation.
                // This resolves disabled parameters to their defaults so that
                // dependent parameters see consistent values.
                let effective = m.config.effective_configuration(&m.configuration);

                for param in &parameters {
                    let is_enabled = match &param.enable_if {
                        None => true,
                        Some(expr) => supreme_hook_config::script_engine::evaluate_bool_expression(
                            expr,
                            &parameters,
                            &effective,
                        )
                        .unwrap_or(false),
                    };

                    // When a parameter becomes disabled, remove any user override
                    // so it cleanly falls back to its default. This also ensures
                    // the override doesn't linger and affect other expressions.
                    if !is_enabled && m.configuration.contains_key(&param.id) {
                        m.configuration.remove(&param.id);
                        changed = true;
                    }

                    // hidden parameters are launcher-set
                    // (`tournament_env`/`tournament_difficulty`/room id …
                    // written when the player creates or joins a room), they
                    // are declared so the resolver's enable_if expressions can
                    // see them, but a user has no business editing them. The
                    // cleanup above still runs for them; only the editor row
                    // is skipped.
                    if param.hidden {
                        continue;
                    }

                    ui.add_enabled_ui(is_enabled, |ui| {
                        let forced_error =
                            state
                                .tournament_param_error
                                .as_ref()
                                .is_some_and(|(dir, param_id)| {
                                    dir == &m.dir_name && param_id == &param.id
                                });
                        changed |= render_parameter(
                            ui,
                            param,
                            &m.config.configuration,
                            &mut m.configuration,
                            &image_base_uri,
                            forced_error,
                        );
                    });
                }

                // Persisted below, after `m`'s borrow is done (the ui-schema
                // block still needs it), same signal, one save.
                if changed {
                    config_changed = true;
                }
            }

            // The `ui` schema: generic buttons for enabled mods
            // with a `ui` section, plus the current tournament selection
            // summary. Clicks open popups / start background tournament
            // actions, persistence for those flows through
            // `tournament::poll_tasks` at the top of `mods_page`.
            if m.enabled
                && m.load_error.is_none()
                && m.config
                    .ui
                    .as_ref()
                    .is_some_and(|ui_schema| !ui_schema.buttons.is_empty())
            {
                let action_in_flight = state.action_task.is_some();
                // Split borrows: `m` holds the `state.mods` loan, these are
                // the disjoint popup/room/account fields the buttons need.
                let ModsPageState {
                    room_cache,
                    list_task,
                    open_popup,
                    popup_values,
                    popup_serial,
                    account: mod_account,
                    avatar,
                    login_popup,
                    ..
                } = state;
                tournament::render_mod_actions(
                    ui,
                    storage,
                    m,
                    action_in_flight,
                    tournament::RoomActions {
                        room_cache,
                        open_popup,
                        popup_values,
                        list_task,
                        popup_serial,
                        account: &*mod_account,
                        avatar: &*avatar,
                        login_popup,
                    },
                );
            }

            if !config_changed {
                return false;
            }
            if let Err(e) = tasks::persist_mod_configurations(storage, &state.mods) {
                eprintln!("Failed to save mod configuration for '{dir_name}': {e}");
                return false;
            }
            true
        })
        .inner
}

/// Renders the control for one parameter and applies any edit directly to
/// `configuration`. Returns whether the value changed this frame, so the
/// caller knows to persist.
fn render_mod_header(
    ui: &mut egui::Ui,
    name: &str,
    version: Option<&str>,
    author: Option<&str>,
    license: Option<&str>,
    warnings: &[String],
) {
    let meta_parts: Vec<&str> = [version, author, license]
        .into_iter()
        .flatten()
        .map(|s| s.trim())
        .filter(|s| !s.is_empty())
        .collect();

    let labelled: Vec<String> = [
        version.map(|v| format!("Version {v}")),
        author.map(|a| format!("By {a}")),
        license.map(|l| format!("License: {l}")),
    ]
    .into_iter()
    .flatten()
    .collect();
    let meta_string = labelled.join("   ·   ");
    let has_meta = !meta_parts.is_empty();

    let title_wt = WidgetText::from(egui::RichText::new(name));
    let title_w = title_wt
        .clone()
        .into_galley(
            ui,
            Some(egui::TextWrapMode::Truncate),
            f32::INFINITY,
            egui::TextStyle::Heading,
        )
        .size()
        .x;
    let meta_wt = if has_meta {
        Some(WidgetText::from(RichText::new(meta_string.as_str()).weak()))
    } else {
        None
    };
    let meta_w = meta_wt
        .as_ref()
        .map(|wt| {
            wt.clone()
                .into_galley(
                    ui,
                    Some(egui::TextWrapMode::Truncate),
                    f32::INFINITY,
                    egui::TextStyle::Body,
                )
                .size()
                .x
        })
        .unwrap_or(0.0);

    // Inside a ScrollArea, available_width() can be unreliable on the first
    // frame. Fall back to max_rect width which is always valid.
    let available = ui.available_width().max(ui.max_rect().width());
    let min_gap = ui.spacing().item_spacing.x * 2.0;

    let fits_on_one_line = has_meta && title_w + min_gap + meta_w <= available;

    if fits_on_one_line {
        ui.horizontal(|ui| {
            ui.heading(name);
            render_warning_icon(ui, warnings);
            ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                ui.label(meta_wt.unwrap());
            });
        });
    } else {
        ui.horizontal(|ui| {
            ui.heading(name);
            render_warning_icon(ui, warnings);
        });
        if let Some(meta_wt) = meta_wt {
            ui.label(meta_wt);
        }
    }
}

/// Renders a subtle ⚠️ icon inline after the mod title when there are
/// unknown-key warnings. Hovering shows the full list. Does nothing when
/// `warnings` is empty, so callers don't need to guard.
fn render_warning_icon(ui: &mut egui::Ui, warnings: &[String]) {
    if warnings.is_empty() {
        return;
    }
    let warning_text = warnings.join("\n");
    ui.label(
        RichText::new("⚠️")
            .size(14.0)
            .color(ui.visuals().warn_fg_color),
    )
    .on_hover_text(warning_text);
}

fn render_parameter(
    ui: &mut egui::Ui,
    param: &ModParameter,
    defaults: &HashMap<String, Value>,
    configuration: &mut HashMap<String, Value>,
    image_base_uri: &str,
    forced_error: bool,
) -> bool {
    let mut changed = false;

    egui::Frame::group(ui.style())
        .fill(ui.visuals().faint_bg_color)
        .inner_margin(egui::Margin::from(6.0))
        .stroke(Stroke::NONE)
        .corner_radius(4.0)
        .show(ui, |ui| {
            ui.set_min_width(ui.available_width());

            ui.horizontal(|ui| {
                ui.label(&param.name);

                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                    match &param.kind {
                        ParameterKind::Boolean => {
                            let mut value = effective_value(&param.id, defaults, configuration)
                                .and_then(Value::as_bool)
                                .unwrap_or(false);
                            if ui.add(toggle(&mut value)).changed() {
                                configuration.insert(param.id.clone(), Value::Bool(value));
                                changed = true;
                            }
                        }
                        ParameterKind::Dropdown { choices } => {
                            // Empty string reads as "(None)" for display, but only
                            // when `""` is itself one of `choices`, there's no
                            // implicit, always-available None option. A dropdown with
                            // no empty-string choice is a mandatory pick among
                            // `choices`, with no off state (and always reads truthy
                            // for gating once anything's been picked).
                            let current = effective_value(&param.id, defaults, configuration)
                                .and_then(Value::as_str)
                                .unwrap_or("")
                                .to_owned();

                            egui::ComboBox::from_id_salt(&param.id)
                                .selected_text(if current.is_empty() {
                                    "(None)"
                                } else {
                                    current.as_str()
                                })
                                .show_ui(ui, |ui| {
                                    for choice in choices {
                                        let label = if choice.is_empty() {
                                            "(None)"
                                        } else {
                                            choice.as_str()
                                        };
                                        if ui.selectable_label(&current == choice, label).clicked()
                                        {
                                            configuration.insert(
                                                param.id.clone(),
                                                Value::String(choice.clone()),
                                            );
                                            changed = true;
                                        }
                                    }
                                });
                        }
                        ParameterKind::Number { min, max, step } => {
                            let mut value = effective_value(&param.id, defaults, configuration)
                                .and_then(Value::as_f64)
                                .map_or(*min, |v| v as f32);
                            let mut slider = egui::Slider::new(&mut value, *min..=*max);
                            if let Some(step) = step {
                                slider = slider.step_by(f64::from(*step));
                            }
                            let width = 180.0_f32.min(ui.available_width());
                            let response =
                                ui.add_sized([width, ui.spacing().interact_size.y], slider);
                            if response.changed() {
                                configuration.insert(param.id.clone(), serde_json::json!(value));
                            }
                            if response.drag_stopped() {
                                changed = true;
                            }
                        }
                        ParameterKind::Text => {
                            let mut value = effective_value(&param.id, defaults, configuration)
                                .and_then(Value::as_str)
                                .unwrap_or("")
                                .to_owned();
                            let width = 200.0_f32.min(ui.available_width());
                            // Live validation on tagged text parameters (the
                            // visible tournament player name): the reason
                            // renders as an error stroke + a warning icon
                            // next to the control, both while editing and
                            // when a refused create/join forces the
                            // highlight on.
                            let mut reason = param.validation.as_deref().and_then(|tag| {
                                supreme_hook_config::validation::validate_value(tag, &value).err()
                            });
                            if reason.is_none() && forced_error {
                                reason = Some(format!(
                                    "A tournament action was refused: {} needs a valid value.",
                                    param.name
                                ));
                            }
                            let mut edited = false;
                            ui.horizontal(|ui| {
                                let response = ui.add_sized(
                                    [width, ui.spacing().interact_size.y],
                                    egui::TextEdit::singleline(&mut value),
                                );
                                edited = response.changed();
                                if let Some(reason) = &reason {
                                    ui.painter().rect_stroke(
                                        response.rect,
                                        4.0,
                                        egui::Stroke::new(1.6, ui.visuals().error_fg_color),
                                        egui::StrokeKind::Inside,
                                    );
                                    ui.label(
                                        RichText::new("\u{26A0}")
                                            .color(ui.visuals().error_fg_color),
                                    )
                                    .on_hover_text(reason);
                                }
                            });
                            if edited {
                                configuration.insert(param.id.clone(), Value::String(value));
                                changed = true;
                            }
                        }
                    }
                });
            });

            if !param.help_text.is_empty() {
                let mut cache = CommonMarkCache::default();
                CommonMarkViewer::new()
                    .default_implicit_uri_scheme(image_base_uri)
                    .show(ui, &mut cache, &param.help_text);
            }
        });

    ui.add_space(8.0);

    changed
}

/// Turns an absolute directory path into a `file://` prefix suitable for
/// [`CommonMarkViewer::default_implicit_uri_scheme`], so that a relative
/// image path in markdown (e.g. `foo.png` or `.supreme/mods/x/foo.png`)
/// resolves unambiguously against that directory.
///
/// egui_commonmark builds the final image URI via plain string
/// concatenation (`format!("{scheme}{relative_path}")`), so the prefix
/// returned here must already end in `/` and must not leave any part of
/// the relative path looking like a URI authority. In particular, a plain
/// `"file://" + "some/relative/path"` is wrong on every platform: with no
/// authority marker, the URI parser reads the first path segment as a
/// hostname, and on Windows that host is then resolved as a UNC network
/// share (which is where "Error 37: network name cannot be found" comes
/// from), Wine reports the equivalent failure as a plain path-not-found.
/// Anchoring the scheme to an absolute path up front avoids the ambiguity
/// entirely.
///
/// `dir` is expected to already be absolute (join of a known storage root
/// with a mod's directory name); if it isn't, it's resolved relative to
/// the current working directory as a best effort, since a relative path
/// here would reintroduce the same ambiguity this function exists to avoid.
fn path_to_file_uri_prefix(dir: &Path) -> String {
    let dir = if dir.is_absolute() {
        dir.to_path_buf()
    } else {
        std::env::current_dir()
            .map(|cwd| cwd.join(dir))
            .unwrap_or_else(|_| dir.to_path_buf())
    };

    let mut s = dir.to_string_lossy().replace('\\', "/");
    if !s.ends_with('/') {
        s.push('/');
    }

    if s.starts_with('/') {
        // Already-absolute Unix path: file:///path/to/mod/
        format!("file://{s}")
    } else {
        // Windows drive-letter path (e.g. "C:/Users/.../mod/"): needs an
        // extra leading slash for the empty-authority form.
        format!("file:///{s}")
    }
}

/// The value actually shown for a parameter: an explicit override (from
/// the active preset's configuration in `mods.json`, what a person
/// has actually changed via the launcher) if one exists, else the mod's
/// own default from its `mod.json` `configuration` block, else unset
/// entirely.
fn effective_value<'a>(
    id: &str,
    defaults: &'a HashMap<String, Value>,
    overrides: &'a HashMap<String, Value>,
) -> Option<&'a Value> {
    overrides.get(id).or_else(|| defaults.get(id))
}

// ---------------------------------------------------------------------------
// iOS‑style toggle switch (from egui demo)
// ---------------------------------------------------------------------------

pub fn toggle_ui(ui: &mut egui::Ui, on: &mut bool) -> egui::Response {
    let desired_size = ui.spacing().interact_size.y * egui::vec2(2.0, 1.0);
    let (rect, mut response) = ui.allocate_exact_size(desired_size, egui::Sense::click());

    if response.clicked() {
        *on = !*on;
        response.mark_changed();
    }
    response.widget_info(|| WidgetInfo::selected(WidgetType::Checkbox, ui.is_enabled(), *on, ""));

    if ui.is_rect_visible(rect) {
        let how_on = ui.ctx().animate_bool_responsive(response.id, *on);
        let visuals = ui.style().interact_selectable(&response, *on);
        let rect = rect.expand(visuals.expansion);
        let radius = 0.5 * rect.height();
        ui.painter().rect(
            rect,
            radius,
            visuals.bg_fill,
            visuals.bg_stroke,
            StrokeKind::Inside,
        );
        let circle_x = egui::lerp((rect.left() + radius)..=(rect.right() - radius), how_on);
        let center = egui::pos2(circle_x, rect.center().y);
        ui.painter()
            .circle(center, 0.75 * radius, visuals.bg_fill, visuals.fg_stroke);
    }

    response
}

pub fn toggle(on: &mut bool) -> impl egui::Widget + '_ {
    move |ui: &mut egui::Ui| toggle_ui(ui, on)
}