launcher/pages/mods/

tournament.rs

//! Tournament UI for the Mods page.
//!
//! Two halves live here:
//!
//! 1. **Generic `ui`-schema rendering**, every enabled mod whose `mod.json`
//!    carries a `ui` section gets its buttons under its details panel
//!    ([`render_mod_actions`]). A button opens its popup
//!    ([`render_popups`]), which is either an input form built from the
//!    authored fields or a live room list fetched from the server. Both are
//!    driven entirely by the parsed [`ModUi`]; nothing about
//!    `online-tournament` is hardcoded beyond the `tournament.*` action
//!    handlers themselves (the action/config ids are internal wire names
//!    kept stable across the "Championship → Tournament" rename,
//!    only the player-facing strings changed).
//!
//! 2. **The `tournament.create` / `tournament.join` action handlers**
//!    create or join a room over HTTP (background task,
//!    the UI thread never blocks), then persist the selection into the
//!    mod's active configuration via [`mods_tasks::persist_mod_configurations`]
//!    (the same mechanism as a parameter edit). There is NO extra
//!    selection file: `tournament_room.json` carried nothing the mod
//!    configuration doesn't already have; the room id/name/window/player
//!    now live where the hook resolver already interpolates from
//!    (see `tournament_selection::TournamentSelection`).
//!
//! UX rules implemented here:
//! - the player name is NEVER asked for: it is read from
//!   `Saved_Data/Arcade_Player.txt` (the game writes it; the uploaded .dat
//!   files carry it). Unreadable → the action is refused with that
//!   guidance, no editable fallback field;
//! - the create form's Starts/Ends REALLY default to now/tomorrow on every
//!   open (the previous selection no longer prefills them);
//! - the room list renders square card buttons with the track's
//!   `Menu_Texture_Normal.tga` as the background (the room NAME on the
//!   card, the rest in the tooltip) instead of full-width text rows;
//! - hints render inside text fields (`UiField::hint`).
//!
//! The Play button's `Online` label is computed by
//! [`tournament_play_selection`], called from the footer.

use crate::launcher_config::AccountConfig;
use crate::tasks::{TaskEvent, TaskHandle, spawn_task};
use crate::tournament_selection::{
    TOURNAMENT_ROOMS_CFG, TOURNAMENT_ENDS_AT_CFG, TOURNAMENT_ROOM_NAME_CFG,
    TOURNAMENT_STARTS_AT_CFG, TournamentSelection, format_tournament_when, is_online,
};
// Trait method syntax below (`chrono::Local.from_local_datetime(..)`,
// `.year()`/`.hour()`/…).
use crate::utils::texture_loader::load_texture_robust;
use chrono::{Datelike as _, TimeZone as _, Timelike as _};
use eframe::egui;
use egui::{Align, Color32, FontId, Layout, RichText, Sense};
use serde_json::Value;
use std::collections::HashMap;
use std::io::ErrorKind;
use supreme_fs::{GameStorage, RoomDto, RoomIdentity, RoomSummaryDto};
use supreme_hook_config::{
    HookConfig, ModUi, UiButton, UiField, UiFieldKind, UiPopup, UiPopupKind, load_mods_state,
    managed_file_specs, validation,
};

use super::tasks as mods_tasks;
use super::types::{LoadedMod, ModsPageState};

/// Live placeholder in button labels, filled from the cached `room_list`
/// (contract A).
const ROOM_COUNT_PLACEHOLDER: &str = "{room_count}";

/// Parameter ids the mod package declares for its enable_if-gated redirect
/// rules (contract E, exactly these strings).
const TOURNAMENT_ENV_PARAM: &str = "tournament_env";
const TOURNAMENT_DIFFICULTY_PARAM: &str = "tournament_difficulty";
/// the remaining selection values the mod's managed-file rules
/// interpolate into their `remote` URLs (declarative remote-backed files,
/// the DLL builds no URLs itself). the server URL is not among
/// them, the mod's own `configuration` ships that default; injecting it
/// from launcher code would make the mod non-self-contained.
const TOURNAMENT_ROOM_ID_PARAM: &str = "tournament_room_id";
pub(super) const TOURNAMENT_PLAYER_PARAM: &str = "tournament_player";

/// the room-card background texture, the track's own menu tile,
/// shipped with the game at
/// `Data/Levels/<Environment>/Tracks/<Difficulty>/Menu_Texture_Normal.tga`.
const MENU_TEXTURE_RELPATH: &str = "Data/Levels";
const MENU_TEXTURE_FILE: &str = "Menu_Texture_Normal.tga";
/// card size (square cards).
const ROOM_CARD_SIZE: f32 = 148.0;

/// the Create form popup's width. egui 0.35's `Window::auto_sized`
/// opens at INFINITY clamped to the whole content rect (nearly the full
/// app width, the "Create room popup takes all the horizontal space"
/// bug) and never shrinks back. A fixed, form-sized width plus widgets
/// that do NOT fill the available width (see `render_field`) gives the
/// compact popup the form deserves.
const CREATE_POPUP_WIDTH: f32 = 320.0;

/// the Create form's widget-column width (the room-name box, the
/// dropdowns). Deliberately NOT "fill available width", see the window
/// sizing note in `render_form_popup`.
const FORM_FIELD_WIDTH: f32 = 170.0;

// ---------------------------------------------------------------------------
// UI state types (stored on ModsPageState)
// ---------------------------------------------------------------------------

/// The live value of one popup field, keyed by
/// `(mod dir, button id, field id)`, per button, per contract B.
#[derive(Debug, Clone, PartialEq)]
pub(super) enum PopupValue {
    Text(String),
    Number(f64),
}

/// The popup currently open. Keyed per (mod, button): two buttons may point
/// at the same popup id, and each gets its own window and field values.
#[derive(Debug, Clone)]
pub(super) struct OpenPopup {
    /// `dir_name` of the mod owning the button.
    pub mod_dir: String,
    /// `UiButton::id` that opened this popup.
    pub button_id: String,
    /// The popup's id in `ModUi::popups`.
    pub popup_id: String,
    /// The owning button's action string (e.g. `tournament.create`).
    pub action: String,
    /// monotonically increasing open counter, part of the egui
    /// window id, a fresh id per open gives the window fresh geometry
    /// state, so the popup re-opens at its authored size every time
    /// instead of keeping the widest size it ever grew to.
    pub open_serial: u64,
}

/// Cached `list_rooms` result, shared by `{room_count}` labels and the
/// room_list popup (contract A: fetched on page activation and whenever a
/// room_list popup opens).
#[derive(Debug, Clone, Default)]
pub(super) enum RoomCache {
    #[default]
    Idle,
    Loading,
    Ready(Vec<RoomSummaryDto>),
    Failed,
}

impl RoomCache {
    /// What `{room_count}` renders as right now. `-` on fetch failure per
    /// contract A.
    fn count_text(&self) -> String {
        match self {
            Self::Ready(rooms) => rooms.len().to_string(),
            Self::Failed => "-".to_owned(),
            Self::Idle | Self::Loading => "…".to_owned(),
        }
    }
}

/// What a finished rooms task produced, `list_rooms` for the cache slot,
/// `create_room`/`join_room` for the action slot.
#[derive(Debug)]
pub(super) enum RoomTaskResult {
    Rooms(Vec<RoomSummaryDto>),
    Room(RoomDto),
    /// A `room_remove` succeeded; the payload is the removed room's id
    /// (the selection cleanup needs to know WHICH room went away).
    Removed(String),
}

/// Everything needed to persist once a create/join task succeeds (the task
/// thread must not touch UI state, so this rides along on the UI side).
#[derive(Debug, Clone)]
pub(super) struct PendingSelection {
    pub mod_dir: String,
    pub player: String,
}

/// A room removal awaiting its confirmation popup's verdict.
#[derive(Debug, Clone)]
pub(super) struct RemoveConfirm {
    /// `dir_name` of the mod whose room list offered the removal (the
    /// player identity lives in its configuration).
    pub mod_dir: String,
    pub room_id: String,
    /// Display name (or `"env / difficulty"` for unnamed rooms), shown
    /// in the confirmation copy.
    pub name: String,
}

// ---------------------------------------------------------------------------
// Page-level wiring (called from mods_page)
// ---------------------------------------------------------------------------

/// Drains both in-flight rooms tasks. Must run before rendering so the same
/// frame reflects completions.
///
/// Returns whether a create/join **persisted**, the caller must refresh
/// the hook resolver (same signal a parameter edit produces), so the
/// freshly-written `tournament_env` / `tournament_difficulty` overrides
/// are interpolated into the redirect rules on the next Play.
pub(super) fn poll_tasks(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
) -> bool {
    let mut config_changed = false;

    // Room-list slot: feeds the cache only. The result is drained out
    // from under the `list_task` borrow, the room-list persistence needs
    // the whole `state`.
    let mut list_result: Option<Result<RoomTaskResult, String>> = None;
    if let Some(handle) = state.list_task.as_mut() {
        let mut finished = false;
        while let Ok(event) = handle.try_recv() {
            let TaskEvent::Finished(res) = event else {
                continue;
            };
            finished = true;
            list_result = Some(res);
        }
        if finished {
            state.list_task = None;
        }
    }
    match list_result {
        Some(Ok(RoomTaskResult::Rooms(rooms))) => {
            config_changed |= persist_room_list(storage, state, &rooms);
            state.room_cache = RoomCache::Ready(rooms);
        }
        Some(Ok(RoomTaskResult::Room(_))) => {} // never produced by the list slot
        Some(Ok(RoomTaskResult::Removed(_))) => {} // never produced by the list slot
        Some(Err(e)) => {
            eprintln!("Tournament: failed to list rooms: {e}");
            state.room_cache = RoomCache::Failed;
        }
        None => {}
    }

    // Create/join slot: on success persist the selection + overrides.
    // The finished result is drained out from under the `action_task` borrow
    // and applied after it ends, persistence needs the whole `state`.
    let mut action_result: Option<Result<RoomTaskResult, String>> = None;
    if let Some(handle) = state.action_task.as_mut() {
        let mut finished = false;
        while let Ok(event) = handle.try_recv() {
            let TaskEvent::Finished(res) = event else {
                continue;
            };
            finished = true;
            action_result = Some(res);
        }
        if finished {
            state.action_task = None;
        }
    }
    if let Some(res) = action_result {
        match res {
            Ok(RoomTaskResult::Room(room)) => {
                config_changed |= persist_selection(storage, state, &room);
            }
            Ok(RoomTaskResult::Removed(room_id)) => {
                config_changed |= handle_room_removed(ctx, storage, state, &room_id);
            }
            Ok(RoomTaskResult::Rooms(_)) => {} // never produced by the action slot
            Err(e) => {
                // Server unreachable, room expired, …, surface it, never panic.
                eprintln!("Tournament: room request failed: {e}");
                state.tournament_error = Some(e);
            }
        }
        // Consumed either way (success already used it; failure means
        // nothing to persist).
        state.pending_selection = None;
    }

    // Account-link + avatar slots (the logged-in player mode): a landed
    // link writes the identity overrides, a logout drops them.
    config_changed |= super::account::poll_tasks(ctx, storage, state);

    config_changed
}

/// Detects the Mods page (re)becoming active and refreshes the room cache
/// when any rendered content needs live room data (contract A).
///
/// `mods_page` runs exactly once per rendered pass while the page is
/// visible, so a pass number that isn't exactly "last + 1" means at least
/// one pass rendered with another page on top, i.e. we just came back.
pub(super) fn on_page_activation(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
) {
    let now = ctx.cumulative_pass_nr();
    let activated = state.last_seen_pass.is_none_or(|last| now != last + 1);
    state.last_seen_pass = Some(now);

    if activated && needs_room_data(state) {
        start_list_task(ctx, storage, &mut state.room_cache, &mut state.list_task);
    }
}

