launcher/pages/troubleshoot/

ui.rs

use std::collections::BTreeMap;

use crate::pages::troubleshoot::tasks::{
    LocalProfileInfo, SnapshotRequest, start_create_snapshot, start_refresh_profiles,
    start_restore_snapshot, start_upload_snapshot,
};

use crate::pages::troubleshoot::types::TroubleshootPageState;
use eframe::egui;
use supreme_fs::GameStorage;

#[cfg(feature = "local")]
use crate::pages::troubleshoot::tasks::{run_cleaner_task, start_path_scan};

#[allow(clippy::too_many_lines)]
pub fn troubleshoot_page(
    ui: &mut egui::Ui,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
) {
    state.update(storage);

    let has_token = std::env::var("SSBZ_API_TOKEN").is_ok();

    // Snapshot Management Section

    ui.horizontal(|ui| {
        ui.heading("Snapshots");
        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
            if ui
                .add_enabled(
                    !state.is_running && !state.profile_refresh_active,
                    egui::Button::new("🔄 Refresh List"),
                )
                .clicked()
            {
                state.has_attempted_profile_refresh = true;
                start_refresh_profiles(ui.ctx().clone(), state, storage);
            }

            if state.profile_refresh_active {
                ui.add(egui::Spinner::new());
            }

            // Auto-refresh if empty (and not running or refreshing)
            if state.available_profiles.is_empty()
                && !state.is_running
                && !state.profile_refresh_active
                && !state.has_attempted_profile_refresh
            {
                state.has_attempted_profile_refresh = true;
                start_refresh_profiles(ui.ctx().clone(), state, storage);
            }
        });
    });

    ui.label("Manage game file snapshots to easily restore or debug configurations.");
    ui.add_space(10.0);

    let box_height = 140.0;

    ui.columns(2, |cols| {
        // --- Left Column: List ---
        cols[0].vertical(|ui| {
            ui.label(egui::RichText::new("Available Snapshots:").strong());
            ui.add_space(2.0);
            egui::Frame::group(ui.style())
                .fill(ui.visuals().extreme_bg_color)
                .show(ui, |ui| {
                    ui.set_min_height(box_height);
                    ui.set_max_height(box_height);
                    ui.set_width(ui.available_width());
                    egui::ScrollArea::vertical()
                        .id_salt("snapshot_list_scroll")
                        .max_height(box_height)
                        .min_scrolled_height(box_height)
                        .auto_shrink([false, true])
                        .show(ui, |ui| {
                            if state.available_profiles.is_empty() {
                                ui.label("No snapshots found.");
                            } else {
                                let mut grouped: BTreeMap<String, Vec<&LocalProfileInfo>> =
                                    BTreeMap::new();
                                for profile in &state.available_profiles {
                                    let name = profile
                                        .name
                                        .as_deref()
                                        .unwrap_or(&profile.filename)
                                        .to_string();
                                    grouped.entry(name).or_default().push(profile);
                                }

                                for (name, mut profiles) in grouped {
                                    profiles.sort_by(|a, b| b.version.cmp(&a.version));

                                    // Find which filename should be active for this group
                                    let active_filename = state
                                        .group_versions
                                        .get(&name)
                                        .cloned()
                                        .unwrap_or_else(|| profiles[0].filename.clone());

                                    // Ensure it exists in the current profiles (it might have been deleted)
                                    let active_profile = profiles
                                        .iter()
                                        .find(|p| p.filename == active_filename)
                                        .copied()
                                        .unwrap_or(profiles[0]);

                                    ui.horizontal(|ui| {
                                        let mut label = egui::RichText::new(name.clone());
                                        if !active_profile.is_valid {
                                            label = label.color(egui::Color32::RED);
                                        }

                                        let is_selected = Some(&active_profile.filename)
                                            == state.selected_profile.as_ref();
                                        if ui.selectable_label(is_selected, label).clicked() {
                                            state.selected_profile =
                                                Some(active_profile.filename.clone());
                                            state.group_versions.insert(
                                                name.clone(),
                                                active_profile.filename.clone(),
                                            );
                                        }

                                        ui.with_layout(
                                            egui::Layout::right_to_left(egui::Align::Center),
                                            |ui| {
                                                // Dropdown for versions if multiple versions exist
                                                if profiles.len() > 1 {
                                                    egui::ComboBox::from_id_salt(format!(
                                                        "combo_{name}"
                                                    ))
                                                    .selected_text(
                                                        active_profile
                                                            .version
                                                            .as_deref()
                                                            .unwrap_or_default(),
                                                    )
                                                    .show_ui(ui, |ui| {
                                                        for p in profiles {
                                                            let version_text = p
                                                                .version
                                                                .as_deref()
                                                                .unwrap_or_default();
                                                            if ui
                                                                .selectable_value(
                                                                    &mut state.selected_profile,
                                                                    Some(p.filename.clone()),
                                                                    version_text,
                                                                )
                                                                .clicked()
                                                            {
                                                                state.group_versions.insert(
                                                                    name.clone(),
                                                                    p.filename.clone(),
                                                                );
                                                            }
                                                        }
                                                    });
                                                } else if let Some(version) =
                                                    &active_profile.version
                                                {
                                                    ui.label(egui::RichText::new(version).weak());
                                                }

                                                if active_profile.is_remote {
                                                    ui.label("☁")
                                                        .on_hover_text("Available on cloud");
                                                }

                                                if !active_profile.is_valid {
                                                    ui.label("⚠").on_hover_text(
                                                        "Invalid or tampered snapshot",
                                                    );
                                                }
                                            },
                                        );
                                    });
                                }
                            }
                        });
                });
        });

        // --- Right Column: Description ---
        cols[1].vertical(|ui| {
            ui.label(egui::RichText::new("Description:").strong());
            ui.add_space(2.0);
            egui::Frame::group(ui.style())
                .fill(ui.visuals().extreme_bg_color)
                .show(ui, |ui| {
                    ui.set_min_height(box_height);
                    ui.set_max_height(box_height);
                    ui.set_width(ui.available_width());

                    if let Some(filename) = &state.selected_profile {
                        if let Some(profile) = state
                            .available_profiles
                            .iter()
                            .find(|p| &p.filename == filename)
                        {
                            ui.label(
                                profile
                                    .description
                                    .as_deref()
                                    .unwrap_or("No description provided."),
                            );
                        } else {
                            ui.label(egui::RichText::new("No description provided.").weak());
                        }
                    } else {
                        ui.label(egui::RichText::new("Select a snapshot to see details.").weak());
                    }
                });
        });
    });

    // --- Bottom Section: Create Button (Left) and Actions (Right) ---
    ui.columns(2, |cols| {
        // Left: Create Button
        cols[0].vertical(|ui| {
            ui.add_space(8.0);
            if ui
                .add_enabled(
                    !state.is_running,
                    egui::Button::new("➕ Create New Snapshot"),
                )
                .on_hover_text("Open a dialog to create a new game file snapshot.")
                .clicked()
            {
                // Reset fields and show popup
                state.snapshot_name = "snapshot".to_string();
                state.snapshot_description.clear();
                state.snapshot_version.clear();
                state.snapshot_compression = 0;
                state.snapshot_directory = None;
                state.show_create_popup = true;
            }
        });

        // Right: Restore & Upload Buttons
        cols[1].vertical(|ui| {
            ui.add_space(8.0);
            ui.horizontal(|ui| {
                let has_selection = state.selected_profile.is_some();

                let has_game_exe = storage.game_path().join("Supreme.exe").exists();
                let selected_is_remote = state
                    .selected_profile
                    .as_ref()
                    .and_then(|f| state.available_profiles.iter().find(|p| &p.filename == f))
                    .is_some_and(|p| p.is_remote);

                let restore_enabled =
                    !state.is_running && has_selection && (!selected_is_remote || has_game_exe);

                if ui
                    .add_enabled(restore_enabled, egui::Button::new("♻ Restore"))
                    .on_hover_text(if selected_is_remote && !has_game_exe {
                        "Restoration unavailable when the file Supreme.exe is missing."
                    } else if !has_selection {
                        "Select a snapshot to restore."
                    } else if state.is_running {
                        "Cannot restore while an operation is running."
                    } else {
                        "Restore the selected snapshot."
                    })
                    .clicked()
                {
                    state.show_restore_popup = true;
                }

                if ui
                    .add_enabled(
                        !state.is_running && has_selection && (has_token || !storage.is_online()),
                        egui::Button::new("☁ Upload"),
                    )
                    .on_hover_text(if has_token || !storage.is_online() {
                        "Upload snapshot and required files to the server."
                    } else {
                        "Cloud upload requires SSBZ_API_TOKEN to be set."
                    })
                    .clicked()
                    && let Some(filename) = state.selected_profile.clone()
                {
                    start_upload_snapshot(ui.ctx().clone(), state, storage, filename);
                }
            });
        });
    });

    // --- Create Snapshot Popup ---
    if state.show_create_popup {
        let mut close_popup = false;
        egui::Window::new("Create Snapshot")
            .collapsible(false)
            .resizable(false)
            .show(ui.ctx(), |ui| {
                ui.vertical(|ui| {
                    ui.label("Give your snapshot a name and description.");
                    ui.add_space(8.0);

                    egui::Grid::new("popup_creation_grid")
                        .num_columns(2)
                        .spacing([12.0, 8.0])
                        .show(ui, |ui| {
                            ui.label("Name:");
                            ui.add(
                                egui::TextEdit::singleline(&mut state.snapshot_name)
                                    .hint_text("Required"),
                            );
                            ui.end_row();

                            ui.label("Path:");
                            ui.horizontal(|ui| {
                                let path_str = state
                                    .snapshot_directory
                                    .as_ref()
                                    .map(|p| p.to_string_lossy().to_string())
                                    .unwrap_or_else(|| {
                                        storage.game_path().to_string_lossy().to_string()
                                    });
                                ui.label(egui::RichText::new(path_str).small());
                                if ui.button("📁 Pick...").clicked()
                                    && let Some(path) = rfd::FileDialog::new()
                                        .set_directory(storage.game_path())
                                        .pick_folder()
                                {
                                    state.snapshot_directory = Some(path);
                                }
                            });
                            ui.end_row();

                            ui.label("Description:");
                            ui.add(
                                egui::TextEdit::multiline(&mut state.snapshot_description)
                                    .hint_text("Optional details...")
                                    .desired_rows(3)
                                    .lock_focus(true),
                            );
                            ui.end_row();

                            ui.label("Version:");
                            ui.add(
                                egui::TextEdit::singleline(&mut state.snapshot_version)
                                    .hint_text("Optional version string..."),
                            );
                            ui.end_row();

                            ui.label("Compression Level:");
                            ui.add(
                                egui::Slider::new(&mut state.snapshot_compression, 0..=8)
                                    .text("0=None, 8=Max"),
                            );
                            ui.end_row();
                        });

                    ui.add_space(12.0);

                    ui.horizontal(|ui| {
                        if ui.button("Cancel").clicked() {
                            close_popup = true;
                        }

                        if ui
                            .add_enabled(
                                !state.snapshot_name.trim().is_empty(),
                                egui::Button::new("📷 Create"),
                            )
                            .clicked()
                        {
                            start_create_snapshot(
                                ui.ctx().clone(),
                                state,
                                storage,
                                SnapshotRequest {
                                    name: state.snapshot_name.clone(),
                                    description: if state.snapshot_description.is_empty() {
                                        None
                                    } else {
                                        Some(state.snapshot_description.clone())
                                    },
                                    version: if state.snapshot_version.is_empty() {
                                        None
                                    } else {
                                        Some(state.snapshot_version.clone())
                                    },
                                    custom_directory: state.snapshot_directory.clone(),
                                    compression_level: state.snapshot_compression,
                                },
                            );
                            close_popup = true;
                        }
                    });
                });
            });

        if close_popup {
            state.show_create_popup = false;
        }
    }

    // --- Restore Snapshot Popup ---
    if state.show_restore_popup {
        if let Some(filename) = state.selected_profile.clone() {
            let snapshot_name = state
                .available_profiles
                .iter()
                .find(|p| p.filename == filename)
                .map(|p| {
                    format!(
                        "{} {}",
                        p.name.as_deref().unwrap_or(&filename),
                        p.version.as_deref().unwrap_or("")
                    )
                })
                .unwrap_or(filename.clone());

            let mut close_popup = false;
            egui::Window::new("Confirm Restoration")
                .collapsible(false)
                .resizable(false)
                .show(ui.ctx(), |ui| {
                    ui.vertical(|ui| {
                        ui.label(
                            egui::RichText::new("⚠ Warning: Snapshot restoration can fail.")
                                .color(ui.visuals().warn_fg_color)
                                .strong(),
                        );
                        ui.label("It is highly recommended to create a snapshot of your current game files before restoring.");
                        ui.add_space(4.0);
                        ui.label("Please report any failure along with the error you encountered.");
                        ui.add_space(12.0);

                        ui.horizontal(|ui| {
                            if ui.button("Cancel").clicked() {
                                close_popup = true;
                            }

                            if ui
                                .button(format!("Restore {snapshot_name}"))
                                .clicked()
                            {
                                start_restore_snapshot(ui.ctx().clone(), state, storage, filename.clone());
                                close_popup = true;
                            }
                        });
                    });
                });

            if close_popup {
                state.show_restore_popup = false;
            }
        } else {
            state.show_restore_popup = false;
        }
    }

    ui.add_space(10.0);

    // Path Validation Section
    #[cfg(feature = "local")]
    ui.group(|ui| {
        ui.heading("Path Validation");
        ui.label("Scan game files for broken path references.");

        if ui.button("🔍 Scan for Broken Paths").clicked() && !state.is_running {
            start_path_scan(ui.ctx().clone(), state, storage);
        }

        // Check if diagnostics report exists
        let diagnostics_path = storage.game_path().join(".supreme/path_diagnostics.json");
        state.path_diagnostics_available = diagnostics_path.exists();

        if state.path_diagnostics_available {
            ui.label(format!(
                "📄 Report available at: {}",
                diagnostics_path.display()
            ));
        }
    });

    ui.add_space(10.0);

    // Actions Section
    #[cfg(feature = "local")]
    ui.group(|ui| {
        ui.heading("Actions");
        ui.label("Batch operations for game maintenance.");

        if ui
            .button("🔧 Normalize case")
            .on_hover_text("Make file and folder names case consistent.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Normalize case",
                supreme_cleaner::normalize_case,
            );
        }

        if ui
            .button("🔧 Fix object references")
            .on_hover_text("Repair broken object paths and removal invalid entries.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Fix object references",
                supreme_cleaner::fix_object_references,
            );
        }

        if ui
            .button("🧹 Free-up textures")
            .on_hover_text("Keep the best texture for each object.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Free-up textures",
                supreme_cleaner::free_up_textures,
            );
        }

        if ui
            .button("🔧 Patch game binaries")
            .on_hover_text("Patch hardcoded paths in DLLs.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Patch game binaries",
                supreme_cleaner::patch_game_binaries,
            );
        }

        if ui
            .button("📦 Consolidate object resources")
            .on_hover_text("Ensure all object resources are local to their configuration file.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Consolidate object resources",
                supreme_cleaner::consolidate_resources,
            );
        }

        if ui
            .button("🗑 Clean unused objects")
            .on_hover_text("Remove object directories not referenced by object_classes.txt.")
            .clicked()
            && !state.is_running
        {
            run_cleaner_task(
                ui.ctx().clone(),
                state,
                storage,
                "Clean unused objects",
                supreme_cleaner::clean_unused_objects,
            );
        }
    });
}