epik/gui/

app.rs

use eframe::egui;
use poll_promise::Promise;
use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};

use crate::api::Game;
use crate::auth::AuthManager;
use crate::config::Config;
use crate::downloader::DownloadProgress as DlProgress;
use crate::games::{DownloadProgressCallback, GameManager, InstalledGame};
use crate::i18n::{Language, Localizer};
use crate::launcher::discover_wine_installations;
use crate::legendary::cli::LegendaryCLI;
use crate::Result;

use super::auth_view::AuthView;
use super::components::{
    AchievementsView, Header, SidebarItem, SidebarState, StatsView, StatusBar, StoreView,
};
use super::download_view::DownloadView;

use super::library_view::{LibraryAction, LibraryView};
use super::settings_view::{SettingsAction, SettingsView};
use super::styles;

type ImageData = (usize, usize, Vec<u8>);

#[derive(Clone, Copy)]
enum AppState {
    Login,
    Library,
    Store,
    Downloads,
    Settings,
}

pub struct LauncherApp {
    state: AppState,
    auth: Arc<Mutex<AuthManager>>,
    config: Arc<Mutex<Config>>,
    localizer: Localizer,
    auth_view: AuthView,
    library_view: LibraryView,
    download_view: DownloadView,
    store_view: StoreView,

    sidebar_state: SidebarState,

    settings_view: SettingsView,
    library_games: Vec<Game>,
    installed_games: Vec<InstalledGame>,
    status_message: String,
    loading_library: bool,
    library_promise: Option<Promise<Result<Vec<Game>>>>,
    install_promises: Vec<(String, Promise<Result<()>>)>,
    image_promises: Vec<(String, Promise<Option<ImageData>>)>,
    verify_promises: Vec<(String, Promise<Result<Vec<String>>>)>,
    enrich_promises: Vec<(String, Promise<Result<Game>>)>,
    update_promises: Vec<(String, Promise<Result<Option<String>>>)>,
    updates_available: HashMap<String, String>,
    updates_checked: HashSet<String>,
    wine_options: Vec<(String, String)>,
    // Shared download progress updates from background threads
    download_progress: Arc<Mutex<std::collections::HashMap<String, DlProgress>>>,
    install_cancel_flags: Arc<Mutex<HashMap<String, Arc<AtomicBool>>>>,
}

impl LauncherApp {
    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
        let config = Config::load().unwrap_or_default();

        // Apply theme from config
        let theme = match config.theme.as_str() {
            "Dark" => styles::Theme::Dark,
            "Light" => styles::Theme::Light,
            _ => styles::Theme::Epic,
        };
        theme.apply(&cc.egui_ctx);

        // Initialize localizer with configured language
        let mut localizer = Localizer::new();
        let language = match config.language.as_str() {
            "it" => Language::Italian,
            "fr" => Language::French,
            "de" => Language::German,
            "es" => Language::Spanish,
            _ => Language::English,
        };
        localizer.set_language(language);

        let auth = AuthManager::new().unwrap_or_default();

        // Check if already authenticated
        let is_authenticated = auth.is_authenticated();

        // Load settings from config
        let mut settings_view = SettingsView::default();
        settings_view.auto_update = config.auto_update;
        settings_view.start_minimized = config.minimize_to_tray;
        settings_view.close_to_tray = config.close_to_tray;
        settings_view.language = config.language.clone();
        settings_view.theme = config.theme.clone();
        settings_view.max_concurrent_downloads = config.max_concurrent_downloads as usize;
        settings_view.download_threads = config.download_threads as usize;
        settings_view.bandwidth_limit_enabled = config.enable_bandwidth_limit;
        settings_view.bandwidth_limit_mbps = config.bandwidth_limit_mbps as f32;
        settings_view.cdn_region = config.cdn_region.clone();
        settings_view.auto_detect_wine = true; // Not in config yet
        settings_view.wine_prefix_per_game = false; // Not in config yet
        settings_view.dxvk_enabled = config.enable_dxvk;
        settings_view.esync_enabled = config.enable_esync;
        settings_view.log_level = config.log_level.clone();
        settings_view.enable_telemetry = !config.disable_telemetry;
        settings_view.log_to_file = config.log_to_file;
        settings_view.crash_reporting = config.enable_crash_reporting;
        settings_view.privacy_mode = config.privacy_mode;