/// Whether any enabled, loadable mod's `ui` references live room data: a
/// `{room_count}` label or a `room_list` popup.
fn needs_room_data(state: &ModsPageState) -> bool {
    state.mods.iter().any(|m| {
        m.enabled
            && m.load_error.is_none()
            && is_online(&m.configuration)
            && m.config.ui.as_ref().is_some_and(|ui_schema| {
                ui_schema
                    .buttons
                    .iter()
                    .any(|b| b.label.contains(ROOM_COUNT_PLACEHOLDER))
                    || ui_schema
                        .popups
                        .values()
                        .any(|p| p.kind == UiPopupKind::RoomList)
            })
    })
}

/// Spawns `list_rooms` on a background thread (the established
/// `spawn_task` mechanism; egui repaints on completion because
/// `TaskSender::send` calls `ctx.request_repaint()`).
fn start_list_task(
    ctx: &egui::Context,
    storage: &GameStorage,
    room_cache: &mut RoomCache,
    list_task: &mut Option<TaskHandle<RoomTaskResult>>,
) {
    if list_task.is_some() {
        return; // one fetch at a time; the cache updates when it lands
    }
    *room_cache = RoomCache::Loading;
    let storage = storage.clone();
    *list_task = Some(spawn_task(ctx.clone(), move |_tx| {
        storage
            .list_rooms()
            .map(RoomTaskResult::Rooms)
            .map_err(|e| e.to_string())
    }));
}

// ---------------------------------------------------------------------------
// Buttons + selection summary (details panel)
// ---------------------------------------------------------------------------

/// Renders the `ui` buttons for one enabled mod, plus its current
/// tournament selection summary when one exists (switching is
/// allowed and overwrites the previous selection).
pub(super) fn render_mod_actions(
    ui: &mut egui::Ui,
    storage: &GameStorage,
    m: &LoadedMod,
    action_in_flight: bool,
    actions: RoomActions<'_>,
) {
    let RoomActions {
        room_cache,
        open_popup,
        popup_values,
        list_task,
        popup_serial,
        account,
        avatar,
        login_popup,
    } = actions;
    let Some(ui_schema) = m.config.ui.as_ref() else {
        return;
    };
    if ui_schema.buttons.is_empty() {
        return;
    }
    // The mod's own play-online toggle: when it is off the whole
    // tournament flow hides, the game's rules go dormant and the vanilla
    // main menu lists the rooms instead.
    if !is_online(&m.configuration) {
        return;
    }

    ui.add_space(6.0);
    ui.horizontal(|ui| {
        for button in &ui_schema.buttons {
            let label = button
                .label
                .replace(ROOM_COUNT_PLACEHOLDER, &room_cache.count_text());
            let mut response = ui.add_enabled(!action_in_flight, egui::Button::new(label));
            if action_in_flight {
                response = response.on_hover_text("Another tournament request is already running.");
            }
            if response.clicked() {
                on_button_clicked(
                    ui.ctx(),
                    storage,
                    m,
                    button,
                    RoomActions {
                        room_cache: &mut *room_cache,
                        open_popup: &mut *open_popup,
                        popup_values: &mut *popup_values,
                        list_task: &mut *list_task,
                        popup_serial: &mut *popup_serial,
                        account,
                        avatar,
                        login_popup: &mut *login_popup,
                    },
                );
            }
        }

        // The launcher-owned account chip, after the mod's own buttons:
        // a guest gets the Log in button (the browser link flow), a
        // logged-in player gets the avatar + nickname, opening the
        // account panel (Log out). It is deliberately NOT part of the
        // mod's `ui` schema - the account belongs to the launcher, not
        // to any single mod package.
        render_account_chip(ui, m, account, avatar, login_popup);
    });

    // Current selection, a quiet status line read from
    // the mod's active configuration; switching rooms simply overwrites
    // the values. The room ID is never shown by design, the NAME
    // is, with the planning window and a liveness note.
    let selection = TournamentSelection::from_configuration(&m.configuration);
    if let Some(selection) = selection {
        ui.add_space(4.0);
        let now = chrono::Utc::now().timestamp();
        let label = if selection.name.is_empty() {
            format!("{} / {}", selection.env, selection.difficulty)
        } else {
            selection.name.clone()
        };
        let window = if selection.starts_at > 0 {
            format!(
                "{} → {}",
                format_tournament_when(selection.starts_at),
                format_tournament_when(selection.ends_at),
            )
        } else {
            format!("until {}", format_tournament_when(selection.ends_at))
        };
        let state_note = selection
            .play_blocker(now)
            .map(|blocker| format!(" ({blocker})"))
            .unwrap_or_default();
        ui.horizontal(|ui| {
            ui.label(RichText::new("Current room:").weak());
            ui.label(format!("{label} · {window}{state_note}"));
        });
    }
}

/// The account chip at the end of the action row. A guest sees **Log
/// in** (starts the browser link flow - the popup opens in Waiting and
/// the poll pass spawns the task); a logged-in player sees the avatar +
/// nickname and the click opens the account panel (the identity, Log
/// out). The avatar falls back to the 👤 glyph until it loaded.
fn render_account_chip(
    ui: &mut egui::Ui,
    m: &LoadedMod,
    account: &Option<AccountConfig>,
    avatar: &super::account::AvatarState,
    login_popup: &mut Option<super::account::LoginPopup>,
) {
    let Some(account) = account else {
        let mut login = ui.button("\u{1F464} Log in");
        login = login.on_hover_text(
            "Log in with a tournament account (opens your browser). Rooms you create \n\
             and join then carry your verified identity, and your nickname is yours alone.",
        );
        if login.clicked() {
            *login_popup = Some(super::account::LoginPopup::Waiting {
                mod_dir: m.dir_name.clone(),
                url: None,
            });
        }
        return;
    };
    let mut chip = match avatar {
        super::account::AvatarState::Ready { texture, .. } => {
            let image = egui::Image::new(texture).fit_to_exact_size(egui::vec2(18.0, 18.0));
            ui.add(egui::Button::image_and_text(image, &account.nickname))
        }
        _ => ui.add(egui::Button::new(format!("\u{1F464} {}", account.nickname))),
    };
    chip = chip.on_hover_text(format!(
        "Logged in as {} (account #{}). Click to open the account panel.",
        account.account_name, account.user_id
    ));
    if chip.clicked() {
        *login_popup = Some(super::account::LoginPopup::Linked);
    }
}

/// A button was pressed: open its popup, seeding per-button default values.
fn on_button_clicked(
    ctx: &egui::Context,
    storage: &GameStorage,
    m: &LoadedMod,
    button: &UiButton,
    actions: RoomActions<'_>,
) {
    let RoomActions {
        room_cache,
        open_popup,
        popup_values,
        list_task,
        popup_serial,
        ..
    } = actions;
    let Some(ui_schema) = m.config.ui.as_ref() else {
        return;
    };
    let Some(popup_id) = button.popup.as_deref() else {
        // A popup-less tournament action has nothing to collect input
        // from (tournament actions always open a popup), log and ignore.
        eprintln!(
            "Mods page: button '{}' has action '{}' but no popup to open",
            button.id, button.action
        );
        return;
    };
    let Some(popup) = ui_schema.popups.get(popup_id) else {
        return; // rejected by ModUi::validate, but never trust that here
    };

    // Reset this button's fields to their defaults (per button id).
    popup_values.retain(|(dir, btn, _), _| !(dir == &m.dir_name && btn == &button.id));
    for field in &popup.fields {
        let default = default_field_value(m, field);
        popup_values.insert(
            (m.dir_name.clone(), button.id.clone(), field.id.clone()),
            default,
        );
    }

    // Live room data every time a room_list popup opens (contract A).
    if popup.kind == UiPopupKind::RoomList {
        start_list_task(ctx, storage, room_cache, list_task);
    }

    // a fresh window serial per open, the auto-sized popup
    // re-hugs its contents instead of keeping a stale geometry.
    *popup_serial += 1;
    let open_serial = *popup_serial;

    *open_popup = Some(OpenPopup {
        mod_dir: m.dir_name.clone(),
        button_id: button.id.clone(),
        popup_id: popup_id.to_owned(),
        action: button.action.clone(),
        open_serial,
    });
}

/// The default value for one authored field when a popup opens. Selects
/// prefill from the mod's current tournament overrides (so "switching"
/// starts from the live selection); datetimes REALLY default to the
/// room window's natural bounds (STARTS = now, ENDS = tomorrow) on every
/// open, the previous selection never prefills them (the label must not
/// claim a default the form doesn't apply); text fields start empty.
fn default_field_value(m: &LoadedMod, field: &UiField) -> PopupValue {
    match field.kind {
        UiFieldKind::Number => PopupValue::Number(0.0),
        UiFieldKind::Select | UiFieldKind::Duration => {
            let current = tournament_param_override_key(&field.id)
                .and_then(|param| m.configuration.get(param))
                .and_then(Value::as_str)
                .filter(|value| field.options.iter().any(|option| option == *value))
                .map(ToOwned::to_owned);
            PopupValue::Text(
                current.unwrap_or_else(|| field.options.first().cloned().unwrap_or_default()),
            )
        }
        UiFieldKind::DateTime => {
            let default_epoch = match field.id.as_str() {
                "ends_at" => now_epoch() + 86_400,
                _ => now_epoch(),
            };
            PopupValue::Text(default_epoch.to_string())
        }
        UiFieldKind::Text | UiFieldKind::Unknown(_) => PopupValue::Text(String::new()),
    }
}

/// `Utc::now` as epoch seconds, the datetime fields' default anchor.
fn now_epoch() -> i64 {
    chrono::Utc::now().timestamp()
}

// ---------------------------------------------------------------------------
// Popups (rendered at page level, above the panels)
// ---------------------------------------------------------------------------

/// Renders the currently open popup (if any) and the tournament error
/// window. Called once per frame from `mods_page`. Returns whether the
/// mod configuration changed (the account popup's Log out restores the
/// guest player name).
pub(super) fn render_popups(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
) -> bool {
    let mut config_changed = false;
    if let Some(open) = state.open_popup.clone() {
        // The owning mod/button must still exist and still point at this
        // popup, a live-reload may have swapped mod.json underneath us.
        let popup = state
            .mods
            .iter()
            .find(|m| {
                m.dir_name == open.mod_dir
                    && m.config.ui.as_ref().is_some_and(|ui_schema| {
                        ui_schema.buttons.iter().any(|b| {
                            b.id == open.button_id
                                && b.popup.as_deref() == Some(open.popup_id.as_str())
                        })
                    })
            })
            .and_then(|m| m.config.ui.as_ref())
            .and_then(|ui_schema| ui_schema.popups.get(&open.popup_id))
            .cloned();

        match popup {
            Some(popup) => match popup.kind {
                UiPopupKind::Form => render_form_popup(ctx, storage, state, &open, &popup),
                UiPopupKind::RoomList => render_room_list_popup(ctx, storage, state, &open, &popup),
                UiPopupKind::Unknown(_) => state.open_popup = None,
            },
            None => state.open_popup = None,
        }
    }

    if let Some(error) = state.tournament_error.clone() {
        let mut is_open = true;
        egui::Window::new("Tournament")
            .id(egui::Id::new("mods_tournament_error"))
            .open(&mut is_open)
            .collapsible(false)
            .resizable(false)
            .show(ctx, |ui| {
                ui.colored_label(ui.visuals().error_fg_color, &error);
                ui.add_space(4.0);
                ui.vertical_centered(|ui| {
                    if ui.button("Close").clicked() {
                        state.tournament_error = None;
                    }
                });
            });
        if !is_open {
            state.tournament_error = None;
        }
    }

    if let Some(remove) = state.remove_confirm.clone() {
        render_remove_confirm_popup(ctx, storage, state, &remove);
    }

    // The account popup (Waiting / Linked / Failed), above the rest like
    // the other tournament popups.
    config_changed |= super::account::render_login_popup(ctx, storage, state);
    config_changed
}

