launcher/pages/troubleshoot/

tasks.rs

use crate::pages::troubleshoot::TroubleshootData;
use crate::pages::troubleshoot::types::TroubleshootPageState;
use crate::tasks::{TaskEvent, spawn_task};
use sha2::{Digest, Sha256};
use std::fs;
use supreme_fs::{GameStorage, SnapshotEvent};

#[cfg(feature = "local")]
use std::io;
#[cfg(feature = "local")]
use std::sync::mpsc::Sender;
#[cfg(feature = "local")]
use supreme_diagnostics::DiagnosticsEvent;

#[derive(Clone, Debug)]
pub struct LocalProfileInfo {
    pub filename: String,
    pub name: Option<String>,
    pub description: Option<String>,
    pub version: Option<String>,
    pub is_remote: bool,
    pub is_valid: bool,
}

pub fn start_refresh_profiles(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
) {
    init_task(state, "Refreshing profiles...".to_string());
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let _ = tx.send(TaskEvent::SetStatus("Refreshing profiles...".to_string()));

        // Send profile-refresh-active flag via the unified data channel
        let _ = tx.send(TaskEvent::PageData(TroubleshootData::RefreshStatus(true)));

        let start_total = std::time::Instant::now();

        let (local_tx, local_rx) = std::sync::mpsc::channel();
        let (remote_tx, remote_rx) = std::sync::mpsc::channel();

        // Local scan, intentionally parallel sub-threads (short-lived)
        let storage_local = storage.clone();
        let local_tx_log = tx.clone();
        std::thread::spawn(move || {
            let _ = local_tx_log.send(TaskEvent::Log("Scanning local profiles...".to_string()));
            let start_local = std::time::Instant::now();

            let filenames = match storage_local.list_snapshots_profiles() {
                Ok(f) => {
                    let _ = local_tx_log.send(TaskEvent::Log(format!(
                        "Found {} local profiles on disk.",
                        f.len()
                    )));
                    f
                }
                Err(e) => {
                    let _ = local_tx_log.send(TaskEvent::Log(format!(
                        "Warning: Failed to list local profiles: {e}"
                    )));
                    Vec::new()
                }
            };
            let mut profiles = Vec::new();

            for filename in filenames {
                let filename_json = format!("{filename}.json");
                let path = storage_local.profiles_path().join(&filename_json);
                let mut name = None;
                let mut desc = None;
                let mut version = None;

                let is_valid;
                if let Ok(content) = fs::read(&path) {
                    // Check validity: sha256 of content must match filename
                    let mut hasher = Sha256::new();
                    hasher.update(&content);
                    let actual_hash = hex::encode(hasher.finalize());
                    is_valid = actual_hash == filename;

                    if let Ok(manifest) =
                        serde_json::from_slice::<supreme_snapshot::SnapshotManifest>(&content)
                    {
                        name = manifest.name;
                        desc = manifest.description;
                        version = manifest.version;
                    }
                } else {
                    is_valid = false;
                }

                profiles.push(LocalProfileInfo {
                    filename,
                    name,
                    description: desc,
                    version,
                    is_remote: false,
                    is_valid,
                });
            }
            let _ = local_tx.send((profiles, start_local.elapsed().as_secs_f64() * 1000.0));
        });

        // Remote scan, intentionally parallel sub-thread
        let storage_remote = storage.clone();
        let remote_tx_log = tx.clone();
        std::thread::spawn(move || {
            let _ = remote_tx_log.send(TaskEvent::Log("Fetching online profiles...".to_string()));
            let start_remote = std::time::Instant::now();

            let online = match storage_remote.list_online_profiles() {
                Ok(p) => {
                    let _ = remote_tx_log.send(TaskEvent::Log(format!(
                        "Found {} online profiles.",
                        p.len()
                    )));
                    p
                }
                Err(e) => {
                    let _ = remote_tx_log.send(TaskEvent::Log(format!(
                        "Warning: Failed to list online profiles: {e}"
                    )));
                    Vec::new()
                }
            };
            let _ = remote_tx.send((online, start_remote.elapsed().as_secs_f64() * 1000.0));
        });

        // Coordinator: wait for both results
        let mut local_res: Option<Vec<LocalProfileInfo>> = None;
        let mut remote_res: Option<Vec<supreme_fs::OnlineProfileInfo>> = None;
        let mut local_ms = 0.0f64;
        let mut remote_ms = 0.0f64;

        let (local_profiles, online_profiles) = loop {
            if local_res.is_none() {
                match local_rx.try_recv() {
                    Ok((res, ms)) => {
                        local_res = Some(res);
                        local_ms = ms;
                    }
                    Err(std::sync::mpsc::TryRecvError::Disconnected) => {
                        local_res = Some(Vec::new());
                    }
                    _ => {}
                }
            }

            if remote_res.is_none() {
                match remote_rx.try_recv() {
                    Ok((res, ms)) => {
                        remote_res = Some(res);
                        remote_ms = ms;
                    }
                    Err(std::sync::mpsc::TryRecvError::Disconnected) => {
                        remote_res = Some(Vec::new());
                    }
                    _ => {}
                }
            }

            if let (Some(local), Some(remote)) = (local_res.take(), remote_res.take()) {
                break (local, remote);
            }
            std::thread::sleep(std::time::Duration::from_millis(10));
        };

        // Merge results
        let mut final_profiles = Vec::new();
        let mut processed_filenames = std::collections::HashSet::new();

        let online_map: std::collections::HashMap<String, supreme_fs::OnlineProfileInfo> =
            online_profiles
                .into_iter()
                .map(|p| (p.filename.clone(), p))
                .collect();

        for mut profile in local_profiles {
            let filename_json = format!("{}.json", profile.filename);
            if let Some(online_info) = online_map.get(&filename_json) {
                profile.is_remote = true;
                if profile.name.is_none() {
                    profile.name = online_info.name.clone();
                }
                if profile.description.is_none() {
                    profile.description = online_info.description.clone();
                }
                if profile.version.is_none() {
                    profile.version = online_info.version.clone();
                }
            }
            processed_filenames.insert(filename_json);
            final_profiles.push(profile);
        }

        // Add remote-only profiles
        for (filename_json, info) in &online_map {
            if !processed_filenames.contains(filename_json) {
                let stem = filename_json
                    .strip_suffix(".json")
                    .unwrap_or(filename_json)
                    .to_string();
                final_profiles.push(LocalProfileInfo {
                    filename: stem,
                    name: info.name.clone(),
                    description: info.description.clone(),
                    version: info.version.clone(),
                    is_remote: true,
                    is_valid: true,
                });
            }
        }

        let count = final_profiles.len();
        let _ = tx.send(TaskEvent::PageData(TroubleshootData::Profiles(
            final_profiles,
        )));
        let _ = tx.send(TaskEvent::PageData(TroubleshootData::RefreshStatus(false)));
        let _ = tx.send(TaskEvent::Log(format!("{count} total profiles loaded.")));
        let _ = tx.send(TaskEvent::SetStatus(format!("{count} profiles loaded.")));

        let total_ms = start_total.elapsed().as_secs_f64() * 1000.0;

        // Write performance report
        #[derive(serde::Serialize)]
        struct ListingPerf {
            total_ms: f64,
            local_ms: f64,
            remote_ms: f64,
            profile_count: usize,
            timestamp: u64,
        }

        let perf = ListingPerf {
            total_ms,
            local_ms,
            remote_ms,
            profile_count: count,
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs(),
        };
        if let Err(e) = storage.write_report("listing_profiles_perf", &perf) {
            let _ = tx.send(TaskEvent::Log(format!("Failed to write perf report: {e}")));
        }

        Ok(TroubleshootData::RefreshStatus(false)) // Finisher data
    }));
}

