launcher/pages/

replays.rs

use crate::tasks::{TaskEvent, TaskHandle, TaskSender, spawn_task};
use crate::widgets::replay_row;
use crate::widgets::replay_row::ReplayRowAction;
use eframe::egui;
use egui_extras::{Column, TableBuilder};
use std::path::PathBuf;
use std::thread;
use supreme_fs::GameStorage;
use supreme_replay_analyzer::AnalyzeResult;
use supreme_replay_analyzer::installer::InstallEvent;
use supreme_replay_analyzer::scanner::ScanResult;
use supreme_snapshot::SnapshotEvent;

#[derive(Default)]
pub struct ReplaysPageState {
    pub analysis_results: Vec<(PathBuf, Result<AnalyzeResult, String>)>,
    pub is_scanning: bool,
    pub is_scanned: bool,
    pub is_advanced_mode: bool,
    pub selected_level: Option<String>,

    // Background processing
    pub backend_receiver: Option<std::sync::mpsc::Receiver<(PathBuf, AnalyzeResult)>>,

    // Snapshot state
    pub snapshot_status: Option<String>,
    pub snapshot_task: Option<TaskHandle<String>>, // Returns snapshot name

    // Install state
    pub replay_name_input: String,
    pub install_status: Option<String>,
    pub install_task: Option<TaskHandle<(PathBuf, AnalyzeResult)>>,
}