/// The removal confirmation: names the room, states the effect, and only
/// the explicit Remove click starts the request (the server deletes the
/// room's files; an accidental click must never do that).
fn render_remove_confirm_popup(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    remove: &RemoveConfirm,
) {
    let mut is_open = true;
    let mut confirmed = false;
    // The Cancel button can't touch `is_open` directly (the Window
    // builder holds that borrow until `show` returns), it sets this flag
    // instead, the same shape as the form popup.
    let mut cancelled = false;
    egui::Window::new("Remove room")
        .id(egui::Id::new((
            "mods_tournament_remove_confirm",
            &remove.room_id,
        )))
        .open(&mut is_open)
        .collapsible(false)
        .resizable(false)
        .show(ctx, |ui| {
            ui.label(format!("Remove \"{}\" from the server?", remove.name));
            ui.add_space(4.0);
            ui.label(
                "The room is deleted for everyone and cannot be restored. \
                 Only you (the creator) see this because nobody has joined \
                 and the room has not started yet.",
            );
            ui.add_space(6.0);
            ui.horizontal(|ui| {
                let remove_button = ui
                    .button(RichText::new("Remove").color(ui.visuals().error_fg_color));
                if remove_button.clicked() {
                    confirmed = true;
                }
                if ui.button("Cancel").clicked() {
                    cancelled = true;
                }
            });
        });
    if confirmed {
        state.remove_confirm = None;
        start_remove_task(ctx, storage, state, remove);
    } else if cancelled || !is_open {
        state.remove_confirm = None;
    }
}

fn render_form_popup(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    open: &OpenPopup,
    popup: &UiPopup,
) {
    let mut is_open = true;
    let mut confirmed = false;
    // The Cancel button can't touch `is_open` directly, the Window builder
    // holds that borrow until `show` returns, so it sets this flag instead.
    let mut cancelled = false;

    // Every authored field's current validity, computed BEFORE the window
    // renders so the confirm button can be disabled with the reason on
    // hover while anything is invalid (the user sees why, not just that).
    let field_value = |field_id: &str| -> Option<String> {
        state
            .popup_values
            .get(&(
                open.mod_dir.clone(),
                open.button_id.clone(),
                field_id.to_owned(),
            ))
            .and_then(as_text)
            .cloned()
    };
    let confirm_blockers = confirm_blockers(popup, field_value);

    egui::Window::new(popup.title.as_str())
        .id(egui::Id::new((
            "mods_tournament_popup",
            &open.mod_dir,
            &open.button_id,
            open.open_serial,
        )))
        .open(&mut is_open)
        .collapsible(false)
        // NOT `auto_sized`, in egui 0.35 that opens the window at
        // INFINITY clamped to the app's content rect (nearly the full
        // app width) and the window never shrinks afterwards. A fixed
        // form-sized width does the hugging instead; the widgets below do
        // not fill the available width, so nothing pushes it wider. The
        // fresh per-open serial in the id still gives every open clean
        // geometry state.
        .resizable(false)
        .default_width(CREATE_POPUP_WIDTH)
        .show(ctx, |ui| {
            ui.add_space(2.0);
            egui::Grid::new("tournament_form_fields")
                .num_columns(2)
                .spacing([12.0, 8.0])
                .min_col_width(90.0)
                .show(ui, |ui| {
                    for field in &popup.fields {
                        ui.label(&field.label);
                        render_field(ui, open, field, &mut state.popup_values);
                        ui.end_row();
                    }
                });
            ui.add_space(6.0);
            ui.separator();
            ui.horizontal(|ui| {
                let confirm = ui.add_enabled(
                    state.action_task.is_none() && confirm_blockers.is_empty(),
                    egui::Button::new(confirm_label(&open.action)),
                );
                if confirm.clicked() {
                    confirmed = true;
                }
                if let Some(reason) = confirm_blockers.first() {
                    // Disabled with the WHY on hover: the fix is in the
                    // field, not in a hidden rule.
                    confirm.on_disabled_hover_text(reason);
                } else if state.action_task.is_some() {
                    confirm
                        .on_disabled_hover_text("Another tournament request is already running.");
                }
                if ui.button("Cancel").clicked() {
                    cancelled = true;
                }
            });
        });

    if confirmed {
        handle_form_confirm(ctx, storage, state, open);
        is_open = false; // the action fired, close the form either way
    }
    if cancelled {
        is_open = false;
    }
    if !is_open {
        state.open_popup = None;
    }
}

fn render_room_list_popup(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    open: &OpenPopup,
    popup: &UiPopup,
) {
    let mut is_open = true;

    egui::Window::new(popup.title.as_str())
        .id(egui::Id::new((
            "mods_tournament_popup",
            &open.mod_dir,
            &open.button_id,
        )))
        .open(&mut is_open)
        .collapsible(false)
        .resizable(true)
        .default_width(560.0)
        .default_height(430.0)
        .show(ctx, |ui| {
            ui.separator();

            // Authored fields (none in the room_list popups, but render
            // them generically if a mod adds some). The player identity
            // is NOT asked here: it is the mod page's visible
            // `tournament_player` parameter (prefilled from
            // Saved_Data/Arcade_Player.txt once); a join without one is
            // refused at the card click and highlights that parameter.
            if !popup.fields.is_empty() {
                egui::Grid::new("tournament_room_list_fields")
                    .num_columns(2)
                    .spacing([12.0, 8.0])
                    .min_col_width(90.0)
                    .show(ui, |ui| {
                        for field in &popup.fields {
                            ui.label(&field.label);
                            render_field(ui, open, field, &mut state.popup_values);
                            ui.end_row();
                        }
                    });
                ui.separator();
            }

            ui.horizontal(|ui| {
                ui.strong("Open rooms");
                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                    let refresh =
                        ui.add_enabled(state.list_task.is_none(), egui::Button::new("🔄 Refresh"));
                    if refresh.clicked() {
                        start_list_task(
                            ctx,
                            storage,
                            &mut state.room_cache,
                            &mut state.list_task,
                        );
                    }
                    refresh.on_hover_text("Reload the list of open rooms from the server.");
                    if state.list_task.is_some() {
                        ui.spinner();
                    }
                });
            });
            ui.separator();

            // Clone the room list out of the cache first, card clicks
            // mutate state (start the join), which can't borrow it.
            enum RoomListBody {
                Loading,
                Failed,
                Empty,
                Rooms(Vec<RoomSummaryDto>),
            }
            let body = match &state.room_cache {
                RoomCache::Idle | RoomCache::Loading => RoomListBody::Loading,
                RoomCache::Failed => RoomListBody::Failed,
                RoomCache::Ready(rooms) => {
                    if rooms.is_empty() {
                        RoomListBody::Empty
                    } else {
                        RoomListBody::Rooms(rooms.clone())
                    }
                }
            };

            match body {
                RoomListBody::Loading => {
                    ui.horizontal(|ui| {
                        ui.spinner();
                        ui.label("Loading rooms…");
                    });
                }
                RoomListBody::Failed => {
                    ui.colored_label(
                        ui.visuals().error_fg_color,
                        "Couldn't load rooms. Is the server reachable? Try Refresh.",
                    );
                }
                RoomListBody::Empty => {
                    ui.weak("No open rooms right now. Create one with the other button, or hit Refresh.");
                }
                RoomListBody::Rooms(rooms) => {
                    egui::ScrollArea::vertical().show(ui, |ui| {
                        let now = chrono::Utc::now().timestamp();
                        // square card buttons instead of the old
                        // full-width text rows (name + track + difficulty
                        // + host + players + records + end crammed into a
                        // single label). One card per room, the track's
                        // menu texture as the background, the name on the
                        // card, the details in the tooltip.
                        ui.horizontal_wrapped(|ui| {
                            ui.add_space(2.0);
                            for room in &rooms {
                                render_room_card(ui, ctx, storage, state, open, room, now);
                            }
                        });
                    });
                }
            }
        });

    if !is_open {
        state.open_popup = None;
    }
}

