epik/games/

mod.rs

use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;

use crate::api::Game;
use crate::downloader::{DownloadManager, DownloadProgress};
use crate::launcher::{GameLauncher, LaunchConfigBuilder};
use serde_json::Value;
use sysinfo::Disks;
// Actually Game is in api.
// We need LegendaryClient.
use crate::auth::AuthManager;
use crate::config::Config;
use crate::legendary::LegendaryClient;
use crate::{Error, Result};

pub mod advanced;
pub mod dlc;
pub mod organization;
pub use advanced::{AdvancedGameManager, GameConfigProfile, Mod, MoveStatus, SaveGameBackup};
pub use dlc::{DlcBundle, DlcInfo, DlcInstallationStatus, DlcManager, DlcOwnership};
pub use organization::{
    AdvancedFilter, GameCollection, GameOrganization, GameTag, SortCriteria, ViewMode,
};

// Callback type for download progress updates
// Useful for UI to track installation progress in real-time
pub type DownloadProgressCallback = std::sync::Arc<dyn Fn(DownloadProgress) + Send + Sync>;

// Cloud save synchronization status
#[derive(Debug, Clone)]
pub struct CloudSaveStatus {
    pub enabled: bool,
    pub last_sync: Option<chrono::DateTime<chrono::Utc>>,
    pub has_local_saves: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InstalledGame {
    pub app_name: String,
    pub app_title: String,
    pub app_version: String,
    pub install_path: PathBuf,
    pub executable: String,
    #[serde(default)]
    pub wine_executable: Option<String>,
    #[serde(default)]
    pub cloud_save_enabled: bool,
    #[serde(default)]
    pub last_cloud_sync: Option<String>,
}

impl InstalledGame {
    pub fn save(&self, config: &Config) -> Result<()> {
        let games_dir = Self::installed_games_dir(config)?;
        fs::create_dir_all(&games_dir)?;

        let game_file = games_dir.join(format!("{}.json", self.app_name));
        let contents = serde_json::to_string_pretty(self)?;
        fs::write(&game_file, contents)?;

        Ok(())
    }

    pub fn load(config: &Config, app_name: &str) -> Result<Self> {
        let games_dir = Self::installed_games_dir(config)?;
        let game_file = games_dir.join(format!("{}.json", app_name));

        if !game_file.exists() {
            return Err(Error::GameNotFound(app_name.to_string()));
        }

        let contents = fs::read_to_string(&game_file)?;
        Ok(serde_json::from_str(&contents)?)
    }

    pub fn list_installed(config: &Config) -> Result<Vec<Self>> {
        let games_dir = Self::installed_games_dir(config)?;

        if !games_dir.exists() {
            return Ok(vec![]);
        }

        let mut games = Vec::new();

        for entry in fs::read_dir(&games_dir)? {
            let entry = entry?;
            let path = entry.path();

            if path.extension().and_then(|s| s.to_str()) == Some("json") {
                if let Ok(contents) = fs::read_to_string(&path) {
                    if let Ok(game) = serde_json::from_str::<InstalledGame>(&contents) {
                        games.push(game);
                    }
                }
            }
        }

        Ok(games)
    }

    pub fn delete(&self, config: &Config) -> Result<()> {
        let games_dir = Self::installed_games_dir(config)?;
        let game_file = games_dir.join(format!("{}.json", self.app_name));

        if game_file.exists() {
            fs::remove_file(&game_file)?;
        }

        Ok(())
    }

    fn installed_games_dir(_config: &Config) -> Result<PathBuf> {
        let data_dir = Config::data_dir()?;
        Ok(data_dir.join("installed"))
    }
}

pub struct GameManager {
    config: Config,
    auth: AuthManager,
    client: LegendaryClient,
}

impl GameManager {
    pub fn new(config: Config, auth: AuthManager) -> Result<Self> {
        let client = LegendaryClient::new()?;
        Ok(Self {
            config,
            auth,
            client,
        })
    }

    async fn ensure_valid_token(&mut self) -> Result<crate::auth::AuthToken> {
        let stored_token = self
            .auth
            .get_stored_token()
            .ok_or(Error::NotAuthenticated)?;

        if !self.client.resume_session(stored_token).await {
            return Err(Error::Auth("Session invalid or expired".to_string()));
        }

        // Get the valid token (LegendaryClient maintains it)
        let token = self.client.get_token()?;
        // Update auth manager if it changed
        self.auth.set_token(token.clone())?;

        Ok(token)
    }

    pub async fn list_library(&mut self) -> Result<Vec<Game>> {
        let _token = self.ensure_valid_token().await?;
        self.client.get_games().await
    }

    pub async fn enrich_game(
        &mut self,
        app_name: &str,
        namespace: &str,
        catalog_item_id: &str,
    ) -> Result<Game> {
        let token = self.ensure_valid_token().await?;
        Ok(self
            .client
            .enrich_game_details(&token, app_name, namespace, catalog_item_id)
            .await)
    }

    pub fn list_installed(&self) -> Result<Vec<InstalledGame>> {
        InstalledGame::list_installed(&self.config)
    }