        let mut app = Self {
            state: if is_authenticated {
                AppState::Library
            } else {
                AppState::Login
            },
            auth: Arc::new(Mutex::new(auth)),
            config: Arc::new(Mutex::new(config)),
            localizer: localizer.clone(),
            auth_view: AuthView::default(),
            library_view: LibraryView::default(),
            download_view: DownloadView::default(),
            store_view: StoreView::default(),
            sidebar_state: SidebarState::default(),

            settings_view,
            library_games: Vec::new(),
            installed_games: Vec::new(),
            status_message: String::new(),
            loading_library: false,
            library_promise: None,
            install_promises: Vec::new(),
            image_promises: Vec::new(),
            verify_promises: Vec::new(),
            enrich_promises: Vec::new(),
            update_promises: Vec::new(),
            updates_available: HashMap::new(),
            updates_checked: HashSet::new(),
            wine_options: Self::load_wine_options(),
            download_progress: Arc::new(Mutex::new(std::collections::HashMap::new())),
            install_cancel_flags: Arc::new(Mutex::new(HashMap::new())),
        };

        // Inject localizer into views
        let localizer_arc = Arc::new(localizer);
        app.library_view.set_localizer(Arc::clone(&localizer_arc));
        app.download_view.set_localizer(Arc::clone(&localizer_arc));
        app.settings_view.set_localizer(Arc::clone(&localizer_arc));
        app.library_view
            .set_privacy_mode(app.config.lock().unwrap().privacy_mode);

        // Load library and installed games if already authenticated
        if is_authenticated {
            app.load_library();
            app.load_installed_games();
        }

