launcher/app/

logic.rs

use super::LauncherApp;
use crate::pages::trainer::TrainerData;
use crate::pages::troubleshoot::TroubleshootData;
use crate::tasks::TaskEvent;
use std::io::Write;

impl LauncherApp {
    pub fn save_all_configs(&mut self) {
        match self.config_manager.save_all() {
            Ok(()) => {
                self.error_message = None;
            }
            Err(errors) => {
                let error_msg = errors.join("\n");
                self.error_message = Some(format!(
                    "{error_msg}\nClick \"Play\" again to start anyway."
                ));
            }
        }
    }

    pub fn load_music_configs(&mut self) {
        self.config_manager.load_music_configs();
        self.music_state.is_scanned = false;
    }

    #[cfg(feature = "local")]
    pub fn export_configs(&mut self) {
        match self.config_manager.export() {
            Ok(_export_path) => {
                self.error_message = None;
            }
            Err(errors) => {
                self.error_message = Some(errors.join("\n"));
            }
        }
    }

    pub fn update_unified_operations(&mut self) {
        // Update dependency operations
        if let Some(handle) = self.dependency_receiver.take() {
            while let Ok(event) = handle.try_recv() {
                self.handle_task_event(event);
            }
            if self.unified_operation.is_running {
                self.dependency_receiver = Some(handle);
            } else {
                self.dependency_receiver = None;
                self.trainer_state.last_checked = None; // Force refresh after operations complete
            }
        }

        // Update troubleshoot operations
        if let Some(handle) = self.troubleshoot_receiver.take() {
            while let Ok(event) = handle.try_recv() {
                match event {
                    TaskEvent::PageData(data) => match data {
                        TroubleshootData::Diagnostics(d) => {
                            self.unified_operation.diagnostics = Some(d);
                        }
                        TroubleshootData::Profiles(_) => {}
                        TroubleshootData::RefreshStatus(_) => {}
                    },
                    event => self.handle_task_event(event.map(|_| ())),
                }
            }
            if self.unified_operation.is_running {
                self.troubleshoot_receiver = Some(handle);
            } else {
                self.troubleshoot_receiver = None;
            }
        }

        // Update trainer operations
        if let Some(handle) = self.trainer_receiver.take() {
            while let Ok(event) = handle.try_recv() {
                match event {
                    TaskEvent::PageData(data) => match data {
                        TrainerData::DependenciesCheck(installed) => {
                            self.trainer_state.dependencies_installed = installed;
                            self.trainer_state.is_checking = false;
                            self.trainer_state.last_checked = Some(std::time::Instant::now());
                        }
                        TrainerData::HdFontsCheck(needed) => {
                            self.trainer_state.hd_fonts_needed = needed;
                        }
                    },
                    event => self.handle_task_event(event.map(|_| ())),
                }
            }
            if !self.unified_operation.is_running && !self.trainer_state.is_checking {
                self.trainer_receiver = None;
            } else {
                self.trainer_receiver = Some(handle);
            }
        }
    }

    pub fn handle_task_event<T>(&mut self, event: TaskEvent<T>) {
        use TaskEvent;
        match event {
            TaskEvent::Log(msg) => {
                self.unified_operation.logs.push(msg);
            }
            TaskEvent::SetStatus(msg) => {
                self.unified_operation.status = msg;
            }
            TaskEvent::InitProgress(total) => {
                self.unified_operation.total_items = total;
                self.unified_operation.processed_items = 0;
            }
            TaskEvent::IncrementProgress => {
                self.unified_operation.processed_items += 1;
            }
            TaskEvent::UpdateProgress(p) => {
                self.unified_operation.processed_items = p;
            }
            TaskEvent::Perf(_op, _target, _ms) => {
                // Ignore perf in unified operation
            }
            TaskEvent::PageData(_) => {
                // Ignore generic data in unified operation; handled in update_unified_operations specifically
            }
            TaskEvent::Finished(res) => {
                self.unified_operation.is_running = false;
                match res {
                    Ok(_) => {
                        self.unified_operation.status =
                            "Operation completed successfully.".to_string();
                        self.unified_operation.processed_items = self.unified_operation.total_items;
                    }
                    Err(e) => {
                        self.unified_operation.status = format!("Error: {e}");
                        self.unified_operation.logs.push(format!("Error: {e}"));
                    }
                }
            }
        }
    }

    pub fn run_injector(&mut self) {
        let resources_dir = self.storage.game_path().join("Display_Config_Resources");
        let injector_path = resources_dir.join("Injector.exe");
        let log_path = resources_dir.join("Display_Config_Helper.log");

        if !injector_path.exists() {
            // Start normally when there is no injector
            std::process::exit(0);
        }

        let mut attempts = 0;
        let max_attempts = 2;

        while attempts < max_attempts {
            let mut command = std::process::Command::new(&injector_path);
            command.current_dir(&resources_dir);
            command.stdout(std::process::Stdio::piped());
            command.stderr(std::process::Stdio::piped());

            let result = command.output();

            // Log output if possible
            if let Ok(ref output) = result
                && let Ok(mut file) = std::fs::OpenOptions::new()
                    .create(true)
                    .append(true)
                    .open(&log_path)
            {
                if let Err(e) = writeln!(file, "\n--- Injector Log (Attempt {}) ---", attempts + 1)
                {
                    eprintln!("Failed to write injector log header: {e}");
                }
                if let Err(e) = file.write_all(&output.stdout) {
                    eprintln!("Failed to write injector stdout to log: {e}");
                }
                if let Err(e) = file.write_all(&output.stderr) {
                    eprintln!("Failed to write injector stderr to log: {e}");
                }
                if let Err(e) = writeln!(file, "--- End Log ---") {
                    eprintln!("Failed to write injector log footer: {e}");
                }
            }
            if let Err(ref e) = result
                && let Ok(mut file) = std::fs::OpenOptions::new()
                    .create(true)
                    .append(true)
                    .open(&log_path)
            {
                if let Err(write_err) = writeln!(file, "\n--- Injector Execution Error ---") {
                    eprintln!("Failed to write injector error header: {write_err}");
                }
                if let Err(write_err) = writeln!(file, "Error: {e}") {
                    eprintln!("Failed to write injector error detail: {write_err}");
                }
                if let Err(write_err) = writeln!(file, "--- End Log ---") {
                    eprintln!("Failed to write injector error footer: {write_err}");
                }
            }

            match result {
                Ok(output) if output.status.success() => {
                    // Injection succeeded, exit
                    std::process::exit(0);
                }
                _ => {
                    // Injection failed
                    let failed_with_logs_disabled =
                        !self.config_manager.trainer_config.enable_logging;

                    self.error_message = Some(
                        "Failed to inject patches.\nClick \"Play\" again to force start."
                            .to_string(),
                    );

                    if attempts == 0 && failed_with_logs_disabled {
                        // Turn on logs and retry
                        self.config_manager.trainer_config.enable_logging = true;
                        if let Err(e) = self.config_manager.save_all() {
                            eprintln!("Failed to save config after enabling logging: {e:?}");
                        }
                        attempts += 1;
                        continue;
                    }
                    // Don't retry further, just exit
                    break;
                }
            }
        }
    }
}