    pub async fn install_game(&mut self, app_name: &str) -> Result<()> {
        self.install_game_with_callback(app_name, None, None).await
    }

    pub async fn install_game_with_callback(
        &mut self,
        app_name: &str,
        progress_callback: Option<DownloadProgressCallback>,
        cancel_flag: Option<Arc<AtomicBool>>,
    ) -> Result<()> {
        let token = self.ensure_valid_token().await?;

        log::info!("Starting installation for game: {}", app_name);

        // Download and parse game manifest
        log::info!("Downloading game manifest...");
        let manifest = self.client.download_manifest(&token, app_name).await?;

        // Check available disk space
        let install_dir = self.config.install_dir.clone(); // Clone necessary for blocking task if needed, but here we invoke sync logic
        let required_space = manifest.build_size;

        let disks = Disks::new_with_refreshed_list();
        // Find best fit disk or default to first one that contains the path
        let mut checked = false;
        // Simple heuristic: find mount point that install_dir starts with
        for disk in &disks {
            if install_dir.starts_with(disk.mount_point()) {
                if disk.available_space() < required_space {
                    return Err(Error::Other(format!(
                        "Insufficient disk space. Required: {} bytes, Available: {} bytes",
                        required_space,
                        disk.available_space()
                    )));
                }
                checked = true;
                break;
            }
        }

        // If path not found in mount points (e.g. relative path resolution issue), check root or warn?
        // Fallback: Check if install_dir exists and check its metadata, or just skip if complex.
        // For now, if not checked, we might assume it's OK or check specific common paths.
        if !checked && !disks.is_empty() {
            // Fallback to checking the first disk (often root) if we can't determine mount point mapping
            // This is imperfect but better than nothing for a simple implementation.
            // Or better: try to canonicalize path.
            if let Ok(canon) = install_dir.canonicalize() {
                for disk in &disks {
                    if canon.starts_with(disk.mount_point()) {
                        if disk.available_space() < required_space {
                            return Err(Error::Other(format!(
                                "Insufficient disk space. Required: {} bytes, Available: {} bytes",
                                required_space,
                                disk.available_space()
                            )));
                        }
                        break;
                    }
                }
            }
        }

        log::info!("Manifest downloaded: version {}", manifest.app_version);
        log::info!("Manifest version: {}", manifest.app_version);
        log::info!("Build size: {} bytes", manifest.build_size);
        log::info!("Files to download: {}", manifest.file_list.len());

        // Create install directory
        let install_path = self.config.install_dir.join(app_name);
        fs::create_dir_all(&install_path)?;

        log::info!("Created install directory: {:?}", install_path);

        // Download game files using DownloadManager
        if !manifest.file_list.is_empty() {
            log::info!("Downloading game files...");

            let cache_dir = Config::data_dir()?.join("cache").join("chunks");

            // Apply bandwidth limiting from config if enabled
            let bandwidth_limit = if self.config.enable_bandwidth_limit {
                Some(self.config.bandwidth_limit_mbps)
            } else {
                None
            };

            let download_manager =
                DownloadManager::with_bandwidth_limit(cache_dir, bandwidth_limit)?;

            let callback = progress_callback.clone();
            download_manager
                .download_game(
                    &manifest,
                    &install_path,
                    move |progress: DownloadProgress| {
                        log::info!(
                            "Progress: {}/{} files, {}/{} bytes ({:.2} MB/s)",
                            progress.downloaded_files,
                            progress.total_files,
                            progress.downloaded_bytes,
                            progress.total_bytes,
                            progress.download_speed / 1024.0 / 1024.0
                        );

                        // Call UI callback if provided
                        if let Some(ref cb) = callback {
                            cb(progress);
                        }
                    },
                    cancel_flag.clone(),
                )
                .await?;

            log::info!("✓ Game files downloaded");
        } else {
            log::warn!("Note: Manifest has no files to download.");
            log::info!("Creating installation record with manifest data...");
        }

        // Create a minimal launcher/executable so the game can be launched.
        // Normalize Windows-style separators in manifests to platform paths.
        let launcher_rel_path = Self::normalize_launch_path(&manifest.launch_exe);
        let launcher_path = install_path.join(&launcher_rel_path);

        if let Some(parent) = launcher_path.parent() {
            fs::create_dir_all(parent)?;
        }

        // Only create a placeholder if the file was not provided by the download
        if !launcher_path.exists() {
            #[cfg(target_os = "windows")]
            {
                let mut bat_contents = String::new();
                bat_contents.push_str("@echo off\r\n");
                bat_contents.push_str(&format!("echo Running %{}%...\r\n", app_name));
                bat_contents.push_str("echo This is a placeholder launcher generated by Epik.\r\n");
                fs::write(&launcher_path, bat_contents)?;
            }

            #[cfg(not(target_os = "windows"))]
            {
                let mut sh_contents = String::new();
                sh_contents.push_str("#!/usr/bin/env bash\n\n");
                sh_contents.push_str(&format!("echo \"Running {}...\"\n", app_name));
                sh_contents
                    .push_str("echo \"This is a placeholder launcher generated by Epik.\"\n");
                sh_contents.push_str("echo \"Close this window to exit.\"\n");
                sh_contents.push_str("sleep 1\n");
                fs::write(&launcher_path, sh_contents)?;
            }
        }

        // Ensure the launcher is executable on Unix platforms
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let mut perms = fs::metadata(&launcher_path)?.permissions();
            perms.set_mode(0o755);
            fs::set_permissions(&launcher_path, perms)?;
        }