        app
    }

    fn handle_login(&mut self) {
        self.state = AppState::Library;
        self.load_library();
        self.load_installed_games();
    }

    fn load_library(&mut self) {
        if self.loading_library {
            return;
        }

        self.loading_library = true;
        self.status_message = "Loading library...".to_string();

        // Use GameManager to benefit from token auto-refresh
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        self.library_promise = Some(Promise::spawn_thread("load_library", move || {
            let rt = tokio::runtime::Runtime::new()
                .expect("Failed to create Tokio runtime for library load");
            rt.block_on(async move {
                match GameManager::new(config, auth) {
                    Ok(mut manager) => manager.list_library().await,
                    Err(e) => Err(e),
                }
            })
        }));
    }

    fn load_installed_games(&mut self) {
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        if let Ok(manager) = GameManager::new(config, auth) {
            if let Ok(games) = manager.list_installed() {
                self.installed_games = games;
                // Reset update tracking when installed set changes
                self.updates_available
                    .retain(|name, _| self.installed_games.iter().any(|g| &g.app_name == name));
                self.updates_checked.clear();
                self.update_promises.clear();
                self.start_update_checks();
            }
        }
    }

    fn start_update_checks(&mut self) {
        for game in &self.installed_games {
            if self.updates_checked.contains(&game.app_name) {
                continue;
            }

            // Avoid spawning duplicate promises for the same app
            if self
                .update_promises
                .iter()
                .any(|(name, _)| name == &game.app_name)
            {
                continue;
            }

            let app_name = game.app_name.clone();
            let app_name_for_rt = app_name.clone();
            let config = Arc::clone(&self.config);
            let auth = Arc::clone(&self.auth);
            let promise = Promise::spawn_thread("check_updates", move || {
                let rt = tokio::runtime::Runtime::new()
                    .expect("Failed to create Tokio runtime for update check");
                let config = (*config.lock().unwrap()).clone();
                let auth = (*auth.lock().unwrap()).clone();

                rt.block_on(async move {
                    match GameManager::new(config, auth) {
                        Ok(manager) => manager.check_for_updates(&app_name_for_rt).await,
                        Err(e) => Err(e),
                    }
                })
            });

            self.update_promises.push((app_name, promise));
        }
    }

    fn load_wine_options() -> Vec<(String, String)> {
        let mut options = Vec::new();
        // Empty path represents auto-detect
        options.push(("Auto-detect".to_string(), String::new()));
        // Special sentinel to trigger file picker
        options.push((
            "Browse custom path...".to_string(),
            "__custom__".to_string(),
        ));

        for entry in discover_wine_installations() {
            options.push((entry.name, entry.path.to_string_lossy().to_string()));
        }

        options
    }

    fn load_game_images(&mut self, _ctx: &egui::Context) {
        const MAX_CACHED_IMAGES: usize = 100;

        for game in &self.library_games {
            // Skip if already cached or already loading
            if self.library_view.image_cache.contains_key(&game.app_name)
                || self
                    .image_promises
                    .iter()
                    .any(|(name, _)| name == &game.app_name)
            {
                continue;
            }

            // Stop loading if cache is getting large
            if self.library_view.image_cache.len() >= MAX_CACHED_IMAGES {
                break;
            }

            if let Some(image_url) = &game.image_url {
                log::info!("Loading image for {}: {}", game.app_name, image_url);
                let app_name = game.app_name.clone();
                let app_name_for_log = app_name.clone();
                let url = image_url.clone();

                let promise = Promise::spawn_thread("load_image", move || {
                    let name = app_name_for_log.clone();
                    match reqwest::blocking::get(&url) {
                        Ok(response) => match response.bytes() {
                            Ok(bytes) => match image::load_from_memory(&bytes) {
                                Ok(img) => {
                                    let rgba = img.to_rgba8();
                                    let size = rgba.dimensions();
                                    Some((size.0 as usize, size.1 as usize, rgba.into_raw()))
                                }
                                Err(e) => {
                                    log::error!("Failed to decode image for {}: {}", name, e);
                                    None
                                }
                            },
                            Err(e) => {
                                log::error!("Failed to download image for {}: {}", name, e);
                                None
                            }
                        },
                        Err(e) => {
                            log::error!("Failed to fetch image for {}: {}", name, e);
                            None
                        }
                    }
                });

                self.image_promises.push((app_name, promise));
            }
        }
    }

    #[allow(dead_code)]
    fn enrich_game_details_background(&mut self) {
        // Enrich game details in background for games with catalog info
        for game in &self.library_games {
            // Only enrich if we have catalog info and title looks like UUID
            if let (Some(namespace), Some(catalog_id)) = (&game.namespace, &game.catalog_item_id) {
                if game.app_name.len() == 32 && game.app_name.chars().all(|c| c.is_alphanumeric()) {
                    log::info!("Starting enrichment for UUID game: {}", game.app_name);
                    let app_name = game.app_name.clone();
                    let ns = namespace.clone();
                    let cat_id = catalog_id.clone();
                    let config = Arc::clone(&self.config);
                    let auth = Arc::clone(&self.auth);

                    let app_name_for_promise = app_name.clone();
                    let promise = Promise::spawn_thread("enrich_game", move || {
                        let rt = tokio::runtime::Runtime::new()
                            .expect("Failed to create Tokio runtime for enrich");
                        let config = (*config.lock().unwrap()).clone();
                        let auth = (*auth.lock().unwrap()).clone();

                        rt.block_on(async move {
                            match GameManager::new(config, auth) {
                                Ok(mut manager) => {
                                    manager
                                        .enrich_game(&app_name_for_promise, &ns, &cat_id)
                                        .await
                                }
                                Err(e) => Err(e),
                            }
                        })
                    });

                    self.enrich_promises.push((app_name, promise));
                }
            }
        }
    }

    fn handle_install(&mut self, app_name: String) {
        // Runs installation in background and updates UI
        let config = Arc::clone(&self.config);
        let auth = Arc::clone(&self.auth);
        let download_progress = Arc::clone(&self.download_progress);
        let cancel_flag = Arc::new(AtomicBool::new(false));
        self.install_cancel_flags
            .lock()
            .unwrap()
            .insert(app_name.clone(), cancel_flag.clone());
        let mut library_view = self.library_view.clone();
        library_view.mark_installation_started(&app_name);
        self.library_view = library_view.clone();
        self.status_message = format!("Installation started for {}...", app_name);

        // Add to download view
        self.download_view.add_download(app_name.clone());

        let app_name_clone = app_name.clone();
        let app_name_for_callback = app_name.clone();
        let cancel_flag_thread = cancel_flag.clone();

        let promise = Promise::spawn_thread("install_game", move || {
            let rt =
                tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime for install");
            let config = (*config.lock().unwrap()).clone();
            let auth = (*auth.lock().unwrap()).clone();
            let dl_progress = Arc::clone(&download_progress);
            let game_name = app_name_for_callback.clone();

            // Create progress callback
            let callback: DownloadProgressCallback = Arc::new(move |progress: DlProgress| {
                if let Ok(mut map) = dl_progress.lock() {
                    map.insert(game_name.clone(), progress);
                }
            });

            rt.block_on(async move {
                match GameManager::new(config, auth) {
                    Ok(mut manager) => {
                        manager
                            .install_game_with_callback(
                                &app_name_clone,
                                Some(callback),
                                Some(cancel_flag_thread),
                            )
                            .await
                    }
                    Err(e) => Err(e),
                }
            })
        });

        self.install_promises.push((app_name, promise));
    }

    fn handle_launch(&mut self, app_name: String) {
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        // Record launch stats
        if let Ok(mut stats) = crate::stats::GameStats::load(&config, &app_name) {
            stats.record_launch();
            let _ = stats.save(&config);
        }

        match GameManager::new(config, auth) {
            Ok(manager) => match manager.launch_game(&app_name) {
                Ok(()) => {
                    self.status_message = format!("Launched {}", app_name);
                }
                Err(e) => {
                    self.status_message = format!("Failed to launch {}: {}", app_name, e);
                }
            },
            Err(e) => {
                self.status_message = format!("Error: {}", e);
            }
        }
    }

    fn handle_update(&mut self, app_name: String) {
        self.status_message = format!("Updating {}...", app_name);

        let app_name_clone = app_name.clone();
        let promise = Promise::spawn_thread("update_game", move || {
            // Use legendary CLI for updates
            let legendary = LegendaryCLI::new();
            legendary.update_game(&app_name_clone)
        });

        self.install_promises.push((app_name, promise));
    }

    fn handle_uninstall(&mut self, app_name: String) {
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        match GameManager::new(config, auth) {
            Ok(manager) => match manager.uninstall_game(&app_name) {
                Ok(()) => {
                    self.status_message = format!("Uninstalled {}", app_name);
                    self.load_installed_games();
                }
                Err(e) => {
                    self.status_message = format!("Failed to uninstall {}: {}", app_name, e);
                }
            },
            Err(e) => {
                self.status_message = format!("Error: {}", e);
            }
        }
    }

    fn handle_verify(&mut self, app_name: String) {
        let config = Arc::clone(&self.config);
        let auth = Arc::clone(&self.auth);

        self.status_message = format!("Verifying {}...", app_name);

        let app_name_clone = app_name.clone();
        let promise = Promise::spawn_thread("verify_game", move || {
            let rt =
                tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime for verify");
            let config = (*config.lock().unwrap()).clone();
            let auth = (*auth.lock().unwrap()).clone();

            rt.block_on(async move {
                match GameManager::new(config, auth) {
                    Ok(mut manager) => manager.verify_game(&app_name_clone).await,
                    Err(e) => Err(e),
                }
            })
        });

        self.verify_promises.push((app_name, promise));
    }

    fn handle_repair(&mut self, app_name: String) {
        let config = Arc::clone(&self.config);
        let auth = Arc::clone(&self.auth);
        let download_progress = Arc::clone(&self.download_progress);

        self.status_message = format!("Repairing {}...", app_name);
        self.download_view.add_download(app_name.clone());

        let app_name_clone = app_name.clone();
        let app_name_for_callback = app_name.clone();

        let promise = Promise::spawn_thread("repair_game", move || {
            let rt =
                tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime for repair");
            let config = (*config.lock().unwrap()).clone();
            let auth = (*auth.lock().unwrap()).clone();
            let dl_progress = Arc::clone(&download_progress);
            let game_name = app_name_for_callback.clone();

            // Create progress callback
            let callback = Arc::new(move |progress: DlProgress| {
                if let Ok(mut map) = dl_progress.lock() {
                    map.insert(game_name.clone(), progress);
                }
            });

            rt.block_on(async move {
                match GameManager::new(config, auth) {
                    Ok(mut manager) => manager.repair_game(&app_name_clone, Some(callback)).await,
                    Err(e) => Err(e),
                }
            })
        });

        self.install_promises.push((app_name, promise));
    }

    fn handle_set_wine(&mut self, app_name: String, wine_path: Option<String>) {
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        match GameManager::new(config, auth) {
            Ok(manager) => match manager.set_game_wine(&app_name, wine_path.clone()) {
                Ok(()) => {
                    self.status_message = if let Some(path) = wine_path {
                        format!("Wine/Proton set for {} -> {}", app_name, path)
                    } else {
                        format!("Wine/Proton reset to auto for {}", app_name)
                    };
                    self.load_installed_games();
                }
                Err(e) => {
                    self.status_message = format!("Failed to set Wine/Proton: {}", e);
                }
            },
            Err(e) => {
                self.status_message = format!("Error: {}", e);
            }
        }
    }

    fn handle_toggle_cloud_save(&mut self, app_name: String, enabled: bool) {
        let config = (*self.config.lock().unwrap()).clone();
        let auth = (*self.auth.lock().unwrap()).clone();

        match GameManager::new(config, auth) {
            Ok(manager) => match manager.set_cloud_save_enabled(&app_name, enabled) {
                Ok(()) => {
                    self.status_message = format!(
                        "Cloud saves {} for {}",
                        if enabled { "enabled" } else { "disabled" },
                        app_name
                    );
                    self.load_installed_games();
                }
                Err(e) => {
                    self.status_message = format!("Failed to update cloud saves: {}", e);
                }
            },
            Err(e) => {
                self.status_message = format!("Error: {}", e);
            }
        }
    }

    fn save_settings(&mut self, ctx: &egui::Context) {
        if let Ok(mut config) = self.config.lock() {
            // Update config with settings from UI
            config.auto_update = self.settings_view.auto_update;
            config.minimize_to_tray = self.settings_view.start_minimized;
            config.close_to_tray = self.settings_view.close_to_tray;
            config.language = self.settings_view.language.clone();
            config.theme = self.settings_view.theme.clone();
            config.max_concurrent_downloads = self.settings_view.max_concurrent_downloads as u32;
            config.download_threads = self.settings_view.download_threads as u32;
            config.enable_bandwidth_limit = self.settings_view.bandwidth_limit_enabled;
            config.bandwidth_limit_mbps = self.settings_view.bandwidth_limit_mbps as u32;
            config.cdn_region = self.settings_view.cdn_region.clone();
            // Wine settings not fully mapped yet
            config.enable_dxvk = self.settings_view.dxvk_enabled;
            config.enable_esync = self.settings_view.esync_enabled;
            config.enable_fsync = false; // Not in SettingsView yet
            config.log_level = self.settings_view.log_level.to_lowercase();
            config.log_to_file = self.settings_view.log_to_file;
            config.enable_crash_reporting = self.settings_view.crash_reporting;
            config.privacy_mode = self.settings_view.privacy_mode;
            config.telemetry_opt_in = self.settings_view.enable_telemetry;
            config.disable_telemetry = !self.settings_view.enable_telemetry;

            // Apply theme change immediately
            let theme = match config.theme.as_str() {
                "Dark" => styles::Theme::Dark,
                "Light" => styles::Theme::Light,
                _ => styles::Theme::Epic,
            };
            theme.apply(ctx);

            // Apply language change immediately
            let language = match config.language.as_str() {
                "it" => Language::Italian,
                "fr" => Language::French,
                "de" => Language::German,
                "es" => Language::Spanish,
                _ => Language::English,
            };
            self.localizer.set_language(language);

            // Update localizer in all views
            let localizer_arc = Arc::new(self.localizer.clone());
            self.library_view.set_localizer(Arc::clone(&localizer_arc));
            self.download_view.set_localizer(Arc::clone(&localizer_arc));
            self.settings_view.set_localizer(Arc::clone(&localizer_arc));
            self.library_view.set_privacy_mode(config.privacy_mode);

            // Save to disk
            match config.save() {
                Ok(()) => {
                    self.status_message = format!("Settings saved successfully");
                }
                Err(e) => {
                    self.status_message = format!("Failed to save settings: {}", e);
                }
            }
        }
    }
}