pub fn replays_page(ui: &mut egui::Ui, state: &mut ReplaysPageState, storage: &GameStorage) {
    // Extract unique levels for the filter
    let mut levels: Vec<String> = state
        .analysis_results
        .iter()
        .filter_map(|(_, res)| res.as_ref().ok())
        .filter_map(|analysis| analysis.track_name.clone())
        .collect();
    levels.sort();
    levels.dedup();

    ui.horizontal(|ui| {
        ui.heading("Replays");

        ui.add_space(10.0);

        egui::ComboBox::from_id_salt("level_filter")
            .selected_text(state.selected_level.as_deref().unwrap_or("All Levels"))
            .show_ui(ui, |ui| {
                ui.selectable_value(&mut state.selected_level, None, "All Levels");
                for level in levels {
                    ui.selectable_value(&mut state.selected_level, Some(level.clone()), level);
                }
            });

        ui.with_layout(egui::Layout::right_to_left(egui::Align::RIGHT), |ui| {
            ui.checkbox(&mut state.is_advanced_mode, "Advanced");
        });
    });

    ui.add_space(10.0);

    // Install Replay UI
    ui.group(|ui| {
        ui.horizontal(|ui| {
            ui.label("Install Replay:");
            let response = ui.text_edit_singleline(&mut state.replay_name_input);
            if (ui.button("Install / Fetch").clicked()
                || (response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))))
                && !state.replay_name_input.is_empty()
            {
                start_replay_installation(
                    ui.ctx().clone(),
                    state,
                    storage,
                    state.replay_name_input.clone(),
                );
            }
        });
        if let Some(status) = &state.install_status {
            ui.add_space(5.0);
            ui.label(egui::RichText::new(status).italics());
        }
    });

    // Check for install updates
    let mut install_finished = false;
    if let Some(handle) = &state.install_task {
        while let Ok(event) = handle.try_recv() {
            match event {
                TaskEvent::Log(msg) | TaskEvent::SetStatus(msg) => {
                    if msg.is_empty() {
                        state.install_status = None;
                    } else {
                        state.install_status = Some(msg);
                    }
                }
                TaskEvent::PageData((path, analysis)) => {
                    state.install_status = Some(format!(
                        "Successfully installed and analyzed!\nFile: {}",
                        path.file_name().unwrap_or_default().to_string_lossy()
                    ));
                    // Update cache
                    if let Some(entry) = state.analysis_results.iter_mut().find(|(p, _)| *p == path)
                    {
                        entry.1 = Ok(analysis);
                    } else {
                        state.analysis_results.push((path, Ok(analysis)));
                        state.analysis_results.sort_by(|a, b| a.0.cmp(&b.0));
                    }
                }
                TaskEvent::Finished(_) => {
                    install_finished = true;
                }
                _ => {}
            }
        }
    }
    if install_finished {
        state.install_task = None;
    }

    // Check for background results
    if let Some(rx) = &state.backend_receiver {
        while let Ok((path, result)) = rx.try_recv() {
            if let Some(entry) = state.analysis_results.iter_mut().find(|(p, _)| *p == path) {
                entry.1 = Ok(result);
            }
        }
    }

    // Check for snapshot updates
    let mut snapshot_finished = false;
    if let Some(handle) = &state.snapshot_task {
        while let Ok(event) = handle.try_recv() {
            match event {
                TaskEvent::Log(_) => {}
                TaskEvent::SetStatus(msg) => state.snapshot_status = Some(msg),
                TaskEvent::InitProgress(_) => {}
                TaskEvent::IncrementProgress => {}
                TaskEvent::UpdateProgress(_) => {}
                TaskEvent::Perf(_, _, _) => {}
                TaskEvent::PageData(_) => {}
                TaskEvent::Finished(res) => {
                    snapshot_finished = true;
                    match res {
                        Ok(snapshot_name) => {
                            ui.ctx().copy_text(snapshot_name);
                            state.snapshot_status =
                                Some("Snapshot created and name copied to clipboard!".to_string());
                        }
                        Err(e) => {
                            state.snapshot_status = Some(format!("Error: {e}"));
                        }
                    }
                }
            }
        }
    }
    if snapshot_finished {
        state.snapshot_task = None;
    }

    if let Some(status) = &state.snapshot_status
        && !status.is_empty()
    {
        ui.label(status);
        ui.add_space(10.0);
    }

    ui.add_space(10.0);

    // Scan for .dat files if not already done
    if !state.is_scanned && !state.is_scanning {
        state.is_scanning = true;
        ui.label("Analyzing all .dat replay files in ./data directory...");
        ui.add_space(10.0);

        // Perform the analysis and cache results
        scan_and_analyze_replays(state, storage);

        state.is_scanning = false;
        state.is_scanned = true;
    } else {
        ui.label("The replay analyzer is experimental, please report any computation mistakes.");
        ui.add_space(10.0);
    }

    if state.analysis_results.is_empty() && !state.is_scanning {
        ui.label("No .dat files found in ./data directory.");
        return;
    }

    // Display results in a table
    ui.add_space(10.0);

    let mut snapshot_request = None;

    let mut builder = TableBuilder::new(ui)
        .striped(true)
        .resizable(true)
        .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
        .column(Column::auto()) // Snapshot
        .column(Column::auto()) // File
        .column(Column::auto()) // Player
        .column(Column::auto()) // Track
        .column(Column::auto().at_least(108.0)) // Start
        .column(Column::auto().at_least(108.0)); // CP1

    if state.is_advanced_mode {
        builder = builder.column(Column::auto()); // CP2
    }

    builder = builder.column(Column::auto().at_least(108.0)); // Finish

    builder = builder.column(Column::auto().at_least(108.0)); // Total

    if state.is_advanced_mode {
        builder = builder
            .column(Column::auto()) // Lag Before
            .column(Column::auto()) // Lag After
            .column(Column::auto()); // Recording length
    }

    builder
        .header(20.0, |mut header| {
            header.col(|ui| {
                ui.strong("📷");
            });
            header.col(|ui| {
                ui.strong("File");
            });
            header.col(|ui| {
                ui.strong("Player");
            });
            header.col(|ui| {
                ui.strong("Track");
            });
            header.col(|ui| {
                ui.horizontal(|ui| {
                    ui.strong("Start");
                    ui.label("ℹ").on_hover_text(
                        "Duration between the end of the countdown and the crossing of the start line.",
                    );
                });
            });
            header.col(|ui| {
                ui.horizontal(|ui| {
                    ui.strong("CP1");
                    ui.label("ℹ").on_hover_text(
                        "Duration from the start line and checkpoint 1.",
                    );
                });
            });
            if state.is_advanced_mode {
                header.col(|ui| {
                    ui.horizontal(|ui| {
                        ui.strong("CP2");
                        ui.label("ℹ").on_hover_text(
                            "Duration from the start line and checkpoint 2.",
                        );
                    });
                });
            }
            header.col(|ui| {
                ui.horizontal(|ui| {
                    ui.strong("Finish");
                    ui.label("ℹ").on_hover_text(
                        "Duration from the start line and finish line.",
                    );
                });
            });
            header.col(|ui| {
                ui.horizontal(|ui| {
                    ui.strong("Total");
                    ui.label("ℹ").on_hover_text(
                        "Total time the character was controlled by the player, from the end of the countdown to the finish line",
                    );
                });
            });
            if state.is_advanced_mode {
                header.col(|ui| {
                    ui.horizontal(|ui| {
                    ui.strong("Lag before");
                    ui.label("ℹ").on_hover_text(
                        "Duration of the countdown, before the player controls the character.",
                    );
                });
                });
                header.col(|ui| {
                    ui.horizontal(|ui| {
                        ui.strong("Lag after");
                        ui.label("ℹ").on_hover_text(
                            "Duration of the part after crossing the finish line.",
                        );
                    });
                });
                header.col(|ui| {
                    ui.horizontal(|ui| {
                        ui.strong("Recording duration");
                        ui.label("ℹ").on_hover_text(
                            "Total recording duration, which is the total time plus the lags.",
                        );
                    });
                });
            }
        })
        .body(|mut body| {
            for (path, result) in &state.analysis_results {
                if let Some(selected_level) = &state.selected_level {
                    match result {
                        Ok(analysis) => {
                            if analysis.track_name.as_deref() != Some(selected_level) {
                                continue;
                            }
                        }
                        Err(_) => continue,
                    }
                }

                body.row(18.0, |mut row| {
                    if let Some(ReplayRowAction::CreateSnapshot) =
                        replay_row::render_replay_row(&mut row, path, result, state.is_advanced_mode)
                        && let Ok(analysis) = result {
                            snapshot_request = Some((path.clone(), analysis.clone()));
                        }
                });
            }
        });

    if let Some((path, analysis)) = snapshot_request {
        start_snapshot_creation(ui.ctx().clone(), state, storage, path, analysis);
    }
}