        // Create installed game entry with manifest data
        let installed_game = InstalledGame {
            app_name: app_name.to_string(),
            app_title: app_name.to_string(),
            app_version: manifest.app_version.clone(),
            install_path: install_path.clone(),
            executable: launcher_rel_path.to_string_lossy().to_string(),
            wine_executable: None,
            cloud_save_enabled: true,
            last_cloud_sync: None,
        };

        installed_game.save(&self.config)?;

        log::info!("Game installation completed for: {}", app_name);
        log::info!("✓ Installation complete!");

        Ok(())
    }

    pub fn import_game(
        &self,
        app_name: &str,
        install_path: PathBuf,
        executable: &str,
    ) -> Result<()> {
        log::info!("Importing game: {}", app_name);

        if !install_path.exists() {
            return Err(Error::Other(format!(
                "Install path does not exist: {:?}",
                install_path
            )));
        }

        let full_exe_path = install_path.join(executable);
        if !full_exe_path.exists() {
            return Err(Error::Other(format!(
                "Executable does not exist: {:?}",
                full_exe_path
            )));
        }

        // Create installed game entry
        let installed_game = InstalledGame {
            app_name: app_name.to_string(),
            app_title: app_name.to_string(), // User can edit this later if needed
            app_version: "imported".to_string(),
            install_path,
            executable: executable.to_string(),
            wine_executable: None,
            cloud_save_enabled: false,
            last_cloud_sync: None,
        };

        installed_game.save(&self.config)?;

        log::info!("✓ Game imported successfully!");
        Ok(())
    }

    // Set a custom Wine/Proton executable for a game
    pub fn set_game_wine(&self, app_name: &str, wine_executable: Option<String>) -> Result<()> {
        let mut game = InstalledGame::load(&self.config, app_name)?;
        game.wine_executable = wine_executable;
        game.save(&self.config)
    }