impl eframe::App for LauncherApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // Check for library loading completion
        if let Some(promise) = &self.library_promise {
            if let Some(result) = promise.ready() {
                match result {
                    Ok(games) => {
                        self.library_games = games.clone();
                        self.status_message = "Library loaded successfully".to_string();

                        // Download images for games that have image URLs
                        self.load_game_images(ctx);
                    }
                    Err(e) => {
                        self.status_message = format!("Failed to load library: {}", e);
                    }
                }
                self.loading_library = false;
                self.library_promise = None;
            }
        }

        egui::TopBottomPanel::top("top_panel")
            .frame(
                egui::Frame::NONE
                    .fill(egui::Color32::from_rgb(22, 24, 28))
                    .inner_margin(egui::Margin::symmetric(20, 15)),
            )
            .show(ctx, |ui| {
                let mut logout_requested = false;
                let mut nav_button = None;
                let is_authenticated = !matches!(self.state, AppState::Login);
                let current_view = match self.state {
                    AppState::Library => super::components::header::NavButton::Library,
                    AppState::Store => super::components::header::NavButton::Library,
                    AppState::Downloads => super::components::header::NavButton::Downloads,
                    AppState::Settings => super::components::header::NavButton::Settings,
                    AppState::Login => super::components::header::NavButton::Library,
                };
                Header::show(
                    ui,
                    is_authenticated,
                    current_view,
                    &mut nav_button,
                    &mut logout_requested,
                    self.download_progress.lock().map(|m| m.len()).unwrap_or(0),
                );

                if logout_requested {
                    if let Ok(mut auth) = self.auth.lock() {
                        let _ = auth.logout();
                    }
                    self.state = AppState::Login;
                    self.library_games.clear();
                    self.installed_games.clear();
                }

                if let Some(nav) = nav_button {
                    self.state = match nav {
                        super::components::header::NavButton::Library => AppState::Library,
                        super::components::header::NavButton::Downloads => AppState::Downloads,
                        super::components::header::NavButton::Settings => AppState::Settings,
                    };
                }
            });

        // Sidebar panel
        if !matches!(self.state, AppState::Login) {
            egui::SidePanel::left("sidebar")
                .resizable(false)
                .default_width(if self.sidebar_state.collapsed { 60.0 } else { 240.0 })
                .width_range(60.0..=240.0)
                .show(ctx, |ui| {
                    if let Some(selected_item) = super::components::Sidebar::show(
                        ui,
                        &mut self.sidebar_state,
                        ui.available_height(),
                    ) {
                        self.state = match selected_item {
                            super::components::SidebarItem::Library => AppState::Library,
                            super::components::SidebarItem::Store => AppState::Store,
                            super::components::SidebarItem::Downloads => AppState::Downloads,
                            super::components::SidebarItem::Settings => AppState::Settings,
                            _ => self.state.clone(), // Other items not yet implemented
                        };
                    }
                });
        }

        egui::CentralPanel::default().show(ctx, |ui| {
            match self.state {
                AppState::Login => {
                    if self.auth_view.ui(ui, &mut self.auth.lock().unwrap()) {
                        self.handle_login();
                    }
                }
                AppState::Library => {
                    if let Some(action) = self.library_view.ui(
                        ui,
                        &self.library_games,
                        &self.installed_games,
                        &self.updates_available,
                        &self.wine_options,
                    ) {
                        match action {
                            LibraryAction::Install(app_name) => {
                                self.handle_install(app_name);
                            }
                            LibraryAction::Launch(app_name) => {
                                self.handle_launch(app_name);
                            }
                            LibraryAction::Update(app_name) => {
                                self.handle_update(app_name);
                            }
                            LibraryAction::Uninstall(app_name) => {
                                self.handle_uninstall(app_name);
                            }
                            LibraryAction::Verify(app_name) => {
                                self.handle_verify(app_name);
                            }
                            LibraryAction::Repair(app_name) => {
                                self.handle_repair(app_name);
                            }
                            LibraryAction::SetWine(app_name, wine_path) => {
                                self.handle_set_wine(app_name, wine_path);
                            }
                            LibraryAction::ToggleCloudSave(app_name, enabled) => {
                                self.handle_toggle_cloud_save(app_name, enabled);
                            }
                        }
                    }
                }
                AppState::Downloads => {
                    // Update download view with current progress
                    if let Ok(progress_map) = self.download_progress.lock() {
                        for (game_name, progress) in progress_map.iter() {
                            self.download_view
                                .update_progress(game_name, progress.clone());
                        }
                    }

                    if let Some(action) = self.download_view.show(ui) {
                        match action {
                            super::download_view::DownloadAction::Cancel(app_name) => {
                                if let Some(flag) = self
                                    .install_cancel_flags
                                    .lock()
                                    .unwrap()
                                    .get(&app_name)
                                    .cloned()
                                {
                                    flag.store(true, Ordering::Relaxed);
                                    self.status_message =
                                        format!("Cancelling download for {}...", app_name);
                                } else {
                                    self.status_message = format!(
                                        "No active download flag found for {}, unable to cancel",
                                        app_name
                                    );
                                }
                            }
                        }
                    }
                }
                AppState::Settings => {
                    if let Some(action) = self.settings_view.show(ui) {
                        match action {
                            SettingsAction::Save => {
                                self.save_settings(ctx);
                            }
                            SettingsAction::ResetDefaults => {
                                let default_config = Config::default();
                                self.settings_view.auto_update = default_config.auto_update;
                                self.settings_view.start_minimized =
                                    default_config.minimize_to_tray;
                                self.settings_view.close_to_tray = default_config.close_to_tray;
                                self.settings_view.language = default_config.language;
                                self.settings_view.theme = default_config.theme;
                                self.settings_view.max_concurrent_downloads =
                                    default_config.max_concurrent_downloads as usize;
                                self.settings_view.download_threads =
                                    default_config.download_threads as usize;
                                self.settings_view.bandwidth_limit_enabled =
                                    default_config.enable_bandwidth_limit;
                                self.settings_view.bandwidth_limit_mbps =
                                    default_config.bandwidth_limit_mbps as f32;
                                self.settings_view.cdn_region = default_config.cdn_region;
                                self.settings_view.dxvk_enabled = default_config.enable_dxvk;
                                self.settings_view.esync_enabled = default_config.enable_esync;
                                self.settings_view.log_level = default_config.log_level;
                                self.settings_view.enable_telemetry =
                                    !default_config.disable_telemetry;
                                self.settings_view.log_to_file = default_config.log_to_file;
                                self.settings_view.crash_reporting =
                                    default_config.enable_crash_reporting;
                                self.settings_view.privacy_mode = default_config.privacy_mode;
                                self.status_message = "Settings reset to defaults".to_string();
                            }
                            SettingsAction::Close => {
                                self.state = AppState::Library;
                            }
                        }
                    }
                }
                AppState::Store => {
                    if let Some(app_name) = self.store_view.show(ui, &self.library_games) {
                        self.handle_install(app_name);
                    }
                }
            }

            // Status bar at bottom using StatusBar component
            let mut clear_status = false;
            StatusBar::show(ui, &self.status_message, &mut clear_status);
            if clear_status {
                self.status_message.clear();
            }
        });

        // Handle installation completion without mutating self during iteration
        let mut completed: Vec<(usize, String, Option<String>)> = Vec::new();
        for (idx, (app_name, p)) in self.install_promises.iter().enumerate() {
            if let Some(result) = p.ready() {
                match result {
                    Ok(()) => completed.push((idx, app_name.clone(), None)),
                    Err(e) => completed.push((idx, app_name.clone(), Some(format!("{}", e)))),
                }
            }
        }
        let mut need_reload_installed = false;
        // Process completed installations
        for (idx, app_name, maybe_err) in completed.into_iter().rev() {
            let _ = self.install_promises.remove(idx);
            // Clean up cancellation flag
            if let Ok(mut flags) = self.install_cancel_flags.lock() {
                flags.remove(&app_name);
            }
            match maybe_err {
                None => {
                    self.status_message = format!("Installation completed for {}", app_name);
                    self.library_view.mark_installation_complete(&app_name);
                    // Remove from download view
                    self.download_view.remove_download(&app_name);
                    // Clean up progress tracking
                    if let Ok(mut map) = self.download_progress.lock() {
                        map.remove(&app_name);
                    }
                    need_reload_installed = true;
                }
                Some(err) => {
                    self.status_message = format!("Installation failed for {}: {}", app_name, err);
                    self.library_view.mark_installation_complete(&app_name);
                    // Remove from download view even on error
                    self.download_view.remove_download(&app_name);
                    // Clean up progress tracking
                    if let Ok(mut map) = self.download_progress.lock() {
                        map.remove(&app_name);
                    }
                }
            }
        }
        if need_reload_installed {
            self.load_installed_games();
        }

        // Handle verification completion
        let mut verified: Vec<(usize, String, Option<String>)> = Vec::new();
        for (idx, (app_name, p)) in self.verify_promises.iter().enumerate() {
            if let Some(result) = p.ready() {
                match result {
                    Ok(corrupted_files) => {
                        if corrupted_files.is_empty() {
                            verified.push((idx, app_name.clone(), None));
                        } else {
                            let msg = format!(
                                "Found {} corrupted file(s): {}",
                                corrupted_files.len(),
                                corrupted_files.join(", ")
                            );
                            verified.push((idx, app_name.clone(), Some(msg)));
                        }
                    }
                    Err(e) => verified.push((
                        idx,
                        app_name.clone(),
                        Some(format!("Verification failed: {}", e)),
                    )),
                }
            }
        }
        for (idx, app_name, maybe_msg) in verified.into_iter().rev() {
            let _ = self.verify_promises.remove(idx);
            match maybe_msg {
                None => {
                    self.status_message =
                        format!("{} - All files verified successfully ✓", app_name);
                }
                Some(msg) => {
                    self.status_message = format!("{} - {}", app_name, msg);
                }
            }
        }

        // Handle game enrichment completion
        let mut enriched: Vec<(usize, String, Option<Game>)> = Vec::new();
        for (idx, (app_name, p)) in self.enrich_promises.iter().enumerate() {
            if let Some(result) = p.ready() {
                match result {
                    Ok(game) => enriched.push((idx, app_name.clone(), Some(game.clone()))),
                    Err(e) => {
                        log::debug!("Failed to enrich {}: {}", app_name, e);
                        enriched.push((idx, app_name.clone(), None));
                    }
                }
            }
        }
        for (idx, app_name, maybe_game) in enriched.into_iter().rev() {
            let _ = self.enrich_promises.remove(idx);
            if let Some(enriched_game) = maybe_game {
                // Update the game in library_games with enriched data
                if let Some(game) = self
                    .library_games
                    .iter_mut()
                    .find(|g| g.app_name == app_name)
                {
                    game.app_title = enriched_game.app_title;
                    if enriched_game.image_url.is_some() {
                        game.image_url = enriched_game.image_url;
                    }
                    log::info!("Enriched game: {} -> {}", app_name, game.app_title);
                }
            }
        }

        // Handle image loading completion
        let mut loaded_images: Vec<(usize, String, Option<ImageData>)> = Vec::new();
        for (idx, (app_name, promise)) in self.image_promises.iter().enumerate() {
            if let Some(image_data) = promise.ready() {
                loaded_images.push((idx, app_name.clone(), image_data.clone()));
            }
        }
        for (idx, app_name, image_data) in loaded_images.into_iter().rev() {
            let _ = self.image_promises.remove(idx);
            if let Some((width, height, pixels)) = image_data {
                log::info!("Image loaded for {}: {}x{}", app_name, width, height);
                let color_image =
                    egui::ColorImage::from_rgba_unmultiplied([width, height], &pixels);
                let texture =
                    ctx.load_texture(&app_name, color_image, egui::TextureOptions::default());
                self.library_view
                    .image_cache
                    .insert(app_name.clone(), texture);
                log::info!("Texture cached for {}", app_name);
            } else {
                log::warn!("No image data received for {}", app_name);
            }
        }

        // Handle update checks completion
        let mut update_done: Vec<(usize, String, std::result::Result<Option<String>, String>)> =
            Vec::new();
        for (idx, (app_name, p)) in self.update_promises.iter().enumerate() {
            if let Some(result) = p.ready() {
                let owned: std::result::Result<Option<String>, String> = match result {
                    Ok(opt) => Ok(opt.clone()),
                    Err(e) => Err(e.to_string()),
                };
                update_done.push((idx, app_name.clone(), owned));
            }
        }
        for (idx, app_name, result) in update_done.into_iter().rev() {
            let _ = self.update_promises.remove(idx);
            self.updates_checked.insert(app_name.clone());
            match result {
                Ok(Some(version)) => {
                    self.updates_available
                        .insert(app_name.clone(), version.clone());
                    self.status_message = format!("Update available for {}: {}", app_name, version);
                }
                Ok(None) => {
                    self.updates_available.remove(&app_name);
                }
                Err(err_msg) => {
                    log::warn!("Update check failed for {}: {}", app_name, err_msg);
                }
            }
        }

        // Request repaint for animations/updates
        ctx.request_repaint_after(std::time::Duration::from_millis(100));
    }
}