launcher/pages/riders/

mod.rs

use crate::utils::texture_loader::load_texture_robust;
use crate::widgets::gallery::{GalleryConfig, GalleryState, gallery_grid};
use crate::widgets::tile::gallery_tile;
use eframe::egui;
use std::collections::HashMap;
use supreme_characters::{
    CharacterMaterial, get_character_texture_path, get_ghost_character, get_grouped_characters,
    identify_active_skin, set_character_skin, set_ghost_character,
};

#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
pub struct RidersPageState {
    pub gallery: GalleryState,
    pub selected_material: CharacterMaterial,
    pub selected_skins: HashMap<String, String>, // Base Name -> Skin Name
    pub ghost_character: Option<String>,
}

impl Default for RidersPageState {
    fn default() -> Self {
        Self {
            gallery: GalleryState::default(),
            selected_material: CharacterMaterial::Face,
            selected_skins: HashMap::new(),
            ghost_character: None,
        }
    }
}

#[allow(clippy::too_many_lines)]
pub fn riders_page(
    ui: &mut egui::Ui,
    storage: &supreme_fs::GameStorage,
    state: &mut RidersPageState,
) {
    let game_path = storage.game_path();
    let characters_dir = game_path.join("Data/Characters");

    if !characters_dir.exists() {
        ui.colored_label(egui::Color32::RED, "Characters directory not found!");
        return;
    }

    let characters = get_grouped_characters(&characters_dir);
    let current_material = state.selected_material;

    if state.ghost_character.is_none() {
        state.ghost_character = get_ghost_character(&characters_dir);
    }

    if let Some(ghost) = state.ghost_character.as_ref() {
        // Ensure the case matches the disk directory (pretty name)
        let pretty_name = characters
            .iter()
            .find(|c| c.name.to_lowercase() == ghost.to_lowercase())
            .map(|c| c.name.clone());

        if let Some(pretty) = pretty_name
            && &pretty != ghost
        {
            state.ghost_character = Some(pretty);
        }
    }

    gallery_grid(
        ui,
        GalleryConfig {
            id: "riders_grid",
            title: "Riders",
            info_text: Some(
                "To create a new skin: duplicate an original 'bulk' character folder corresponding to the one you want, then edit the texture files. Ensure the .txt files inside are edited to match the new directory name you created.",
            ),
            open_folder_path: Some(&characters_dir),
        },
        &mut state.gallery,
        &characters,
        |ui| {
            egui::ComboBox::from_id_salt("char_material_select")
                .selected_text(state.selected_material.to_string())
                .show_ui(ui, |ui| {
                    for mat in CharacterMaterial::all() {
                        ui.selectable_value(&mut state.selected_material, mat, mat.to_string());
                    }
                });
            ui.label("Texture:");

            ui.add_space(8.0);

            let mut selected_ghost = state.ghost_character.clone().unwrap_or_default();
            let mut ghost_changed = false;

            egui::ComboBox::from_id_salt("ghost_select")
                .selected_text(&selected_ghost)
                .show_ui(ui, |ui| {
                    for base_char in &characters {
                        if ui
                            .selectable_value(
                                &mut selected_ghost,
                                base_char.name.clone(),
                                &base_char.name,
                            )
                            .changed()
                        {
                            ghost_changed = true;
                        }
                    }
                });

            if ghost_changed {
                if let Err(e) = set_ghost_character(&characters_dir, &selected_ghost) {
                    eprintln!("[Riders] Failed to set ghost character to '{selected_ghost}': {e}");
                } else {
                    state.ghost_character = Some(selected_ghost);
                }
            }
            ui.label("Ghost:");
        },
        |ui, base_char, tile_size, gallery_state| {
            let base_name = &base_char.name;

            // Get selected skin for this base character
            let selected_skin_name = state
                .selected_skins
                .entry(base_name.clone())
                .or_insert_with(|| identify_active_skin(&base_char.base_dir, &base_char.skins));

            let selected_skin = base_char
                .skins
                .iter()
                .find(|s| &s.name == selected_skin_name)
                .unwrap_or(&base_char.skins[0]);

            // Resolve texture based on selected skin
            // TODO: Investigate the use better typing to avoid string-based lookup.
            let texture_key = format!(
                "char_{}_{}_{}",
                base_name,
                selected_skin.name,
                current_material.to_string().to_lowercase()
            );

            if !gallery_state.textures.contains_key(&texture_key)
                && let Some(texture_path) =
                    get_character_texture_path(&selected_skin.dir, current_material)
            {
                let full_texture_path = game_path.join(&texture_path);
                if let Ok(texture) = load_texture_robust(ui.ctx(), &full_texture_path, &texture_key)
                {
                    gallery_state.textures.insert(texture_key.clone(), texture);
                }
            }

            gallery_tile(
                ui,
                tile_size,
                1.0,
                base_name,
                |ui| {
                    if base_char.skins.len() > 1 || selected_skin_name == "(Custom)" {
                        egui::ComboBox::from_id_salt(format!("skin_select_{base_name}"))
                            .selected_text(if selected_skin_name == "(Custom)" {
                                egui::RichText::new("(Custom)").italics()
                            } else {
                                egui::RichText::new(selected_skin_name.clone())
                            })
                            .width(80.0)
                            .show_ui(ui, |ui| {
                                if selected_skin_name == "(Custom)" {
                                    ui.selectable_value(
                                        selected_skin_name,
                                        "(Custom)".to_string(),
                                        egui::RichText::new("(Custom)").italics(),
                                    );
                                }
                                for skin in &base_char.skins {
                                    if ui
                                        .selectable_value(
                                            selected_skin_name,
                                            skin.name.clone(),
                                            &skin.name,
                                        )
                                        .changed()
                                        && let Err(e) =
                                            set_character_skin(&base_char.base_dir, &skin.dir)
                                    {
                                        eprintln!("Failed to set character skin: {e}");
                                    }
                                }
                            });
                    }
                },
                gallery_state.textures.get(&texture_key),
            );
        },
    );
}