/// Refined one room as a square card button, fully
/// self-contained, no content below the tile. The background is the
/// track's `Menu_Texture_Normal.tga` (fallback: an environment-tinted
/// panel); the room NAME sits on a darkened band for legibility with the
/// "N players" count right beneath it; the top-left carries a rough
/// countdown chip (the biggest remaining denomination only: months,
/// weeks, days, hours, minutes) and the top-right the Results icon that
/// opens the room's standings page in the browser. The rest (track,
/// host, planning window) stays in the tooltip. A room that has not
/// started (or has expired) renders dimmed and inert, with the reason in
/// the tooltip.
fn render_room_card(
    ui: &mut egui::Ui,
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    open: &OpenPopup,
    room: &RoomSummaryDto,
    now: i64,
) {
    let live = room.is_live(now);
    let name = if room.name.is_empty() {
        format!("{} / {}", room.env, room.difficulty)
    } else {
        room.name.clone()
    };

    ui.vertical(|ui| {
        let (rect, response) = ui.allocate_exact_size(
            egui::vec2(ROOM_CARD_SIZE, ROOM_CARD_SIZE),
            if live { Sense::click() } else { Sense::hover() },
        );
        // Background: the track's menu texture (cached per env/difficulty).
        let texture = room_card_texture(ctx, storage, state, &room.env, &room.difficulty);
        match &texture {
            Some(texture) => {
                let tint = if live {
                    Color32::WHITE
                } else {
                    Color32::from_gray(105)
                };
                ui.painter().image(
                    texture.id(),
                    rect,
                    egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
                    tint,
                );
            }
            None => {
                let base = env_card_color(&room.env);
                let base = if live {
                    base
                } else {
                    base.gamma_multiply(0.55)
                };
                ui.painter().rect_filled(rect, 6.0, base);
            }
        }

        // Top-left: the rough countdown chip (clock + biggest remaining
        // denomination). Live rooms count down to their end; scheduled
        // rooms to their start; expired rooms show nothing.
        let countdown_target = if room.starts_at > now {
            Some(room.starts_at)
        } else if live {
            Some(room.ends_at)
        } else {
            None
        };
        if let Some(target) = countdown_target {
            paint_chip(
                ui,
                egui::pos2(rect.left() + 5.0, rect.top() + 5.0),
                format!("\u{1F550} {}", rough_countdown(target - now)),
                FontId::proportional(12.5),
            );
        }

        // Top-right: the Results icon, the room's standings page (ranking
        // + stats) in the browser. The URL is the SERVER's (it knows how
        // it is exposed to browsers); when the server does not publish
        // one, no icon renders, the launcher never assembles the URL
        // itself. Registered after the card response so clicks inside the
        // icon go to the icon, not the card.
        if let Some(results_url) = &room.results_url {
            let icon_size = 26.0;
            let icon_rect = egui::Rect::from_min_size(
                egui::pos2(rect.right() - icon_size - 5.0, rect.top() + 5.0),
                egui::vec2(icon_size, icon_size),
            );
            let icon_response = ui.interact(
                icon_rect,
                egui::Id::new(("tournament_room_card_results", &room.id)),
                Sense::click(),
            );
            ui.painter().rect_filled(
                icon_rect,
                6.0,
                if icon_response.hovered() {
                    Color32::from_black_alpha(215)
                } else {
                    Color32::from_black_alpha(150)
                },
            );
            paint_galley_centered(
                ui,
                icon_rect.center(),
                "\u{1F4CA}",
                FontId::proportional(14.0),
            );
            if icon_response.clicked() {
                if let Err(e) = open::that(results_url) {
                    eprintln!("Tournament: could not open browser for {results_url}: {e}");
                    state.tournament_error = Some(format!("Could not open the browser: {e}"));
                }
            }
            icon_response
                .on_hover_text("Open this room's results page (ranking and stats) in your browser");
        }

        // Below the Results icon: the Remove chip, offered ONLY on the
        // player's own un-started rooms nobody else joined (the server
        // re-checks all three guards; this gate only decides whether the
        // affordance exists). Opens the confirmation popup, never deletes
        // directly. A logged-in account also owns rooms carrying its
        // user id as the owner.
        let account_user_id = state.account.as_ref().map(|account| account.user_id);
        if let Some(player) = tournament_player_of(state, &open.mod_dir)
            && room_can_be_removed(room, &player, account_user_id, now)
        {
            let icon_size = 26.0;
            let icon_rect = egui::Rect::from_min_size(
                egui::pos2(rect.right() - icon_size - 5.0, rect.top() + icon_size + 9.0),
                egui::vec2(icon_size, icon_size),
            );
            let icon_response = ui.interact(
                icon_rect,
                egui::Id::new(("tournament_room_card_remove", &room.id)),
                Sense::click(),
            );
            ui.painter().rect_filled(
                icon_rect,
                6.0,
                if icon_response.hovered() {
                    Color32::from_black_alpha(215)
                } else {
                    Color32::from_black_alpha(150)
                },
            );
            paint_galley_centered(
                ui,
                icon_rect.center(),
                "\u{1F5D1}",
                FontId::proportional(14.0),
            );
            if icon_response.clicked() {
                state.remove_confirm = Some(RemoveConfirm {
                    mod_dir: open.mod_dir.clone(),
                    room_id: room.id.clone(),
                    name: name.clone(),
                });
            }
            icon_response.on_hover_text(
                "Remove this room (you created it, nobody has joined, it has not started)",
            );
        }

        // Name band: darken the lower third so the text always reads; the
        // room NAME with the "N players" count right beneath it.
        let players_text = format!(
            "{} player{}",
            room.player_count,
            if room.player_count == 1 { "" } else { "s" }
        );
        let name_galley = ui.painter().layout(
            name.clone(),
            FontId::proportional(15.0),
            Color32::WHITE,
            ROOM_CARD_SIZE - 12.0,
        );
        let players_galley = ui.painter().layout(
            players_text,
            FontId::proportional(11.5),
            Color32::from_gray(215),
            ROOM_CARD_SIZE - 12.0,
        );
        let band_height = name_galley.size().y + players_galley.size().y + 11.0;
        let band = egui::Rect::from_min_max(
            egui::pos2(rect.left(), rect.bottom() - band_height),
            egui::pos2(rect.right(), rect.bottom()),
        );
        ui.painter()
            .rect_filled(band, 0.0, Color32::from_black_alpha(150));
        let name_pos = egui::pos2(
            rect.left() + 6.0,
            band.bottom() - players_galley.size().y - name_galley.size().y - 6.0,
        );
        ui.painter().galley(name_pos, name_galley, Color32::WHITE);
        let players_pos = egui::pos2(
            rect.left() + 6.0,
            band.bottom() - players_galley.size().y - 4.0,
        );
        ui.painter()
            .galley(players_pos, players_galley, Color32::from_gray(215));

        let when = if room.starts_at > now {
            format!("starts {}", format_tournament_when(room.starts_at))
        } else if live {
            format!("ends {}", format_tournament_when(room.ends_at))
        } else {
            format!("ended {}", format_tournament_when(room.ends_at))
        };
        let hint = if live {
            "Click to join this room as your player"
        } else if room.starts_at > now {
            "Not started yet; join when it goes live"
        } else {
            "This room has expired"
        };
        let tooltip = format!(
            "{name}\n{} / {} · host {}\n{} players\n{when}\n\n{hint}",
            room.env, room.difficulty, room.host, room.player_count,
        );
        if live && response.clicked() {
            handle_room_selected(ctx, storage, state, open, &room.id);
        }
        response.on_hover_text(tooltip);
    });
    ui.add_space(4.0);
}

/// paints a small dark chip with `text` at `top_left` and returns
/// nothing, used for the card's countdown chip (clock emoji + unit).
fn paint_chip(ui: &mut egui::Ui, top_left: egui::Pos2, text: String, font: FontId) {
    let galley = ui
        .painter()
        .layout(text, font, Color32::WHITE, f32::INFINITY);
    let chip = egui::Rect::from_min_size(
        top_left,
        egui::vec2(galley.size().x + 10.0, galley.size().y + 6.0),
    );
    ui.painter()
        .rect_filled(chip, 4.0, Color32::from_black_alpha(150));
    ui.painter().galley(
        egui::pos2(chip.left() + 5.0, chip.center().y - galley.size().y / 2.0),
        galley,
        Color32::WHITE,
    );
}

/// one centered text glyph inside `rect` (the Results icon).
fn paint_galley_centered(ui: &mut egui::Ui, center: egui::Pos2, text: &str, font: FontId) {
    let galley = ui
        .painter()
        .layout(text.to_owned(), font, Color32::WHITE, f32::INFINITY);
    ui.painter().galley(
        egui::pos2(
            center.x - galley.size().x / 2.0,
            center.y - galley.size().y / 2.0,
        ),
        galley,
        Color32::WHITE,
    );
}

/// the card countdown's rough text, the biggest remaining time
/// denomination ONLY (month, week, day, hour, minute), e.g. "5 weeks" or
/// "13 minutes". Rough by design: a denomination appears from two units
/// of it upwards (60 days → "2 months", 45 days → "6 weeks", 90 minutes
/// → "90 minutes"), everything below a minute rounds up to "1 minute".
fn rough_countdown(seconds: i64) -> String {
    let seconds = seconds.max(0);
    const MINUTE: i64 = 60;
    const HOUR: i64 = 60 * MINUTE;
    const DAY: i64 = 24 * HOUR;
    const WEEK: i64 = 7 * DAY;
    const MONTH: i64 = 30 * DAY;
    let (value, unit) = if seconds >= 2 * MONTH {
        (seconds / MONTH, "month")
    } else if seconds >= 2 * WEEK {
        (seconds / WEEK, "week")
    } else if seconds >= 2 * DAY {
        (seconds / DAY, "day")
    } else if seconds >= 2 * HOUR {
        (seconds / HOUR, "hour")
    } else {
        (seconds / MINUTE, "minute")
    };
    let value = value.max(1);
    if value == 1 {
        format!("1 {unit}")
    } else {
        format!("{value} {unit}s")
    }
}

/// The card texture for one env/difficulty track: the game's
/// `Data/Levels/<Environment>/Tracks/<Difficulty>/Menu_Texture_Normal.tga`,
/// resolved case-insensitively by the shared texture loader and cached on
/// the page state (`None` = tried and failed → the tinted fallback card).
fn room_card_texture(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    env: &str,
    difficulty: &str,
) -> Option<egui::TextureHandle> {
    let key = format!("{env}/{difficulty}");
    if let Some(cached) = state.room_card_textures.get(&key) {
        return cached.clone();
    }
    let loaded = load_room_menu_texture(ctx, storage, env, difficulty);
    state.room_card_textures.insert(key, loaded.clone());
    loaded
}

fn load_room_menu_texture(
    ctx: &egui::Context,
    storage: &GameStorage,
    env: &str,
    difficulty: &str,
) -> Option<egui::TextureHandle> {
    let base = storage.game_path().join(MENU_TEXTURE_RELPATH);
    // The game ships capitalized level/difficulty directories; try the
    // wire's lowercase first (Windows is case-insensitive either way),
    // then the capitalized spelling for case-sensitive filesystems.
    for (env_dir, diff_dir) in [
        (env.to_owned(), difficulty.to_owned()),
        (capitalize(env), capitalize(difficulty)),
    ] {
        let path = base
            .join(&env_dir)
            .join("Tracks")
            .join(&diff_dir)
            .join(MENU_TEXTURE_FILE);
        if let Ok(texture) =
            load_texture_robust(ctx, &path, &format!("room_card_{env_dir}_{diff_dir}"))
        {
            return Some(texture);
        }
    }
    eprintln!("Tournament: no menu texture for {env}/{difficulty}; using the fallback card");
    None
}

fn capitalize(word: &str) -> String {
    let mut chars = word.chars();
    match chars.next() {
        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
        None => String::new(),
    }
}

/// Fallback card color when a track's menu texture is unavailable.
fn env_card_color(env: &str) -> Color32 {
    match env {
        "alpine" => Color32::from_rgb(74, 111, 165),  // ice blue
        "forest" => Color32::from_rgb(62, 112, 77),   // pine green
        "village" => Color32::from_rgb(126, 100, 84), // warm wood
        other => {
            // Deterministic tint from the name so unknown envs still differ.
            let hash: u32 = other.bytes().map(u32::from).sum::<u32>() % 251;
            Color32::from_rgb(
                (70 + hash * 13 % 60) as u8,
                (90 + hash * 29 % 50) as u8,
                120,
            )
        }
    }
}