/// Scans and analyzes replay files using the scanner module
fn scan_and_analyze_replays(state: &mut ReplaysPageState, storage: &GameStorage) {
    let ScanResult {
        analysis_results,
        background_receiver,
        performance,
    } = supreme_replay_analyzer::scanner::scan_and_analyze_replays(storage);

    state.analysis_results = analysis_results;
    state.backend_receiver = Some(background_receiver);
    state.is_scanned = true;

    // Write performance log
    supreme_replay_analyzer::scanner::write_performance_log(storage, &performance);
}

/// Starts snapshot creation using the `supreme_snapshot` module
fn start_snapshot_creation(
    ctx: eframe::egui::Context,
    state: &mut ReplaysPageState,
    storage: &GameStorage,
    replay_path: PathBuf,
    analysis: AnalyzeResult,
) {
    state.snapshot_status = Some("Initializing snapshot...".to_string());
    let storage_clone = storage.clone();

    state.snapshot_task = Some(spawn_task(ctx, move |tx: TaskSender<String>| {
        let (lib_tx, lib_rx) = std::sync::mpsc::channel();
        let storage_clone = storage_clone.clone();
        let handle = thread::spawn(move || {
            supreme_snapshot::create_replay_snapshot(&storage_clone, replay_path, &analysis, lib_tx)
        });

        while let Ok(event) = lib_rx.recv() {
            let mapped = match event {
                SnapshotEvent::Log(msg) => TaskEvent::Log(msg),
                SnapshotEvent::SetStatus(msg) => TaskEvent::SetStatus(msg),
                SnapshotEvent::InitProgress(total) => TaskEvent::InitProgress(total),
                SnapshotEvent::IncrementProgress => TaskEvent::IncrementProgress,
                SnapshotEvent::Perf(op, target, ms) => TaskEvent::Perf(op, target, ms),
            };
            let _ = tx.send(mapped);
        }

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

/// Starts replay installation using the installer module
fn start_replay_installation(
    ctx: eframe::egui::Context,
    state: &mut ReplaysPageState,
    storage: &GameStorage,
    replay_name: String,
) {
    state.install_status = Some(format!("Fetching '{replay_name}'..."));
    let storage = storage.clone();

    state.install_task = Some(spawn_task(ctx, move |tx| {
        let handle = supreme_replay_analyzer::installer::install_replay(&storage, replay_name);

        for event in handle.receiver {
            match event {
                InstallEvent::Log(msg) => {
                    let _ = tx.send(TaskEvent::Log(msg));
                }
                InstallEvent::Finished(path, analysis) => {
                    let _ = tx.send(TaskEvent::PageData((path.clone(), analysis.clone())));
                    return Ok((path, analysis));
                }
            }
        }

        Err("Installation ended without a result".to_string())
    }));
}