pub fn init_task(state: &mut TroubleshootPageState, status: String) {
    state.is_running = true;
    state.total_items = 0;
    state.processed_items = 0;
    state.status = status;
    state.logs.clear();
    state.performance_entries.clear();
}

#[cfg(feature = "local")]
pub fn run_cleaner_task<F>(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
    name: &str,
    f: F,
) where
    F: FnOnce(&GameStorage, Sender<supreme_cleaner::CleanerEvent>) -> io::Result<()>
        + Send
        + 'static,
{
    init_task(state, format!("{name}..."));
    let name = name.to_string();
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let _ = tx.send(TaskEvent::Log(format!("Starting: {name}")));
        let (lib_tx, lib_rx) = std::sync::mpsc::channel();

        let handle = std::thread::spawn(move || f(&storage, lib_tx));

        for event in lib_rx {
            let task_event: TaskEvent<()> = event.into();
            let _ = tx.send(task_event.map(|_| TroubleshootData::RefreshStatus(false)));
        }

        let result = handle
            .join()
            .unwrap_or(Err(io::Error::other("Task panicked")));
        match &result {
            Err(e) => {
                let _ = tx.send(TaskEvent::Log(format!("Error: {e}")));
            }
            Ok(_) => {
                let _ = tx.send(TaskEvent::Log(format!("Completed: {name}")));
            }
        }
        result
            .map(|_| TroubleshootData::RefreshStatus(false))
            .map_err(|e| e.to_string())
    }));
}