/// Renders one authored (or synthetic) field into the shared value map.
fn render_field(
    ui: &mut egui::Ui,
    open: &OpenPopup,
    field: &UiField,
    values: &mut HashMap<(String, String, String), PopupValue>,
) {
    let key = (
        open.mod_dir.clone(),
        open.button_id.clone(),
        field.id.clone(),
    );
    match &field.kind {
        UiFieldKind::Select | UiFieldKind::Duration => {
            let mut current = values
                .get(&key)
                .and_then(as_text)
                .map(String::as_str)
                .unwrap_or("")
                .to_owned();
            // fixed width, a ComboBox sizes to its selected text
            // (fine), but an unfixed one still participates in the grid's
            // available-width stretch; the explicit width keeps the form
            // column at its authored size.
            egui::ComboBox::from_id_salt((
                "mods_tournament_field",
                &open.mod_dir,
                &open.button_id,
                &field.id,
            ))
            .width(FORM_FIELD_WIDTH)
            .selected_text(if current.is_empty() {
                "(None)"
            } else {
                current.as_str()
            })
            .show_ui(ui, |ui| {
                for option in &field.options {
                    if ui.selectable_label(current == *option, option).clicked() {
                        values.insert(key.clone(), PopupValue::Text(option.clone()));
                        current = option.clone();
                    }
                }
            });
        }
        UiFieldKind::Text => {
            let mut value = values
                .get(&key)
                .and_then(as_text)
                .cloned()
                .unwrap_or_default();
            // Snapshot for the live validation below: the TextEdit holds
            // the value mutably for the whole frame (immediate mode), so
            // the check reads the pre-frame value; the edited value is
            // stored right away and the reason catches up next frame.
            let current = value.clone();
            let mut edit = egui::TextEdit::singleline(&mut value);
            // fixed width, the default TextEdit FILLS the
            // available width, which is exactly what pushed the old
            // auto-sized window to the app's full width (and what would
            // pin any window at its default width forever, since egui
            // windows only grow). A authored-size box lets the window hug
            // the form.
            edit = edit.desired_width(FORM_FIELD_WIDTH);
            // the mod's hint renders INSIDE the box (e.g. the
            // room name's "(optional)"), not as label padding.
            if let Some(hint) = &field.hint {
                edit = edit.hint_text(hint);
            }
            // Live validation while the user types: an invalid value
            // gets an error stroke around the box and a warning icon
            // whose hover carries the reason. The confirm button is
            // disabled by the same rule, the reason is never a secret.
            let reason = field
                .validation
                .as_deref()
                .and_then(|tag| validation::validate_value(tag, &current).err());
            let mut edited = false;
            ui.horizontal(|ui| {
                let response = ui.add(edit);
                edited = response.changed();
                if let Some(reason) = &reason {
                    ui.painter().rect_stroke(
                        response.rect,
                        2.0,
                        egui::Stroke::new(1.4, 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 {
                values.insert(key.clone(), PopupValue::Text(value));
            }
        }
        UiFieldKind::Number => {
            let mut value = values.get(&key).and_then(as_number).copied().unwrap_or(0.0);
            if ui
                .add(egui::DragValue::new(&mut value).speed(1.0))
                .changed()
            {
                values.insert(key.clone(), PopupValue::Number(value));
            }
        }
        UiFieldKind::DateTime => {
            // date + time pickers from the existing egui widgets,
            // egui_extras' DatePickerButton for the calendar, hour/minute
            // DragValues for the time-of-day. The stored value is a UTC
            // epoch-seconds string; what the user picks is LOCAL time.
            let epoch = values
                .get(&key)
                .and_then(as_text)
                .and_then(|text| text.parse::<i64>().ok())
                .unwrap_or_else(now_epoch);
            let local = chrono::DateTime::from_timestamp(epoch, 0)
                .map(|utc| utc.with_timezone(&chrono::Local))
                .unwrap_or_else(chrono::Local::now);
            let (mut hour, mut minute) = (local.hour() as i32, local.minute() as i32);
            // egui_extras' DatePickerButton is jiff-based (its `selection`
            // is a `jiff::civil::Date`), bridge chrono→jiff for the
            // picker and jiff→chrono for the epoch math.
            let mut jdate =
                jiff::civil::date(local.year() as i16, local.month() as i8, local.day() as i8);
            ui.horizontal(|ui| {
                let id_salt = format!(
                    "mods_tournament_datepicker/{}/{}/{}",
                    open.mod_dir, open.button_id, field.id
                );
                // The button's label comes from `.format(...)`, the
                // jiff strftime of the picked date itself.
                ui.add(
                    egui_extras::DatePickerButton::new(&mut jdate)
                        .id_salt(&id_salt)
                        .format("%Y-%m-%d (%a)"),
                );
                ui.add(
                    egui::DragValue::new(&mut hour)
                        .range(0..=23)
                        .suffix("h")
                        .update_while_editing(false),
                );
                ui.add(
                    egui::DragValue::new(&mut minute)
                        .range(0..=59)
                        .suffix("m")
                        .update_while_editing(false),
                );
            });
            let picked = chrono::NaiveDate::from_ymd_opt(
                i32::from(jdate.year()),
                u32::from(jdate.month() as u8),
                u32::from(jdate.day() as u8),
            )
            .and_then(|date| {
                date.and_hms_opt(hour.clamp(0, 23) as u32, minute.clamp(0, 59) as u32, 0)
            })
            .and_then(|naive| chrono::Local.from_local_datetime(&naive).single())
            .map(|local| local.timestamp())
            .unwrap_or(epoch);
            values.insert(key.clone(), PopupValue::Text(picked.to_string()));
        }
        UiFieldKind::Unknown(kind) => {
            // Rejected by ModUi::validate long before this point; shown
            // inertly rather than swallowed, just in case.
            ui.label(RichText::new(format!("unsupported field kind `{kind}`")).weak());
        }
    }
}

fn as_text(value: &PopupValue) -> Option<&String> {
    match value {
        PopupValue::Text(text) => Some(text),
        PopupValue::Number(_) => None,
    }
}

fn as_number(value: &PopupValue) -> Option<&f64> {
    match value {
        PopupValue::Text(_) => None,
        PopupValue::Number(number) => Some(number),
    }
}

// ---------------------------------------------------------------------------
// Action handling (tournament.create / tournament.join)
// ---------------------------------------------------------------------------

fn is_tournament_action(action: &str) -> bool {
    action.starts_with("tournament.")
}

fn confirm_label(action: &str) -> &'static str {
    match action {
        "tournament.create" => "Create",
        "tournament.join" => "Join",
        _ => "OK",
    }
}

/// The reasons a form popup's Confirm button must stay disabled: every
/// authored field whose validation tag refuses its current value, plus
/// the planning-window cross-field rule (END after STARTS). Empty =
/// the form is confirmable. Pure so the gating copy can be unit tested
/// without a live egui context; the render path feeds it the popup's
/// live values, the reasons surface on the disabled button's hover.
fn confirm_blockers(popup: &UiPopup, value_of: impl Fn(&str) -> Option<String>) -> Vec<String> {
    let mut blockers: Vec<String> = Vec::new();
    for field in &popup.fields {
        let Some(tag) = &field.validation else {
            continue;
        };
        let value = value_of(&field.id).unwrap_or_default();
        if let Err(reason) = validation::validate_value(tag, &value) {
            blockers.push(format!("{}: {reason}", field.label));
        }
    }
    // Cross-field: the planning window must END after it STARTS (the
    // datetime defaults are now/tomorrow, so a fresh form never trips).
    if popup.fields.iter().any(|f| f.id == "starts_at")
        && popup.fields.iter().any(|f| f.id == "ends_at")
    {
        let parse_epoch =
            |field_id: &str| value_of(field_id).and_then(|text| text.trim().parse::<i64>().ok());
        if let (Some(starts_at), Some(ends_at)) = (parse_epoch("starts_at"), parse_epoch("ends_at"))
            && ends_at <= starts_at
        {
            blockers.push(
                "The room must END after it STARTS. Adjust the date/time pickers.".to_owned(),
            );
        }
    }
    blockers
}

/// The player identity a create/join runs as, read from the mod's
/// `tournament_player` parameter (the mod page's visible, live-validated
/// control). Refuses with the reason when the value is missing or
/// invalid, and highlights the parameter on the mod page
/// ([`ModsPageState::tournament_param_error`]) so the fix happens where
/// the value lives.
fn player_for_action(state: &mut ModsPageState, mod_dir: &str) -> Result<String, String> {
    let raw = state
        .mods
        .iter()
        .find(|m| m.dir_name == mod_dir)
        .and_then(|m| m.configuration.get(TOURNAMENT_PLAYER_PARAM))
        .and_then(Value::as_str)
        .unwrap_or_default();
    match validation::validate_player_name(raw) {
        Ok(name) => {
            // A valid value clears any stale highlight from a previous
            // refusal.
            if let Some((dir, param)) = &state.tournament_param_error
                && dir == mod_dir
                && param == TOURNAMENT_PLAYER_PARAM
            {
                state.tournament_param_error = None;
            }
            Ok(name)
        }
        Err(reason) => {
            state.tournament_param_error =
                Some((mod_dir.to_owned(), TOURNAMENT_PLAYER_PARAM.to_owned()));
            Err(reason)
        }
    }
}

/// One popup field's current text value, keyed (mod dir, button id,
/// field id). A free function, not a closure, so call sites that also
/// need `&mut` access to the page state (the player highlight) never
/// hold the immutable borrow across it.
fn popup_field_value(state: &ModsPageState, open: &OpenPopup, field_id: &str) -> Option<String> {
    state
        .popup_values
        .get(&(
            open.mod_dir.clone(),
            open.button_id.clone(),
            field_id.to_owned(),
        ))
        .and_then(as_text)
        .cloned()
}

/// The form's confirm button was pressed: gather values and start the
/// corresponding network action on a background task.
fn handle_form_confirm(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    open: &OpenPopup,
) {
    match open.action.as_str() {
        "tournament.create" => {
            // The player identity is the mod page's visible
            // `tournament_player` parameter (validated live while it is
            // edited). Missing or invalid: the create is refused and the
            // parameter is highlighted, the fix happens there, not in a
            // popup field.
            let player = match player_for_action(state, &open.mod_dir) {
                Ok(player) => player,
                Err(reason) => {
                    state.tournament_error = Some(reason);
                    return;
                }
            };
            // Field ids per the `ui` schema (shape); unknown/missing ones fall
            // back to safe defaults instead of guessing at other ids.
            let env = popup_field_value(state, open, "env").unwrap_or_else(|| "alpine".to_owned());
            let difficulty =
                popup_field_value(state, open, "difficulty").unwrap_or_else(|| "easy".to_owned());
            // Optional display name, empty means the server autogenerates
            // a snowboarding name (and enforces its blocklist on a given
            // one, surfacing refusals as the error popup). The charset is
            // validated client-side so the refusal never surprises.
            let name = popup_field_value(state, open, "name")
                .unwrap_or_default()
                .trim()
                .to_owned();
            if let Err(reason) = validation::validate_room_name(&name) {
                state.tournament_error = Some(reason);
                return;
            }
            let parse_epoch = |field_id: &str, fallback: i64| -> i64 {
                popup_field_value(state, open, field_id)
                    .and_then(|text| text.trim().parse::<i64>().ok())
                    .unwrap_or(fallback)
            };
            let starts_at = parse_epoch("starts_at", now_epoch());
            let ends_at = parse_epoch("ends_at", now_epoch() + 86_400);
            if ends_at <= starts_at {
                state.tournament_error = Some(
                    "The room must END after it STARTS. Adjust the date/time pickers.".to_owned(),
                );
                return;
            }
            start_create_task(
                ctx,
                storage,
                state,
                CreateRoomForm {
                    mod_dir: open.mod_dir.clone(),
                    env,
                    difficulty,
                    player,
                    name,
                    starts_at,
                    ends_at,
                },
            );
        }
        "tournament.join" => {
            // Joining needs a room id, which only a room_list popup provides
            // (the `ui` schema wires tournament.join to a room_list popup).
            state.tournament_error = Some(
                "This button must open a `room_list` popup so a room to join can be picked."
                    .to_owned(),
            );
        }
        action if action.starts_with("tournament.") => {
            state.tournament_error = Some(format!("Unsupported tournament action `{action}`."));
        }
        action => {
            // Free-form actions are reserved for future use, not
            // launcher-handled; log like the rest of the app and close.
            eprintln!("Mods page: popup action `{action}` is not launcher-handled; nothing to do.");
        }
    }
}

/// One-time prefill of the visible `tournament_player` parameter from
/// `Saved_Data/Arcade_Player.txt` (the game writes the file when a rider
/// is picked; the value must match what the game writes since it travels
/// inside every uploaded .dat). Only touches enabled, loadable mods that
/// declare the parameter VISIBLE (hidden launcher-set parameters are
/// written by the create/join flow, never prefilled) and whose current
/// value is empty. Runs once per page initialization, the override then
/// persists like any user edit.
pub(super) fn prefill_tournament_player(
    storage: &GameStorage,
    mods: &mut [LoadedMod],
    config_changed: &mut bool,
) {
    let Some(name) = read_player_name(storage) else {
        return;
    };
    for m in mods {
        if !m.enabled || m.load_error.is_some() {
            continue;
        }
        let declares_visible_param = m
            .config
            .parameters
            .iter()
            .any(|p| p.id == TOURNAMENT_PLAYER_PARAM && !p.hidden);
        if !declares_visible_param {
            continue;
        }
        let empty = m
            .configuration
            .get(TOURNAMENT_PLAYER_PARAM)
            .and_then(Value::as_str)
            .unwrap_or("")
            .is_empty();
        if empty {
            m.configuration.insert(
                TOURNAMENT_PLAYER_PARAM.to_owned(),
                Value::String(name.clone()),
            );
            *config_changed = true;
        }
    }
}

/// Reads the player name from `<game_dir>/Saved_Data/Arcade_Player.txt`.
/// The game writes it quoted, strip surrounding quotes and whitespace.
/// This is the ONE-TIME prefill source for the mod page's visible
/// `tournament_player` parameter (the name travels inside every uploaded
/// .dat, so the value must match what the game writes). `None` when
/// unreadable/empty (the parameter just starts empty, the user types the
/// name; create/join refuse until it is valid).
pub(super) fn read_player_name(storage: &GameStorage) -> Option<String> {
    let path = storage
        .game_path()
        .join("Saved_Data")
        .join("Arcade_Player.txt");
    let raw = std::fs::read_to_string(&path).ok()?;
    let mut name = raw.trim();
    if name.len() >= 2 && name.starts_with('"') && name.ends_with('"') {
        name = name[1..name.len() - 1].trim();
    }
    if name.is_empty() {
        None
    } else {
        Some(name.to_owned())
    }
}

/// The logged-in identity a room action carries, cloned out of the
/// page state: [`RoomIdentity`] borrows its key, and the borrow cannot
/// travel into a `'static` task closure - the owned pair stays alive
/// INSIDE the closure and only lends itself to the call. `None` =
/// guest.
fn account_identity_for_task(account: Option<&AccountConfig>) -> Option<(i64, String)> {
    account.map(|account| (account.user_id, account.auth_key.clone()))
}

/// The borrowed wire view of one cloned identity pair (the pair lives
/// in the task closure, the identity only borrows it for the call).
fn borrowed_identity(pair: &(i64, String)) -> RoomIdentity<'_> {
    RoomIdentity {
        user_id: pair.0,
        auth_key: pair.1.as_str(),
    }
}

fn start_create_task(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    form: CreateRoomForm,
) {
    if state.action_task.is_some() {
        return; // double-submit guard
    }
    let identity = account_identity_for_task(state.account.as_ref());
    state.pending_selection = Some(PendingSelection {
        mod_dir: form.mod_dir,
        player: form.player.clone(),
    });
    let storage = storage.clone();
    state.action_task = Some(spawn_task(ctx.clone(), move |_tx| {
        let identity = identity.as_ref().map(borrowed_identity);
        storage
            .create_room(
                &form.env,
                &form.difficulty,
                &form.player,
                &form.name,
                form.starts_at,
                form.ends_at,
                identity,
            )
            .map(RoomTaskResult::Room)
            .map_err(|e| e.to_string())
    }));
}
/// The create-room form values, exactly as the popup collected them.
struct CreateRoomForm {
    mod_dir: String,
    env: String,
    difficulty: String,
    player: String,
    name: String,
    starts_at: i64,
    ends_at: i64,
}

/// The shared mutable state the tournament action helpers pass along:
/// everything a button render or click may touch, grouped so the
/// helpers stay under the argument-count limit and the call sites
/// read as one unit.
pub(super) struct RoomActions<'a> {
    pub(super) room_cache: &'a mut RoomCache,
    pub(super) open_popup: &'a mut Option<OpenPopup>,
    pub(super) popup_values: &'a mut HashMap<(String, String, String), PopupValue>,
    pub(super) list_task: &'a mut Option<TaskHandle<RoomTaskResult>>,
    pub(super) popup_serial: &'a mut u64,
    /// The logged-in account, read-only in the action row (the account
    /// popup and the poll pass own the changes to it).
    pub(super) account: &'a Option<AccountConfig>,
    /// The account avatar's load state, read-only here.
    pub(super) avatar: &'a super::account::AvatarState,
    /// The account popup, opened by the account chip.
    pub(super) login_popup: &'a mut Option<super::account::LoginPopup>,
}

/// A card in a room_list popup was selected → join it as the player the
/// `tournament_player` parameter carries ("selecting a card = join
/// action"). Missing or invalid parameter: refused here and highlighted
/// on the mod page.
fn handle_room_selected(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    open: &OpenPopup,
    room_id: &str,
) {
    let player = match player_for_action(state, &open.mod_dir) {
        Ok(player) => player,
        Err(reason) => {
            state.tournament_error = Some(reason);
            return;
        }
    };
    if state.action_task.is_some() {
        return; // double-submit guard
    }
    let identity = account_identity_for_task(state.account.as_ref());

    state.pending_selection = Some(PendingSelection {
        mod_dir: open.mod_dir.clone(),
        player: player.clone(),
    });
    let storage = storage.clone();
    let room_id = room_id.to_owned();
    state.action_task = Some(spawn_task(ctx.clone(), move |_tx| {
        let identity = identity.as_ref().map(borrowed_identity);
        storage
            .join_room(&room_id, &player, identity)
            .map(RoomTaskResult::Room)
            .map_err(|e| e.to_string())
    }));

    // The action started; the room list closes. On failure the error window
    // opens with the server's message.
    state.open_popup = None;
}

/// The `tournament_player` value of the mod owning the open popup (the
/// identity a join or ownership check runs as). `None` when unset.
pub(super) fn tournament_player_of(state: &ModsPageState, mod_dir: &str) -> Option<String> {
    state
        .mods
        .iter()
        .find(|m| m.dir_name == mod_dir)
        .and_then(|m| m.configuration.get(TOURNAMENT_PLAYER_PARAM))
        .and_then(Value::as_str)
        .map(str::to_owned)
}

/// Whether the player (or their logged-in account) created this room: the
/// host name matches the tournament player (the guest identity), or the
/// room carries the account's user id as its owner. Pure so the removal
/// gating can be unit tested.
fn room_owned_by(room: &RoomSummaryDto, player: &str, account_user_id: Option<i64>) -> bool {
    room.host == player || account_user_id.is_some_and(|uid| room.owner_user_id == Some(uid))
}

/// Whether the room list should offer a Remove button for this room: the
/// player's own, not started yet, and joined by nobody else (the server
/// enforces the same guards under its room lock, this gate only decides
/// whether the affordance exists).
fn room_can_be_removed(
    room: &RoomSummaryDto,
    player: &str,
    account_user_id: Option<i64>,
    now: i64,
) -> bool {
    room.is_removable(now) && room_owned_by(room, player, account_user_id)
}

/// The remove confirmation's Remove button was pressed: start the
/// `room_remove` request on the action slot (the same one-at-a-time slot
/// create/join use, so a removal can never race a join).
fn start_remove_task(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    remove: &RemoveConfirm,
) {
    let player = match player_for_action(state, &remove.mod_dir) {
        Ok(player) => player,
        Err(reason) => {
            state.tournament_error = Some(reason);
            return;
        }
    };
    if state.action_task.is_some() {
        return; // double-submit guard
    }
    let identity = account_identity_for_task(state.account.as_ref());
    let storage = storage.clone();
    let room_id = remove.room_id.clone();
    state.action_task = Some(spawn_task(ctx.clone(), move |_tx| {
        let identity = identity.as_ref().map(borrowed_identity);
        storage
            .remove_room(&room_id, &player, identity)
            .map(|_| RoomTaskResult::Removed(room_id.clone()))
            .map_err(|e| e.to_string())
    }));
}

/// Called on the UI thread once a room removal succeeded: refreshes the
/// room list (the popup cache and the game's offline menu list both
/// re-derive from it), and when the removed room was the SELECTED one,
/// clears the selection overrides and removes the mod's local managed
/// copies, mirroring the cleanup a room switch performs (the files are
/// the removed room's content and would serve stale ghosts).
///
/// Returns whether `mods.json` changed (→ refresh the hook resolver).
fn handle_room_removed(
    ctx: &egui::Context,
    storage: &GameStorage,
    state: &mut ModsPageState,
    room_id: &str,
) -> bool {
    start_list_task(ctx, storage, &mut state.room_cache, &mut state.list_task);

    let selected: Vec<usize> = state
        .mods
        .iter()
        .enumerate()
        .filter(|(_, m)| {
            m.configuration
                .get(TOURNAMENT_ROOM_ID_PARAM)
                .and_then(Value::as_str)
                == Some(room_id)
        })
        .map(|(index, _)| index)
        .collect();
    let mut config_changed = false;
    for index in selected {
        let m = &mut state.mods[index];
        wipe_stale_managed_files(storage, m);
        config_changed |= clear_room_selection(&mut m.configuration);
    }
    if !config_changed {
        return false;
    }
    if let Err(e) = mods_tasks::persist_mod_configurations(storage, &state.mods) {
        let message = format!("Failed to persist tournament configuration: {e}");
        eprintln!("Tournament: {message}");
        state.tournament_error = Some(message);
        return false;
    }
    true
}

/// Drops the selected-room overrides from one mod's configuration: every
/// key [`persist_selection`] writes EXCEPT the player's own name (that one
/// is the user's visible control, it survives room switches). An empty
/// `tournament_room_id` afterwards means "no selection", exactly the
/// shipped default. Returns whether anything changed.
fn clear_room_selection(configuration: &mut HashMap<String, Value>) -> bool {
    const SELECTION_KEYS: [&str; 6] = [
        TOURNAMENT_ENV_PARAM,
        TOURNAMENT_DIFFICULTY_PARAM,
        TOURNAMENT_ROOM_ID_PARAM,
        TOURNAMENT_ROOM_NAME_CFG,
        TOURNAMENT_STARTS_AT_CFG,
        TOURNAMENT_ENDS_AT_CFG,
    ];
    let mut changed = false;
    for key in SELECTION_KEYS {
        changed |= configuration.remove(key).is_some();
    }
    changed
}

/// Called on the UI thread once a create/join task succeeded: writes the
/// selection into the mod's active configuration, the room/player values
/// the rules interpolate (`env`, `difficulty`, `room_id`, `player`; the
/// server URL stays the mod's own default) plus the display and
/// gating values (`room_name`, `starts_at`, `ends_at`), then persists
/// `mods.json` the same way a parameter edit does. The selection lives
/// only in the mod's active configuration, and the hook resolver already
/// merges exactly these values on Play.
///
/// Returns whether `mods.json` changed (→ refresh the hook resolver).
fn persist_selection(storage: &GameStorage, state: &mut ModsPageState, room: &RoomDto) -> bool {
    let Some(pending) = state.pending_selection.clone() else {
        eprintln!("Tournament: room result arrived without a pending selection; ignoring");
        return false;
    };

    if let Some(m) = state
        .mods
        .iter_mut()
        .find(|m| m.dir_name == pending.mod_dir)
    {
        // selecting a DIFFERENT room wipes the mod's locally saved
        // remote-backed files first (the five replay slots and the
        // high-times table). They are the old room's content and would
        // serve stale ghosts and stale rows until the daemon's first
        // refresh of the new room landed; the .dat files the game finds
        // on disk must belong to the room being entered. Re-joining the
        // SAME room keeps everything (that is a refresh, not a switch).
        let room_changed = m
            .configuration
            .get(TOURNAMENT_ROOM_ID_PARAM)
            .and_then(Value::as_str)
            .is_none_or(|previous| previous != room.id.as_str());
        if room_changed {
            wipe_stale_managed_files(storage, m);
        }

        // The interpolated values (contract E; the rules' enable_if and
        // remote URLs read exactly these keys).
        m.configuration.insert(
            TOURNAMENT_ENV_PARAM.to_owned(),
            Value::String(room.env.clone()),
        );
        m.configuration.insert(
            TOURNAMENT_DIFFICULTY_PARAM.to_owned(),
            Value::String(room.difficulty.clone()),
        );
        m.configuration.insert(
            TOURNAMENT_ROOM_ID_PARAM.to_owned(),
            Value::String(room.id.as_str().to_owned()),
        );
        m.configuration.insert(
            TOURNAMENT_PLAYER_PARAM.to_owned(),
            Value::String(pending.player.clone()),
        );
        // The display + gating values : the room NAME (so the UI
        // never has to show the id) and the planning window (so Play can
        // be disabled for scheduled/expired rooms).
        m.configuration.insert(
            TOURNAMENT_ROOM_NAME_CFG.to_owned(),
            Value::String(room.name.clone()),
        );
        m.configuration.insert(
            TOURNAMENT_STARTS_AT_CFG.to_owned(),
            Value::Number(room.starts_at.into()),
        );
        m.configuration.insert(
            TOURNAMENT_ENDS_AT_CFG.to_owned(),
            Value::Number(room.ends_at.into()),
        );
    } else {
        eprintln!(
            "Tournament: mod '{}' vanished before its configuration could be updated",
            pending.mod_dir
        );
    }

    if let Err(e) = mods_tasks::persist_mod_configurations(storage, &state.mods) {
        let message = format!("Failed to persist tournament configuration: {e}");
        eprintln!("Tournament: {message}");
        state.tournament_error = Some(message);
        return false;
    }
    true
}

/// Persists the launcher-computed room list into every enabled mod that
/// declares the `TheListOfRooms` parameter (the offline main-menu patch
/// interpolates it while the play-online toggle is off). `rooms` arrive
/// already sorted by expiration proximity (the server's `room_list`
/// order). Returns whether `mods.json` changed.
fn persist_room_list(
    storage: &GameStorage,
    state: &mut ModsPageState,
    rooms: &[RoomSummaryDto],
) -> bool {
    let list = room_list_text(rooms);
    let mut changed = false;
    for m in state.mods.iter_mut() {
        if !m.enabled
            || m.load_error.is_some()
            || !m
                .config
                .parameters
                .iter()
                .any(|p| p.id == TOURNAMENT_ROOMS_CFG)
        {
            continue;
        }
        if m.configuration
            .get(TOURNAMENT_ROOMS_CFG)
            .and_then(Value::as_str)
            != Some(list.as_str())
        {
            m.configuration.insert(
                TOURNAMENT_ROOMS_CFG.to_owned(),
                Value::String(list.clone()),
            );
            changed = true;
        }
    }
    if !changed {
        return false;
    }
    if let Err(e) = mods_tasks::persist_mod_configurations(storage, &state.mods) {
        eprintln!("Tournament: failed to persist the room list: {e}");
        return false;
    }
    true
}

/// The offline room-list text: `"Name (records)", ...` comma-separated,
/// the game's Menu_Strings room list renders it verbatim.
fn room_list_text(rooms: &[RoomSummaryDto]) -> String {
    rooms
        .iter()
        .map(|room| format!("{} ({})", room.name, room.record_count))
        .collect::<Vec<_>>()
        .join(", ")
}

/// Deletes every managed-file local copy the mod declares (for the online
/// tournament: the five replay slots and the high-times table). Called
/// when the selected room changes so no file of the previous room can be
/// served from disk. Missing files are fine; other failures are logged
/// and left for the daemon's next copy-if-different refresh to reconcile.
fn wipe_stale_managed_files(storage: &GameStorage, m: &LoadedMod) {
    let config = HookConfig {
        rules: m.config.rules.clone(),
    };
    let mut wiped = 0;
    for spec in managed_file_specs(storage.game_path(), &config) {
        match std::fs::remove_file(&spec.local) {
            Ok(()) => {
                wiped += 1;
                eprintln!(
                    "Tournament: room switch; removed stale local copy {}",
                    spec.local.display()
                );
            }
            Err(e) if e.kind() == ErrorKind::NotFound => {}
            Err(e) => eprintln!(
                "Tournament: room switch; could not remove stale local copy {}: {e}",
                spec.local.display()
            ),
        }
    }
    if wiped > 0 {
        eprintln!(
            "Tournament: room switch; {wiped} stale managed file(s) removed; \
             the new room's content is fetched on the next game launch"
        );
    }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Maps a `ui` form field id to the mod parameter id whose override carries
/// the same value (contract E). `None` = not persisted as an override.
fn tournament_param_override_key(field_id: &str) -> Option<&'static str> {
    match field_id {
        "env" => Some(TOURNAMENT_ENV_PARAM),
        "difficulty" => Some(TOURNAMENT_DIFFICULTY_PARAM),
        _ => None,
    }
}

// ---------------------------------------------------------------------------
// Play button label
// ---------------------------------------------------------------------------

/// The Play button becomes **"Online"** when an enabled mod with
/// tournament `ui` actions has a selection in its active configuration
/// (there is no extra selection file).
/// Returns that selection (for the footer tooltip), or `None` for a normal
/// `Play!`.
///
/// When the Mods page hasn't been opened this session (`mods` is empty) the
/// check falls back to disk: the enabled list + per-mod overrides from
/// `mods.json`, the same values the hook resolver interpolates on Play.
pub fn tournament_play_selection(
    storage: &GameStorage,
    mods_state: &ModsPageState,
) -> Option<TournamentSelection> {
    if mods_state.mods.is_empty() {
        let active = load_mods_state(&mods_tasks::mods_dir(storage))
            .map(|state| state.active)
            .unwrap_or_default();
        for dir in &active.enabled {
            if let Some(selection) = active
                .configuration
                .get(dir)
                .filter(|cfg| is_online(cfg))
                .and_then(TournamentSelection::from_configuration)
            {
                return Some(selection);
            }
        }
        return None;
    }

    for m in &mods_state.mods {
        if !m.enabled || m.load_error.is_some() {
            continue; // a broken mod's rules can't be applied, never claim Online
        }
        let has_tournament_actions = m.config.ui.as_ref().is_some_and(|ui_schema: &ModUi| {
            ui_schema
                .buttons
                .iter()
                .any(|b| is_tournament_action(&b.action))
        });
        if !has_tournament_actions || !is_online(&m.configuration) {
            continue; // the toggle is off: the game stays offline, never claim Online
        }
        if let Some(selection) = TournamentSelection::from_configuration(&m.configuration) {
            return Some(selection);
        }
    }
    None
}

// ---------------------------------------------------------------------------
// High-times population (owned by the DLL)
// ---------------------------------------------------------------------------

// The game reads `Saved_Data/<env>_<diff>_high_times.txt` once at startup
// and builds its high-score list, and the ghosts it wants to race
// against, from those entries, pairing entry rank N with the replay in
// `Replay_N.dat`.
//
// The LAUNCHER performs no downloads at all on the launch path: the
// hooking DLL owns the file at runtime. The mod's managed-file rule
// fetches the server-rendered text when the game opens the file (a
// bounded wait on first contact, then always serve-from-disk while the
// background cadence refreshes it), and a missing copy degrades to the
// vanilla file. The launch path only writes configs and starts the game.

#[cfg(test)]
mod tests {
    use super::super::types::{LoadedMod, ModsPageState};
    use super::{
        TOURNAMENT_PLAYER_PARAM, clear_room_selection, confirm_blockers, player_for_action,
        prefill_tournament_player, read_player_name, room_can_be_removed, room_owned_by,
        rough_countdown, tournament_player_of,
    };
    use supreme_fs::GameStorage;
    use supreme_fs::RoomSummaryDto;
    use supreme_hook_config::{
        ModConfig, ModParameter, PLAYER_NAME_TAG, ParameterKind, ROOM_NAME_TAG, UiField,
        UiFieldKind, UiPopup, UiPopupKind,
    };
    use tempfile::tempdir;

    const MIN: i64 = 60;
    const HOUR: i64 = 60 * MIN;
    const DAY: i64 = 24 * HOUR;

    /// A text field for the blocker tests, carrying an optional
    /// validation tag.
    fn text_field(id: &str, label: &str, tag: Option<&str>) -> UiField {
        UiField {
            id: id.to_owned(),
            kind: UiFieldKind::Text,
            label: label.to_owned(),
            options: Vec::new(),
            hint: None,
            validation: tag.map(str::to_owned),
        }
    }

    fn form_popup(fields: Vec<UiField>) -> UiPopup {
        UiPopup {
            title: "Create Tournament Room".to_owned(),
            kind: UiPopupKind::Form,
            fields,
        }
    }

    /// A page state with one enabled, loadable mod whose
    /// `tournament_player` override is `value` (None = unset).
    fn state_with_player(value: Option<&str>) -> ModsPageState {
        let mut configuration = std::collections::HashMap::new();
        if let Some(value) = value {
            configuration.insert(
                TOURNAMENT_PLAYER_PARAM.to_owned(),
                serde_json::Value::String(value.to_owned()),
            );
        }
        let mut state = ModsPageState::default();
        state.mods.push(LoadedMod {
            dir_name: "online-tournament".to_owned(),
            config: ModConfig::default(),
            configuration,
            enabled: true,
            load_error: None,
            warnings: Vec::new(),
        });
        state
    }

    /// A mod declaring `tournament_player` with the given visibility and
    /// current override, the shape `prefill_tournament_player` filters on.
    fn mod_declaring_player(visible: bool, current: Option<&str>) -> LoadedMod {
        let mut configuration = std::collections::HashMap::new();
        if let Some(current) = current {
            configuration.insert(
                TOURNAMENT_PLAYER_PARAM.to_owned(),
                serde_json::Value::String(current.to_owned()),
            );
        }
        LoadedMod {
            dir_name: "online-tournament".to_owned(),
            config: ModConfig {
                parameters: vec![ModParameter {
                    id: TOURNAMENT_PLAYER_PARAM.to_owned(),
                    name: "Tournament player name".to_owned(),
                    help_text: String::new(),
                    kind: ParameterKind::Text,
                    enable_if: None,
                    hidden: !visible,
                    validation: Some(PLAYER_NAME_TAG.to_owned()),
                }],
                ..ModConfig::default()
            },
            configuration,
            enabled: true,
            load_error: None,
            warnings: Vec::new(),
        }
    }

    /// A game dir whose `Saved_Data/Arcade_Player.txt` holds the exact
    /// bytes the game writes. The TempDir guard travels with the
    /// storage: `GameStorage` keeps only the path, the directory dies
    /// with the guard.
    fn storage_with_player_file(raw: &str) -> (GameStorage, tempfile::TempDir) {
        let dir = tempdir().expect("game dir");
        let saved_data = dir.path().join("Saved_Data");
        std::fs::create_dir_all(&saved_data).expect("Saved_Data");
        std::fs::write(saved_data.join("Arcade_Player.txt"), raw).expect("player file");
        (GameStorage::new(dir.path()), dir)
    }

    /// A room-list entry with the given shape, for the removal-gating
    /// tests.
    fn summary_room(host: &str, starts_at: i64, player_count: i64) -> RoomSummaryDto {
        RoomSummaryDto {
            id: "r_test00000000".to_owned(),
            name: "Fresh Powder".to_owned(),
            env: "alpine".to_owned(),
            difficulty: "easy".to_owned(),
            host: host.to_owned(),
            starts_at,
            ends_at: starts_at + DAY,
            player_count,
            record_count: 0,
            results_url: None,
            owner_user_id: None,
        }
    }

    #[test]
    fn remove_button_shows_only_on_own_unstarted_unjoined_rooms() {
        let now = 1_000_000;
        let starts_at = now + HOUR;

        // Own, un-started, alone: the one shape that may be removed.
        let own = summary_room("Xinfe", starts_at, 1);
        assert!(room_can_be_removed(&own, "Xinfe", None, now));

        // Somebody else's room: never, regardless of shape.
        let other = summary_room("GhostRdr", starts_at, 1);
        assert!(!room_can_be_removed(&other, "Xinfe", None, now));
        // Own but started, or someone joined: not removable.
        let started = summary_room("Xinfe", now - MIN, 1);
        assert!(!room_can_be_removed(&started, "Xinfe", None, now));
        let joined = summary_room("Xinfe", starts_at, 2);
        assert!(!room_can_be_removed(&joined, "Xinfe", None, now));

        // A logged-in account also owns rooms carrying its user id,
        // even under a different host name.
        let mut owned = summary_room("someoneelse", starts_at, 1);
        owned.owner_user_id = Some(7);
        assert!(!room_owned_by(&owned, "Xinfe", None), "guest cannot remove it");
        assert!(room_owned_by(&owned, "Xinfe", Some(7)));
        assert!(room_can_be_removed(&owned, "Xinfe", Some(7), now));
        // A DIFFERENT account's room is not ours.
        assert!(!room_can_be_removed(&owned, "Xinfe", Some(8), now));
    }

    #[test]
    fn clearing_a_removed_selection_drops_the_room_keys_keeps_the_player() {
        let mut configuration = std::collections::HashMap::new();
        configuration.insert(
            "tournament_env".to_owned(),
            serde_json::json!("village"),
        );
        configuration.insert(
            "tournament_difficulty".to_owned(),
            serde_json::json!("hard"),
        );
        configuration.insert(
            "tournament_room_id".to_owned(),
            serde_json::json!("r_gone0000000000"),
        );
        configuration.insert(
            "tournament_room_name".to_owned(),
            serde_json::json!("Fresh Powder"),
        );
        configuration.insert(
            "tournament_starts_at".to_owned(),
            serde_json::json!(1_760_000_000),
        );
        configuration.insert(
            "tournament_ends_at".to_owned(),
            serde_json::json!(1_760_086_400),
        );
        configuration.insert(
            TOURNAMENT_PLAYER_PARAM.to_owned(),
            serde_json::json!("Xinfe"),
        );
        assert!(clear_room_selection(&mut configuration));
        // The player's own name survives; every room key is gone, the
        // absent room id reads as "no selection".
        assert_eq!(
            configuration.get(TOURNAMENT_PLAYER_PARAM),
            Some(&serde_json::json!("Xinfe"))
        );
        assert!(
            !configuration.contains_key("tournament_room_id")
                && !configuration.contains_key("tournament_room_name")
                && !configuration.contains_key("tournament_env")
                && !configuration.contains_key("tournament_difficulty")
                && !configuration.contains_key("tournament_starts_at")
                && !configuration.contains_key("tournament_ends_at"),
            "every selected-room override is dropped: {configuration:?}"
        );
        // Clearing again changes nothing (the room was already gone).
        assert!(!clear_room_selection(&mut configuration));
    }

    #[test]
    fn tournament_player_of_reads_the_owning_mods_value() {
        let state = state_with_player(Some("Xinfe"));
        assert_eq!(
            tournament_player_of(&state, "online-tournament").as_deref(),
            Some("Xinfe")
        );
        assert_eq!(
            tournament_player_of(&state, "unknown-mod"),
            None,
            "an uninstalled mod dir reads as no player"
        );
    }

    #[test]
    fn confirm_blockers_pass_clean_and_untagged_forms() {
        // A fresh create form: no validation tags, no values yet.
        let popup = form_popup(vec![
            text_field("name", "Room name", None),
            text_field("env", "Environment", None),
        ]);
        assert!(confirm_blockers(&popup, |_| None).is_empty());
        // A tagged room name that is EMPTY is confirmable: the server
        // autogenerates a name, only the charset is refused.
        let popup = form_popup(vec![text_field("name", "Room name", Some(ROOM_NAME_TAG))]);
        let empty = |_: &str| None::<String>;
        assert!(confirm_blockers(&popup, empty).is_empty());
    }

    #[test]
    fn confirm_blockers_surface_each_fields_reason_under_its_label() {
        let popup = form_popup(vec![
            text_field("name", "Room name", Some(ROOM_NAME_TAG)),
            text_field("player", "Player name", Some(PLAYER_NAME_TAG)),
        ]);
        let values = |id: &str| match id {
            "name" => Some("粉末".to_owned()),
            "player" => Some("player1".to_owned()),
            _ => None,
        };
        let blockers = confirm_blockers(&popup, values);
        assert_eq!(blockers.len(), 2, "one reason per invalid field");
        assert!(
            blockers[0].starts_with("Room name: "),
            "the reason names its field: {blockers:?}"
        );
        assert!(
            blockers[1].starts_with("Player name: "),
            "the reason names its field: {blockers:?}"
        );
        // A missing player value is refused (the identity is required),
        // a valid room name is not.
        let popup = form_popup(vec![
            text_field("name", "Room name", Some(ROOM_NAME_TAG)),
            text_field("player", "Player name", Some(PLAYER_NAME_TAG)),
        ]);
        let blockers = confirm_blockers(&popup, |id| {
            (id == "name").then(|| "Fresh Powder".to_owned())
        });
        assert_eq!(blockers.len(), 1);
        assert!(
            blockers[0].starts_with("Player name: "),
            "the missing identity is the only blocker: {blockers:?}"
        );
    }

    #[test]
    fn confirm_blockers_require_the_window_to_end_after_it_starts() {
        let popup = form_popup(vec![
            text_field("starts_at", "Starts", None),
            text_field("ends_at", "Ends", None),
        ]);
        let equal = |_: &str| Some("1000".to_owned());
        assert_eq!(
            confirm_blockers(&popup, equal),
            vec!["The room must END after it STARTS. Adjust the date/time pickers.".to_owned()],
            "an equal window is a zero-length room, refused"
        );
        let ordered = |id: &str| {
            Some(
                (id == "ends_at")
                    .then(|| "1001".to_owned())
                    .unwrap_or_default(),
            )
        };
        assert!(
            confirm_blockers(&popup, ordered).is_empty(),
            "ends after starts is the valid window"
        );
        // Unparseable/absent values never block: the popup-open path
        // seeds real now/tomorrow defaults, an absent value means the
        // form predates the pickers, not that the window is invalid.
        assert!(
            confirm_blockers(&popup, |id| {
                (id == "starts_at").then(|| "not a number".to_owned())
            })
            .is_empty()
        );
    }

    #[test]
    fn player_for_action_accepts_a_valid_name_and_clears_a_stale_highlight() {
        let mut state = state_with_player(Some("Xinfe"));
        state.tournament_param_error = Some((
            "online-tournament".to_owned(),
            TOURNAMENT_PLAYER_PARAM.to_owned(),
        ));
        assert_eq!(
            player_for_action(&mut state, "online-tournament"),
            Ok("Xinfe".to_owned())
        );
        assert!(
            state.tournament_param_error.is_none(),
            "a valid value clears the highlight a previous refusal set"
        );
    }

    #[test]
    fn player_for_action_refuses_and_highlights_missing_or_invalid_names() {
        let mut state = state_with_player(None);
        let reason = player_for_action(&mut state, "online-tournament").unwrap_err();
        assert_eq!(
            state.tournament_param_error,
            Some((
                "online-tournament".to_owned(),
                TOURNAMENT_PLAYER_PARAM.to_owned()
            )),
            "the refusal points at the mod page's parameter"
        );
        assert!(reason.contains("player name"), "{reason}");

        let mut state = state_with_player(Some("player1"));
        assert!(player_for_action(&mut state, "online-tournament").is_err());
        assert_eq!(
            state.tournament_param_error,
            Some((
                "online-tournament".to_owned(),
                TOURNAMENT_PLAYER_PARAM.to_owned()
            )),
            "non-letters are refused the same way"
        );

        // An unknown mod dir (uninstalled mid-flow) never panics, it
        // reads as an unset value and refuses with guidance.
        let mut state = state_with_player(Some("Xinfe"));
        assert!(player_for_action(&mut state, "gone-mod").is_err());
    }

    #[test]
    fn read_player_name_strips_the_games_quoting() {
        let (storage, _dir) = storage_with_player_file("\"Xinfe\"\r\n");
        assert_eq!(read_player_name(&storage).as_deref(), Some("Xinfe"));
        // Unquoted (hand-edited) files read the same.
        let (storage, _dir) = storage_with_player_file("  Xinfe  ");
        assert_eq!(read_player_name(&storage).as_deref(), Some("Xinfe"));
        // Missing file, empty and quote-only values read as absent.
        let dir = tempdir().expect("game dir");
        let storage = GameStorage::new(dir.path());
        assert_eq!(read_player_name(&storage), None);
        let (storage, _dir) = storage_with_player_file("\"\"");
        assert_eq!(read_player_name(&storage), None);
    }

    #[test]
    fn prefill_tournament_player_fills_only_empty_visible_parameters() {
        let (storage, _dir) = storage_with_player_file("\"Xinfe\"\r\n");

        // Visible + empty: prefilled, exactly once, flagged for persist.
        let mut mods = vec![mod_declaring_player(true, None)];
        let mut changed = false;
        prefill_tournament_player(&storage, &mut mods, &mut changed);
        assert_eq!(changed, true);
        assert_eq!(
            mods[0].configuration.get(TOURNAMENT_PLAYER_PARAM),
            Some(&serde_json::json!("Xinfe"))
        );

        // Already set (a user edit or a previous run): untouched.
        let mut mods = vec![mod_declaring_player(true, Some("GhostRdr"))];
        let mut changed = false;
        prefill_tournament_player(&storage, &mut mods, &mut changed);
        assert_eq!(changed, false);
        assert_eq!(
            mods[0].configuration.get(TOURNAMENT_PLAYER_PARAM),
            Some(&serde_json::json!("GhostRdr"))
        );

        // Hidden launcher-set parameter: never prefilled.
        let mut mods = vec![mod_declaring_player(false, None)];
        let mut changed = false;
        prefill_tournament_player(&storage, &mut mods, &mut changed);
        assert_eq!(changed, false);
        assert!(!mods[0].configuration.contains_key(TOURNAMENT_PLAYER_PARAM));

        // Disabled mod: untouched regardless of its shape.
        let mut mods = vec![mod_declaring_player(true, None)];
        mods[0].enabled = false;
        let mut changed = false;
        prefill_tournament_player(&storage, &mut mods, &mut changed);
        assert_eq!(changed, false);
        assert!(!mods[0].configuration.contains_key(TOURNAMENT_PLAYER_PARAM));
    }

    #[test]
    fn prefill_tournament_player_without_a_player_file_changes_nothing() {
        let dir = tempdir().expect("game dir");
        let storage = GameStorage::new(dir.path());
        let mut mods = vec![mod_declaring_player(true, None)];
        let mut changed = false;
        prefill_tournament_player(&storage, &mut mods, &mut changed);
        assert_eq!(changed, false);
        assert!(!mods[0].configuration.contains_key(TOURNAMENT_PLAYER_PARAM));
    }

    #[test]
    fn countdown_uses_the_biggest_denomination_only() {
        assert_eq!(rough_countdown(5 * 7 * DAY), "5 weeks");
        assert_eq!(rough_countdown(13 * MIN), "13 minutes");
        // Single-value ladders.
        assert_eq!(rough_countdown(75 * DAY), "2 months");
        assert_eq!(rough_countdown(45 * DAY), "6 weeks");
        assert_eq!(rough_countdown(13 * DAY), "13 days");
        assert_eq!(rough_countdown(2 * DAY), "2 days");
        assert_eq!(rough_countdown(5 * HOUR + 12 * MIN), "5 hours");
        assert_eq!(rough_countdown(2 * HOUR), "2 hours");
        assert_eq!(rough_countdown(59 * MIN), "59 minutes");
        // Sub-minute rounds up; zero clamps.
        assert_eq!(rough_countdown(30), "1 minute");
        assert_eq!(rough_countdown(0), "1 minute");
        // Negative (clock skew) never panics.
        assert_eq!(rough_countdown(-5), "1 minute");
    }

    #[test]
    fn countdown_pluralizes() {
        // Rungs start at two units, so the singular forms below the minute
        // rung never appear: exactly one day renders as "24 hours", one
        // week as "7 days".
        assert_eq!(rough_countdown(MIN), "1 minute");
        assert_eq!(rough_countdown(2 * MIN), "2 minutes");
        assert_eq!(rough_countdown(DAY), "24 hours");
        assert_eq!(rough_countdown(3 * DAY), "3 days");
        assert_eq!(rough_countdown(7 * DAY), "7 days");
        // 30 days is under the two-month rung → weeks.
        assert_eq!(rough_countdown(30 * DAY), "4 weeks");
        assert_eq!(rough_countdown(60 * DAY), "2 months");
    }
}