    // Scan a directory for potential game installations
    // Returns a list of found games with their install path and detected executable
    pub fn scan_directory(&self, scan_path: &PathBuf) -> Result<Vec<(String, PathBuf, String)>> {
        let mut found_games = Vec::new();

        if !scan_path.exists() {
            return Err(Error::Other(format!(
                "Scan path does not exist: {:?}",
                scan_path
            )));
        }

        // Common executable patterns
        let exe_patterns = vec![
            ".exe", ".bat", ".sh", // Basic executables
        ];

        // Scan directory entries
        for entry in fs::read_dir(scan_path)? {
            let entry = entry?;
            let path = entry.path();

            if path.is_dir() {
                // Potential game directory
                let dir_name = path
                    .file_name()
                    .and_then(|n| n.to_str())
                    .unwrap_or("")
                    .to_string();

                // Look for executables in this directory
                if let Ok(files) = fs::read_dir(&path) {
                    for file_entry in files {
                        if let Ok(file) = file_entry {
                            let file_path = file.path();
                            if file_path.is_file() {
                                let file_name =
                                    file_path.file_name().and_then(|n| n.to_str()).unwrap_or("");

                                // Check if it matches executable patterns
                                for pattern in &exe_patterns {
                                    if file_name.ends_with(pattern) {
                                        let relative_exe = file_path
                                            .strip_prefix(&path)
                                            .unwrap_or(&file_path)
                                            .to_str()
                                            .unwrap_or(file_name)
                                            .to_string();

                                        found_games.push((
                                            dir_name.clone(),
                                            path.clone(),
                                            relative_exe,
                                        ));
                                        break; // Found one, move to next directory
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        log::info!(
            "Found {} potential games in {:?}",
            found_games.len(),
            scan_path
        );
        Ok(found_games)
    }

    // Scan common Epic/Legendary install locations
    pub fn scan_common_locations(&self) -> Result<Vec<(String, PathBuf, String)>> {
        let mut all_found = Vec::new();

        // Common locations to check
        let common_paths = vec![
            // Epic Games Launcher default
            PathBuf::from("/opt/EpicGames"),
            PathBuf::from(format!(
                "{}/.wine/drive_c/Program Files/Epic Games",
                std::env::var("HOME").unwrap_or_default()
            )),
            // Legendary default
            PathBuf::from(format!(
                "{}/.legendary/installed",
                std::env::var("HOME").unwrap_or_default()
            )),
            // Heroic Games Launcher
            PathBuf::from(format!(
                "{}/Games/Heroic",
                std::env::var("HOME").unwrap_or_default()
            )),
            // Custom install dir from config
            self.config.install_dir.clone(),
        ];

        for path in common_paths {
            if path.exists() {
                if let Ok(mut games) = self.scan_directory(&path) {
                    all_found.append(&mut games);
                }
            }
        }

        Ok(all_found)
    }

    // Verify game files integrity against manifest
    pub async fn verify_game(&mut self, app_name: &str) -> Result<Vec<String>> {
        let token = self.ensure_valid_token().await?;
        let game = InstalledGame::load(&self.config, app_name)?;

        log::info!("Verifying game files for: {}", app_name);

        // Download manifest to verify against
        let manifest = self.client.download_manifest(&token, app_name).await?;

        let mut corrupted_files = Vec::new();

        // Check each file in manifest
        for file_manifest in &manifest.file_list {
            let file_path = game.install_path.join(&file_manifest.filename);

            if !file_path.exists() {
                log::warn!("Missing file: {}", file_manifest.filename);
                corrupted_files.push(file_manifest.filename.clone());
                continue;
            }

            // Verify file hash
            match fs::read(&file_path) {
                Ok(file_data) => {
                    use sha2::{Digest, Sha256};
                    let mut hasher = Sha256::new();
                    hasher.update(&file_data);
                    let hash = hasher.finalize();

                    if hash.as_slice() != file_manifest.file_hash.as_slice() {
                        log::warn!("Corrupted file: {}", file_manifest.filename);
                        corrupted_files.push(file_manifest.filename.clone());
                    }
                }
                Err(e) => {
                    log::error!("Failed to read file {}: {}", file_manifest.filename, e);
                    corrupted_files.push(file_manifest.filename.clone());
                }
            }
        }

        if corrupted_files.is_empty() {
            log::info!("✓ All files verified successfully!");
        } else {
            log::warn!("Found {} corrupted/missing files", corrupted_files.len());
        }

        Ok(corrupted_files)
    }

    // Repair game by re-downloading corrupted files
    pub async fn repair_game(
        &mut self,
        app_name: &str,
        progress_callback: Option<DownloadProgressCallback>,
    ) -> Result<()> {
        log::info!("Starting repair for: {}", app_name);

        // First verify to find corrupted files
        let corrupted_files = self.verify_game(app_name).await?;

        if corrupted_files.is_empty() {
            log::info!("No files need repair");
            return Ok(());
        }

        log::info!("Repairing {} files...", corrupted_files.len());

        // Get token and manifest
        let token = self.ensure_valid_token().await?;
        let manifest = self.client.download_manifest(&token, app_name).await?;
        let game = InstalledGame::load(&self.config, app_name)?;

        // Filter manifest to only include corrupted files
        let mut repair_manifest = manifest.clone();
        repair_manifest
            .file_list
            .retain(|f| corrupted_files.contains(&f.filename));

        // Re-download corrupted files
        let cache_dir = Config::data_dir()?.join("cache").join("chunks");

        // Apply bandwidth limiting from config if enabled
        let bandwidth_limit = if self.config.enable_bandwidth_limit {
            Some(self.config.bandwidth_limit_mbps)
        } else {
            None
        };

        let download_manager =
            crate::downloader::DownloadManager::with_bandwidth_limit(cache_dir, bandwidth_limit)?;

        let callback = progress_callback.clone();
        download_manager
            .download_game(
                &repair_manifest,
                &game.install_path,
                move |progress| {
                    log::info!(
                        "Repair progress: {}/{} files",
                        progress.downloaded_files,
                        progress.total_files
                    );

                    if let Some(ref cb) = callback {
                        cb(progress);
                    }
                },
                None,
            )
            .await?;

        log::info!("✓ Repair complete!");
        Ok(())
    }

    pub fn launch_game(&self, app_name: &str) -> Result<()> {
        log::info!("Starting launch_game for: {}", app_name);

        let mut game = InstalledGame::load(&self.config, app_name)?;
        log::info!("Loaded game config: {:?}", game);

        // Normalize any Windows-style separators before joining
        let executable_rel = Self::normalize_launch_path(&game.executable);
        let executable_path = game.install_path.join(&executable_rel);
        log::debug!("Looking for executable at: {:?}", executable_path);

        // If the expected executable is missing, try to resolve it from Legendary metadata,
        // otherwise fall back to Legendary launch.
        if !executable_path.exists() {
            log::warn!(
                "Executable not found, attempting Legendary metadata fallback for {}",
                app_name
            );

            if let Some((resolved_path, resolved_workdir)) =
                self.legendary_resolve_install(app_name)?
            {
                log::info!("Resolved executable via Legendary: {:?}", resolved_path);
                return self.launch_resolved(app_name, &game, resolved_path, resolved_workdir);
            }

            log::warn!(
                "Legendary metadata not available, delegating to legendary launch for {}",
                app_name
            );
            return self.launch_with_legendary(app_name, &game);
        }

        log::info!("Launching game: {} ({})", game.app_title, game.app_name);
        log::debug!("Executable: {:?}", executable_path);
        log::debug!("Install path: {:?}", game.install_path);
        log::debug!("Wine executable: {:?}", game.wine_executable);

        // Detect placeholder launcher and use Legendary instead
        if Self::is_placeholder_launcher(&executable_path) {
            log::warn!(
                "Detected placeholder launcher, attempting Legendary metadata fallback for {}",
                app_name
            );

            if let Some((resolved_path, resolved_workdir)) =
                self.legendary_resolve_install(app_name)?
            {
                log::info!("Resolved executable via Legendary: {:?}", resolved_path);
                return self.launch_resolved(app_name, &game, resolved_path, resolved_workdir);
            }

            log::warn!(
                "Legendary metadata not available, delegating to legendary launch for {}",
                app_name
            );
            return self.launch_with_legendary(app_name, &game);
        }

        // Pre-launch cloud save sync if enabled
        if game.cloud_save_enabled {
            log::info!("Pre-launch cloud save sync...");
            let rt = tokio::runtime::Runtime::new()?;
            if let Err(e) = rt.block_on(self.sync_cloud_saves_safe(app_name)) {
                log::warn!("Cloud save sync failed: {}", e);
            } else {
                game.last_cloud_sync = Some(chrono::Utc::now().to_rfc3339());
                let _ = game.save(&self.config);
            }
        }

        // Determine if we need Wine (on Linux for Windows games or explicitly set)
        let selected_wine = game
            .wine_executable
            .as_ref()
            .map(|p| std::path::PathBuf::from(p));
        let needs_wine = selected_wine.is_some()
            || (cfg!(target_os = "linux") && Self::is_windows_executable(&executable_path));

        log::info!("Needs Wine: {} (selected: {:?})", needs_wine, selected_wine);

        let launch_config = if needs_wine {
            // Setup Wine/Proton
            let data_dir = Config::data_dir()?;
            let wine_prefix = data_dir.join("prefixes").join(app_name);
            log::info!("Creating Wine prefix at: {:?}", wine_prefix);
            fs::create_dir_all(&wine_prefix)?;

            LaunchConfigBuilder::new(executable_path, game.install_path.clone())
                .with_wine(selected_wine, Some(wine_prefix))
                .build()
        } else {
            LaunchConfigBuilder::new(executable_path, game.install_path.clone()).build()
        };

        log::info!("Launching game with config: {:?}", launch_config);
        let launcher = GameLauncher::new(launch_config);
        let mut child = launcher.launch()?;

        log::info!("Game process started successfully");

        // Post-launch cloud save upload (wait for game exit)
        if game.cloud_save_enabled {
            let app_name_clone = app_name.to_string();
            let config_clone = self.config.clone();
            let auth_clone = self.auth.clone();
            std::thread::spawn(move || {
                // Wait for game to exit
                if let Err(e) = child.wait() {
                    log::error!("Failed waiting for game process: {}", e);
                    return;
                }
                log::info!("Post-launch cloud save upload...");
                let rt = match tokio::runtime::Runtime::new() {
                    Ok(rt) => rt,
                    Err(e) => {
                        log::error!("Failed to create runtime for cloud save upload: {}", e);
                        return;
                    }
                };
                match GameManager::new(config_clone, auth_clone) {
                    Ok(manager) => {
                        if let Err(e) = rt.block_on(manager.upload_cloud_saves(&app_name_clone)) {
                            log::warn!("Cloud save upload failed: {}", e);
                        } else {
                            log::info!("Cloud saves uploaded successfully");
                        }
                    }
                    Err(e) => log::error!("Failed to create GameManager: {}", e),
                }
            });
        }

        Ok(())
    }

    pub fn uninstall_game(&self, app_name: &str) -> Result<()> {
        let game = InstalledGame::load(&self.config, app_name)?;

        // Remove game files
        if game.install_path.exists() {
            fs::remove_dir_all(&game.install_path)?;
        }

        // Remove metadata
        game.delete(&self.config)?;

        log::info!("Uninstalled game: {} ({})", game.app_title, game.app_name);

        Ok(())
    }

    // Convert Windows-style paths in manifests (with backslashes) to platform separators
    fn normalize_launch_path(path: &str) -> PathBuf {
        // PathBuf accepts forward slashes on all platforms; replace backslashes so Unix resolves paths
        PathBuf::from(path.replace('\\', "/"))
    }

    // Detect our generated placeholder script to avoid launching a no-op
    fn is_placeholder_launcher(path: &PathBuf) -> bool {
        if let Ok(content) = fs::read_to_string(path) {
            return content.contains("placeholder launcher generated by Epik");
        }
        false
    }

    // Find the legendary command, checking: wrapper script -> venv bin -> PATH
    fn find_legendary_cmd() -> String {
        // Get the project root by looking at executable location
        // During development: target/debug/epik -> go to root
        // After install: /usr/local/bin/epik -> look for .venv-legendary in common locations

        let project_root = if let Ok(exe_path) = std::env::current_exe() {
            // Check if we're in a development environment (target/debug or target/release)
            if let Some(parent) = exe_path.parent() {
                if let Some(grandparent) = parent.parent() {
                    if grandparent.ends_with("target") {
                        // We're in target/{debug,release}, project root is parent of target
                        grandparent.parent().map(|p| p.to_path_buf())
                    } else {
                        // Likely an installed binary, try to find .venv-legendary
                        // Check common locations
                        let home = std::env::var("HOME").ok();
                        if let Some(h) = home {
                            Some(std::path::PathBuf::from(&h))
                        } else {
                            None
                        }
                    }
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        };

        // Try to find wrapper script in project root
        if let Some(root) = project_root {
            let wrapper = root.join("legendary");
            if wrapper.exists() {
                log::debug!("Using wrapper script: {}", wrapper.display());
                if let Some(path_str) = wrapper.to_str() {
                    return path_str.to_string();
                }
            }

            // Try venv in project root
            let venv_legendary = root.join(".venv-legendary/bin/legendary");
            if venv_legendary.exists() {
                log::debug!("Using legendary from venv: {}", venv_legendary.display());
                if let Some(path_str) = venv_legendary.to_str() {
                    return path_str.to_string();
                }
            }

            // Try Windows venv
            let venv_legendary_win = root.join(".venv-legendary/Scripts/legendary.exe");
            if venv_legendary_win.exists() {
                log::debug!(
                    "Using legendary from venv (Windows): {}",
                    venv_legendary_win.display()
                );
                if let Some(path_str) = venv_legendary_win.to_str() {
                    return path_str.to_string();
                }
            }
        }

        // Fallback: check relative paths (for backwards compatibility)
        if std::path::Path::new("./legendary").exists() {
            log::debug!("Using wrapper script: ./legendary");
            return "./legendary".to_string();
        }

        let venv_legendary = ".venv-legendary/bin/legendary";
        if std::path::Path::new(venv_legendary).exists() {
            log::debug!("Using legendary from venv: {}", venv_legendary);
            return venv_legendary.to_string();
        }

        let venv_legendary_win = ".venv-legendary/Scripts/legendary.exe";
        if std::path::Path::new(venv_legendary_win).exists() {
            log::debug!(
                "Using legendary from venv (Windows): {}",
                venv_legendary_win
            );
            return venv_legendary_win.to_string();
        }

        // Final fallback: search PATH
        log::debug!("Searching for legendary in PATH");
        "legendary".to_string()
    }

    // Configure legendary to use EPIK's config directory for synchronization
    fn configure_legendary_sync(cmd: &mut std::process::Command, _config: &Config) -> Result<()> {
        // Point legendary to EPIK's config directory so they share authentication tokens
        let config_dir = Config::config_path()?;
        if let Some(parent) = config_dir.parent() {
            log::debug!("Syncing legendary config with EPIK: {}", parent.display());
            cmd.env("LEGENDARY_CONFIG_DIR", parent);
        }
        Ok(())
    }

    // Resolve install/executable information using legendary --json output (best-effort)
    fn legendary_resolve_install(&self, app_name: &str) -> Result<Option<(PathBuf, PathBuf)>> {
        // Find legendary: wrapper script -> venv -> PATH
        let legendary_cmd = Self::find_legendary_cmd();

        // Use the correct legendary command: list or list-games
        let mut cmd = std::process::Command::new(&legendary_cmd);
        cmd.arg("list")
            .arg("--json")
            .arg("--installed")
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped());

        // Sync with EPIK's config
        Self::configure_legendary_sync(&mut cmd, &self.config)?;

        let output = match cmd.output() {
            Ok(out) => out,
            Err(e) => {
                log::debug!(
                    "Legendary CLI not available ({}), skipping metadata resolution",
                    e
                );
                return Ok(None);
            }
        };

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            log::debug!(
                "legendary list failed (status {:?}): {}",
                output.status.code(),
                stderr.trim()
            );
            return Ok(None);
        }

        let stdout = String::from_utf8_lossy(&output.stdout);
        if stdout.trim().is_empty() {
            log::warn!("legendary list returned empty output");
            return Ok(None);
        }

        // Expected structure: array of objects with app_name, install_path, executable (best-effort)
        let parsed: Value = match serde_json::from_str(stdout.trim()) {
            Ok(v) => v,
            Err(e) => {
                log::warn!("Failed to parse legendary list JSON: {}", e);
                return Ok(None);
            }
        };

        let entries = match parsed.as_array() {
            Some(arr) => arr,
            None => {
                log::warn!("legendary list JSON is not an array");
                return Ok(None);
            }
        };

        for entry in entries {
            let name = entry.get("app_name").and_then(|v| v.as_str()).unwrap_or("");
            if name != app_name {
                continue;
            }

            let install_path = entry
                .get("install_path")
                .and_then(|v| v.as_str())
                .map(PathBuf::from);

            let exe_rel = entry
                .get("executable")
                .and_then(|v| v.as_str())
                .map(|s| Self::normalize_launch_path(s));

            if let (Some(install), Some(exe_rel)) = (install_path, exe_rel) {
                let resolved = install.join(&exe_rel);
                if resolved.exists() {
                    return Ok(Some((resolved, install)));
                } else {
                    log::warn!("legendary resolved path does not exist: {:?}", resolved);
                }
            }
        }

        Ok(None)
    }

    // Launch using a resolved executable (e.g., from Legendary metadata)
    fn launch_resolved(
        &self,
        app_name: &str,
        game: &InstalledGame,
        exe_path: PathBuf,
        workdir: PathBuf,
    ) -> Result<()> {
        let needs_wine = game.wine_executable.is_some()
            || (cfg!(target_os = "linux") && Self::is_windows_executable(&exe_path));

        let mut launch_builder = LaunchConfigBuilder::new(exe_path.clone(), workdir.clone());

        if needs_wine {
            let prefix = Config::data_dir()?.join("prefixes").join(app_name);
            fs::create_dir_all(&prefix)?;
            launch_builder = launch_builder.with_wine(
                game.wine_executable.as_ref().map(|w| PathBuf::from(w)),
                Some(prefix),
            );
        }

        let launcher = GameLauncher::new(launch_builder.build());
        let mut child = launcher.launch()?;

        // Spawn cloud save upload if enabled
        if game.cloud_save_enabled {
            let app_name_clone = app_name.to_string();
            let config_clone = self.config.clone();
            let auth_clone = self.auth.clone();
            std::thread::spawn(move || {
                if let Err(e) = child.wait() {
                    log::error!("Failed waiting for game process: {}", e);
                    return;
                }
                let rt = match tokio::runtime::Runtime::new() {
                    Ok(rt) => rt,
                    Err(e) => {
                        log::error!("Failed to create runtime for cloud save upload: {}", e);
                        return;
                    }
                };
                match GameManager::new(config_clone, auth_clone) {
                    Ok(manager) => {
                        if let Err(e) = rt.block_on(manager.upload_cloud_saves(&app_name_clone)) {
                            log::warn!("Cloud save upload failed: {}", e);
                        } else {
                            log::info!("Cloud saves uploaded successfully");
                        }
                    }
                    Err(e) => log::error!("Failed to create GameManager: {}", e),
                }
            });
        }

        Ok(())
    }

    // Fallback: delegate launch to the Legendary CLI (similar to Rare's strategy)
    fn launch_with_legendary(&self, app_name: &str, game: &InstalledGame) -> Result<()> {
        log::info!("Fallback to legendary launch for {}", app_name);

        // Find legendary: wrapper script -> venv -> PATH
        let legendary_cmd = Self::find_legendary_cmd();

        // Capture output so we can surface errors to the UI/logs
        let mut cmd = std::process::Command::new(&legendary_cmd);
        cmd.arg("launch")
            .arg(app_name)
            .arg("--skip-version-check")
            .arg("--install-dir")
            .arg(&game.install_path)
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped());

        if let Some(wine) = &game.wine_executable {
            cmd.arg("--wine").arg(wine);
        }

        cmd.current_dir(&game.install_path);

        // Sync with EPIK's config
        Self::configure_legendary_sync(&mut cmd, &self.config)?;

        let output = match cmd.output() {
            Ok(out) => out,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                return Err(Error::Other(
                    "Legendary CLI not found. Please run: ./scripts/setup-legendary.sh".to_string(),
                ));
            }
            Err(e) => return Err(Error::Other(format!("Failed to run legendary: {}", e))),
        };

        let stdout = String::from_utf8_lossy(&output.stdout);
        let stderr = String::from_utf8_lossy(&output.stderr);

        if !stdout.trim().is_empty() {
            log::info!("legendary stdout: {}", stdout.trim());
        }
        if !stderr.trim().is_empty() {
            log::warn!("legendary stderr: {}", stderr.trim());
        }

        if !output.status.success() {
            return Err(Error::Other(format!(
                "Legendary launch failed (status {:?}): {}",
                output.status.code(),
                stderr.trim()
            )));
        }

        Ok(())
    }

    // Check if executable is a Windows PE file
    fn is_windows_executable(path: &PathBuf) -> bool {
        // Check file extension first
        if let Some(ext) = path.extension() {
            let ext_str = ext.to_string_lossy().to_lowercase();
            if ext_str == "exe" || ext_str == "bat" {
                return true;
            }
        }

        // Check PE header (MZ signature)
        if let Ok(mut file) = std::fs::File::open(path) {
            use std::io::Read;
            let mut buffer = [0u8; 2];
            if file.read_exact(&mut buffer).is_ok() {
                return buffer == [0x4D, 0x5A]; // "MZ" magic number
            }
        }

        false
    }

    // Check for game updates
    pub async fn check_for_updates(&self, app_name: &str) -> Result<Option<String>> {
        let token = self.auth.get_token()?;
        let game = InstalledGame::load(&self.config, app_name)?;

        log::info!(
            "Checking for updates for {} (current: {})",
            app_name,
            game.app_version
        );

        self.client
            .check_for_updates(token, app_name, &game.app_version)
            .await
    }

    // Update a game to the latest version
    pub async fn update_game(&mut self, app_name: &str) -> Result<()> {
        // TODO: Implement differential updates (download only changed files)
        // TODO: Compare old and new manifests to identify changes
        // TODO: Support update rollback in case of failure
        // TODO: Preserve user settings and save files during update
        // TODO: Show update changelog to user

        let token = self.auth.get_token()?;

        log::info!("Updating game: {}", app_name);

        // Check if update is available
        match self.check_for_updates(app_name).await? {
            Some(new_version) => {
                log::info!("Update available: {}", new_version);
                log::info!("Downloading update...");

                // Download new manifest
                let manifest = self.client.download_manifest(&token, app_name).await?;

                // Update game files (differential update would be more efficient)
                log::info!("Updating game files...");

                // Update installation record
                let mut game = InstalledGame::load(&self.config, app_name)?;
                game.app_version = manifest.app_version.clone();
                game.executable = manifest.launch_exe.clone();
                game.save(&self.config)?;

                log::info!("✓ Game updated to version {}", manifest.app_version);
                Ok(())
            }
            None => {
                log::info!("Game is already up to date");
                Ok(())
            }
        }
    }

    // Safe cloud save sync with error handling
    async fn sync_cloud_saves_safe(&self, app_name: &str) -> Result<()> {
        match self.download_cloud_saves(app_name).await {
            Ok(_) => Ok(()),
            Err(e) => {
                log::warn!("Cloud save download failed: {}", e);
                Ok(()) // Don't fail launch on cloud save errors
            }
        }
    }

    // Download cloud saves with backup and conflict resolution
    pub async fn download_cloud_saves(&self, app_name: &str) -> Result<()> {
        let token = self.auth.get_token()?;
        let game = InstalledGame::load(&self.config, app_name)?;

        log::info!("Downloading cloud saves for {}", app_name);

        let saves = self.client.get_cloud_saves(token, app_name).await?;

        if saves.is_empty() {
            log::info!("No cloud saves found");
            return Ok(());
        }

        log::info!("Found {} cloud save(s)", saves.len());

        // Create saves and backup directories
        let saves_dir = game.install_path.join("saves");
        let backup_dir = Config::data_dir()?.join("saves_backup").join(app_name);
        fs::create_dir_all(&saves_dir)?;
        fs::create_dir_all(&backup_dir)?;

        for save in saves {
            log::info!("  Downloading: {}", save.filename);

            let save_path = saves_dir.join(&save.filename);

            // Backup existing save if present
            if save_path.exists() {
                let timestamp = chrono::Utc::now().format("%Y%m%d_%H%M%S");
                let backup_path = backup_dir.join(format!("{}_{}", timestamp, save.filename));

                if let Ok(metadata) = fs::metadata(&save_path) {
                    if let Ok(modified) = metadata.modified() {
                        let local_time: chrono::DateTime<chrono::Utc> = modified.into();

                        // Compare timestamps - skip if local is newer
                        if let Ok(cloud_time) =
                            chrono::DateTime::parse_from_rfc3339(&save.uploaded_at)
                        {
                            if local_time > cloud_time.with_timezone(&chrono::Utc) {
                                log::info!("Local save is newer, keeping local version");
                                continue;
                            }
                        }
                    }
                }

                fs::copy(&save_path, &backup_path)?;
                log::info!("Backed up to: {:?}", backup_path);
            }

            let save_data = self.client.download_cloud_save(token, &save.id).await?;
            fs::write(&save_path, &save_data)?;
        }

        log::info!("✓ Cloud saves downloaded");
        Ok(())
    }

    // Upload local saves to cloud
    pub async fn upload_cloud_saves(&self, app_name: &str) -> Result<()> {
        let token = self.auth.get_token()?;
        let game = InstalledGame::load(&self.config, app_name)?;

        log::info!("Uploading cloud saves for {}", app_name);

        let saves_dir = game.install_path.join("saves");

        if !saves_dir.exists() {
            log::info!("No local saves found");
            return Ok(());
        }

        let mut uploaded = 0;

        for entry in fs::read_dir(&saves_dir)? {
            let entry = entry?;
            let path = entry.path();

            if path.is_file() {
                let save_data = fs::read(&path)?;
                log::info!(
                    "  Uploading: {}",
                    path.file_name().unwrap().to_string_lossy()
                );

                self.client
                    .upload_cloud_save(token, app_name, &save_data)
                    .await?;
                uploaded += 1;
            }
        }

        log::info!("✓ Uploaded {} save file(s)", uploaded);
        Ok(())
    }

    // Get cloud save sync status
    pub fn get_cloud_save_status(&self, app_name: &str) -> Result<CloudSaveStatus> {
        let game = InstalledGame::load(&self.config, app_name)?;

        let last_sync = game
            .last_cloud_sync
            .and_then(|s| chrono::DateTime::parse_from_rfc3339(&s).ok())
            .map(|dt| dt.with_timezone(&chrono::Utc));

        let saves_dir = game.install_path.join("saves");
        let has_local_saves = saves_dir.exists()
            && fs::read_dir(&saves_dir)
                .ok()
                .map(|mut d| d.next().is_some())
                .unwrap_or(false);

        Ok(CloudSaveStatus {
            enabled: game.cloud_save_enabled,
            last_sync,
            has_local_saves,
        })
    }

    // Toggle cloud save sync for a game
    pub fn set_cloud_save_enabled(&self, app_name: &str, enabled: bool) -> Result<()> {
        let mut game = InstalledGame::load(&self.config, app_name)?;
        game.cloud_save_enabled = enabled;
        game.save(&self.config)?;
        log::info!(
            "Cloud saves {} for {}",
            if enabled { "enabled" } else { "disabled" },
            app_name
        );
        Ok(())
    }
}