pub fn start_create_snapshot(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
    request: SnapshotRequest,
) {
    init_task(state, format!("Creating snapshot '{}'...", request.name));
    let SnapshotRequest {
        name,
        description,
        version,
        custom_directory,
        compression_level,
    } = request;
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let (lib_tx, lib_rx) = std::sync::mpsc::channel::<SnapshotEvent>();

        // Library must run on a std thread, it may use rayon internally.
        let handle = std::thread::spawn(move || {
            supreme_snapshot::create_snapshot(
                &storage,
                &name,
                description,
                version,
                custom_directory,
                lib_tx,
                compression_level,
            )
        });

        for event in lib_rx {
            let task_event: TaskEvent<()> = event.into();
            let _ = tx.send(task_event.map(|()| TroubleshootData::RefreshStatus(false)));
        }

        handle
            .join()
            .unwrap_or(Err(std::io::Error::other("Thread panicked")))
            .map(|_| TroubleshootData::RefreshStatus(false))
            .map_err(|e| e.to_string())
    }));
}

/// The user-supplied create-snapshot request, exactly as the form
/// filled it in.
pub struct SnapshotRequest {
    pub name: String,
    pub description: Option<String>,
    pub version: Option<String>,
    pub custom_directory: Option<std::path::PathBuf>,
    pub compression_level: u32,
}

pub fn start_restore_snapshot(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
    profile: String,
) {
    init_task(state, format!("Restoring profile '{profile}'..."));
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let (lib_tx, lib_rx) = std::sync::mpsc::channel::<SnapshotEvent>();
        let mut perf_entries: Vec<(String, String, u128)> = Vec::new();

        // Library must run on a std thread, it may use rayon internally.
        let profile_for_thread = profile.clone();
        let storage_for_thread = storage.clone();
        let handle = std::thread::spawn(move || {
            supreme_snapshot::restore_snapshot(&storage_for_thread, &profile_for_thread, lib_tx)
        });

        for event in lib_rx {
            if let SnapshotEvent::Perf(ref op, ref target, ms) = event {
                perf_entries.push((op.clone(), target.clone(), ms));
            }
            let task_event: TaskEvent<()> = event.into();
            let _ = tx.send(task_event.map(|()| TroubleshootData::RefreshStatus(false)));
        }

        let result = handle
            .join()
            .unwrap_or(Err(std::io::Error::other("Thread panicked")));

        #[derive(serde::Serialize)]
        struct PerfEntry {
            op: String,
            target: String,
            ms: u128,
        }
        #[derive(serde::Serialize)]
        struct RestorePerf {
            profile: String,
            entries: Vec<PerfEntry>,
            timestamp: u64,
        }
        let report = RestorePerf {
            profile: profile.clone(),
            entries: perf_entries
                .iter()
                .map(|(op, target, ms)| PerfEntry {
                    op: op.clone(),
                    target: target.clone(),
                    ms: *ms,
                })
                .collect(),
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs(),
        };
        if let Err(e) = storage.write_report("restore_snapshot_perf", &report) {
            let _ = tx.send(TaskEvent::Log(format!("Failed to write perf report: {e}")));
        }

        // --- Post-Restoration Music Handling ---
        // Pass the manifest returned by restore_snapshot directly so it is not re-loaded from disk.
        if let Ok(ref manifest) = result {
            let sub_tx = tx.clone();
            let (lib_tx, lib_rx) = std::sync::mpsc::channel::<SnapshotEvent>();
            let bridge_handle = std::thread::spawn(move || {
                while let Ok(event) = lib_rx.recv() {
                    let task_event: TaskEvent<()> = event.into();
                    let _ =
                        sub_tx.send(task_event.map(|()| TroubleshootData::RefreshStatus(false)));
                }
            });

            if let Err(e) =
                supreme_snapshot::reconcile_music_after_restore(&storage, manifest, &lib_tx)
            {
                let _ = tx.send(TaskEvent::Log(format!(
                    "Failed to reconcile music after restore: {e}"
                )));
            }
            drop(lib_tx);
            if bridge_handle.join().is_err() {
                let _ = tx.send(TaskEvent::Log(
                    "Music reconciliation logging thread panicked".to_string(),
                ));
            }
        }

        result
            .map(|_manifest| TroubleshootData::RefreshStatus(false))
            .map_err(|e| e.to_string())
    }));
}

pub fn start_upload_snapshot(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
    filename: String,
) {
    init_task(state, format!("Uploading snapshot '{filename}'..."));
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let (lib_tx, lib_rx) = std::sync::mpsc::channel::<SnapshotEvent>();

        let path = storage.profiles_path().join(format!("{filename}.json"));

        if let Ok(metadata) = fs::metadata(&path) {
            let file_size = metadata.len();
            let _ = tx.send(TaskEvent::Log(format!("Snapshot size: {file_size} bytes")));

            if let Ok(max_size) = storage.get_max_upload_size()
                && file_size > max_size as u64
            {
                let _ = tx.send(TaskEvent::Log(format!(
                    "File size exceeds server limit ({max_size} bytes), using chunked upload"
                )));
            }
        }

        // Library must run on a std thread, it may use rayon internally.
        let handle = std::thread::spawn(move || {
            supreme_snapshot::upload_snapshot(&storage, &path, &filename, &lib_tx)
        });

        for event in lib_rx {
            let task_event: TaskEvent<()> = event.into();
            let _ = tx.send(task_event.map(|()| TroubleshootData::RefreshStatus(false)));
        }

        handle
            .join()
            .unwrap_or(Err(std::io::Error::other("Thread panicked")))
            .map(|()| TroubleshootData::RefreshStatus(false))
            .map_err(|e| e.to_string())
    }));
}

#[cfg(feature = "local")]
pub fn start_path_scan(
    ctx: eframe::egui::Context,
    state: &mut TroubleshootPageState,
    storage: &GameStorage,
) {
    init_task(state, "Scanning for broken paths...".to_string());
    let storage = storage.clone();

    state.task_handle = Some(spawn_task(ctx, move |tx| {
        let (lib_tx, lib_rx) = std::sync::mpsc::channel::<DiagnosticsEvent>();

        // Library must run on a std thread, it uses rayon::par_iter internally.
        let handle = std::thread::spawn(move || supreme_diagnostics::scan_paths(&storage, lib_tx));

        for event in lib_rx {
            // DiagnosticsEvent::Finished carries Result<(), String> (not PathDiagnostics).
            // The actual PathDiagnostics is the function's return value; skip this variant here.
            if !matches!(event, DiagnosticsEvent::Finished(_)) {
                let task_event: TaskEvent<()> = event.into();
                let _ = tx.send(task_event.map(|_| TroubleshootData::RefreshStatus(false)));
            }
        }

        match handle
            .join()
            .unwrap_or(Err(std::io::Error::other("Thread panicked")))
        {
            Ok(diagnostics) => {
                let _ = tx.send(TaskEvent::PageData(TroubleshootData::Diagnostics(
                    diagnostics,
                )));
                Ok(TroubleshootData::RefreshStatus(false))
            }
            Err(e) => Err(e.to_string()),
        }
    }));
}