epik/games/

advanced.rs

// Advanced Game Management for v1.2.0
// Supports move installations, save game backups, config profiles, mod support

use crate::{Error, Result};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

// Game configuration profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GameConfigProfile {
    pub id: String,
    pub app_name: String,
    pub name: String,
    pub description: Option<String>,
    pub settings: std::collections::HashMap<String, String>,
    pub launch_args: String,
    pub wine_prefix: Option<String>,
    pub environment_vars: std::collections::HashMap<String, String>,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub modified_at: chrono::DateTime<chrono::Utc>,
    pub is_active: bool,
}

impl GameConfigProfile {
    pub fn new(app_name: String, name: String) -> Self {
        let now = chrono::Utc::now();
        Self {
            id: uuid::Uuid::new_v4().to_string(),
            app_name,
            name,
            description: None,
            settings: std::collections::HashMap::new(),
            launch_args: String::new(),
            wine_prefix: None,
            environment_vars: std::collections::HashMap::new(),
            created_at: now,
            modified_at: now,
            is_active: false,
        }
    }

    pub fn set_setting(&mut self, key: String, value: String) {
        self.settings.insert(key, value);
        self.modified_at = chrono::Utc::now();
    }

    pub fn set_launch_args(&mut self, args: String) {
        self.launch_args = args;
        self.modified_at = chrono::Utc::now();
    }

    pub fn set_env_var(&mut self, key: String, value: String) {
        self.environment_vars.insert(key, value);
        self.modified_at = chrono::Utc::now();
    }
}

// Backup information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SaveGameBackup {
    pub id: String,
    pub app_name: String,
    pub backup_name: String,
    pub backup_path: PathBuf,
    pub size_bytes: u64,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub is_automatic: bool,
    pub description: Option<String>,
}

impl SaveGameBackup {
    pub fn new(app_name: String, backup_path: PathBuf, is_automatic: bool) -> Result<Self> {
        let size_bytes = Self::calculate_size(&backup_path)?;
        let now = chrono::Utc::now();

        Ok(Self {
            id: uuid::Uuid::new_v4().to_string(),
            app_name,
            backup_name: format!("Backup_{}", now.format("%Y%m%d_%H%M%S")),
            backup_path,
            size_bytes,
            created_at: now,
            is_automatic,
            description: None,
        })
    }

    fn calculate_size(path: &PathBuf) -> Result<u64> {
        let mut total = 0u64;

        if path.is_file() {
            total = fs::metadata(path)?.len();
        } else if path.is_dir() {
            for entry in fs::read_dir(path)? {
                let entry = entry?;
                let metadata = entry.metadata()?;
                if metadata.is_file() {
                    total += metadata.len();
                } else if metadata.is_dir() {
                    total += Self::calculate_size(&entry.path())?;
                }
            }
        }

        Ok(total)
    }

    pub fn size_mb(&self) -> f32 {
        (self.size_bytes as f32) / (1024.0 * 1024.0)
    }

    pub fn size_gb(&self) -> f32 {
        (self.size_bytes as f32) / (1024.0 * 1024.0 * 1024.0)
    }
}

// Mod information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Mod {
    pub id: String,
    pub app_name: String,
    pub name: String,
    pub version: String,
    pub mod_path: PathBuf,
    pub enabled: bool,
    pub size_bytes: u64,
    pub installed_at: chrono::DateTime<chrono::Utc>,
}

impl Mod {
    pub fn new(app_name: String, name: String, mod_path: PathBuf) -> Result<Self> {
        let size_bytes = SaveGameBackup::calculate_size(&mod_path)?;

        Ok(Self {
            id: uuid::Uuid::new_v4().to_string(),
            app_name,
            name,
            version: "1.0".to_string(),
            mod_path,
            enabled: true,
            size_bytes,
            installed_at: chrono::Utc::now(),
        })
    }

    pub fn size_mb(&self) -> f32 {
        (self.size_bytes as f32) / (1024.0 * 1024.0)
    }
}

// Installation move operation status
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum MoveStatus {
    Pending,
    InProgress,
    Completed,
    Failed,
    Cancelled,
}

// Advanced game manager
pub struct AdvancedGameManager {
    profiles: std::collections::HashMap<String, GameConfigProfile>,
    backups: std::collections::HashMap<String, SaveGameBackup>,
    mods: std::collections::HashMap<String, Mod>,
}

impl Default for AdvancedGameManager {
    fn default() -> Self {
        Self::new()
    }
}

impl AdvancedGameManager {
    pub fn new() -> Self {
        Self {
            profiles: std::collections::HashMap::new(),
            backups: std::collections::HashMap::new(),
            mods: std::collections::HashMap::new(),
        }
    }

    // Profile management
    pub fn create_profile(&mut self, app_name: String, name: String) -> String {
        let profile = GameConfigProfile::new(app_name, name);
        let id = profile.id.clone();
        self.profiles.insert(id.clone(), profile);
        id
    }

    pub fn delete_profile(&mut self, profile_id: &str) -> Result<()> {
        if self.profiles.remove(profile_id).is_some() {
            Ok(())
        } else {
            Err(Error::Other(format!("Profile not found: {}", profile_id)))
        }
    }

    pub fn get_profile(&self, profile_id: &str) -> Option<&GameConfigProfile> {
        self.profiles.get(profile_id)
    }

    pub fn get_profile_mut(&mut self, profile_id: &str) -> Option<&mut GameConfigProfile> {
        self.profiles.get_mut(profile_id)
    }

    pub fn list_profiles_for_game(&self, app_name: &str) -> Vec<&GameConfigProfile> {
        self.profiles
            .values()
            .filter(|p| p.app_name == app_name)
            .collect()
    }

    pub fn set_active_profile(&mut self, app_name: &str, profile_id: &str) -> Result<()> {
        // Deactivate all profiles for this game
        for profile in self.profiles.values_mut() {
            if profile.app_name == app_name {
                profile.is_active = false;
            }
        }

        // Activate selected profile
        if let Some(profile) = self.profiles.get_mut(profile_id) {
            if profile.app_name == app_name {
                profile.is_active = true;
                Ok(())
            } else {
                Err(Error::Other("Profile not found for game".to_string()))
            }
        } else {
            Err(Error::Other(format!("Profile not found: {}", profile_id)))
        }
    }

    pub fn get_active_profile(&self, app_name: &str) -> Option<&GameConfigProfile> {
        self.profiles
            .values()
            .find(|p| p.app_name == app_name && p.is_active)
    }

    // Backup management
    pub fn create_backup(&mut self, backup: SaveGameBackup) -> String {
        let id = backup.id.clone();
        self.backups.insert(id.clone(), backup);
        id
    }

    pub fn delete_backup(&mut self, backup_id: &str) -> Result<()> {
        if let Some(backup) = self.backups.remove(backup_id) {
            // Delete backup file
            if backup.backup_path.exists() {
                if backup.backup_path.is_file() {
                    fs::remove_file(&backup.backup_path)?;
                } else if backup.backup_path.is_dir() {
                    fs::remove_dir_all(&backup.backup_path)?;
                }
            }
            Ok(())
        } else {
            Err(Error::Other(format!("Backup not found: {}", backup_id)))
        }
    }

    pub fn get_backup(&self, backup_id: &str) -> Option<&SaveGameBackup> {
        self.backups.get(backup_id)
    }

    pub fn list_backups_for_game(&self, app_name: &str) -> Vec<&SaveGameBackup> {
        self.backups
            .values()
            .filter(|b| b.app_name == app_name)
            .collect()
    }

    pub fn get_total_backup_size(&self, app_name: &str) -> u64 {
        self.list_backups_for_game(app_name)
            .iter()
            .map(|b| b.size_bytes)
            .sum()
    }

    // Mod management
    pub fn install_mod(&mut self, mod_info: Mod) -> Result<String> {
        let id = mod_info.id.clone();
        self.mods.insert(id.clone(), mod_info);
        Ok(id)
    }

    pub fn uninstall_mod(&mut self, mod_id: &str) -> Result<()> {
        if let Some(mod_info) = self.mods.remove(mod_id) {
            // Delete mod directory
            if mod_info.mod_path.exists() {
                fs::remove_dir_all(&mod_info.mod_path)?;
            }
            Ok(())
        } else {
            Err(Error::Other(format!("Mod not found: {}", mod_id)))
        }
    }

    pub fn get_mod(&self, mod_id: &str) -> Option<&Mod> {
        self.mods.get(mod_id)
    }

    pub fn get_mod_mut(&mut self, mod_id: &str) -> Option<&mut Mod> {
        self.mods.get_mut(mod_id)
    }

    pub fn list_mods_for_game(&self, app_name: &str) -> Vec<&Mod> {
        self.mods
            .values()
            .filter(|m| m.app_name == app_name)
            .collect()
    }

    pub fn enable_mod(&mut self, mod_id: &str) -> Result<()> {
        if let Some(mod_info) = self.mods.get_mut(mod_id) {
            mod_info.enabled = true;
            Ok(())
        } else {
            Err(Error::Other(format!("Mod not found: {}", mod_id)))
        }
    }

    pub fn disable_mod(&mut self, mod_id: &str) -> Result<()> {
        if let Some(mod_info) = self.mods.get_mut(mod_id) {
            mod_info.enabled = false;
            Ok(())
        } else {
            Err(Error::Other(format!("Mod not found: {}", mod_id)))
        }
    }

    pub fn get_enabled_mods(&self, app_name: &str) -> Vec<&Mod> {
        self.list_mods_for_game(app_name)
            .into_iter()
            .filter(|m| m.enabled)
            .collect()
    }

    pub fn get_total_mods_size(&self, app_name: &str) -> u64 {
        self.list_mods_for_game(app_name)
            .iter()
            .map(|m| m.size_bytes)
            .sum()
    }

    // Installation management
    pub async fn move_installation(
        &self,
        current_path: &PathBuf,
        new_path: &PathBuf,
    ) -> Result<()> {
        // Verify source exists
        if !current_path.exists() {
            return Err(Error::Other(format!(
                "Source path does not exist: {:?}",
                current_path
            )));
        }

        // Verify destination doesn't exist
        if new_path.exists() {
            return Err(Error::Other(format!(
                "Destination path already exists: {:?}",
                new_path
            )));
        }

        // Create destination parent directory
        if let Some(parent) = new_path.parent() {
            fs::create_dir_all(parent)?;
        }

        // Move installation
        fs::rename(current_path, new_path)?;

        Ok(())
    }

    // Create backup of saves (thread-safe async copy)
    pub async fn backup_saves(
        &mut self,
        save_path: &PathBuf,
        backup_dir: &PathBuf,
        app_name: &str,
        auto: bool,
    ) -> Result<String> {
        // Create backup directory if needed
        fs::create_dir_all(backup_dir)?;

        let backup_subdir = backup_dir.join(format!(
            "backup_{}",
            chrono::Utc::now().format("%Y%m%d_%H%M%S")
        ));
        fs::create_dir_all(&backup_subdir)?;

        // Copy save files
        copy_recursively(save_path, &backup_subdir)?;

        let backup = SaveGameBackup::new(app_name.to_string(), backup_subdir, auto)?;
        Ok(self.create_backup(backup))
    }

    // Restore saves from backup
    pub async fn restore_saves(
        &self,
        backup_id: &str,
        target_path: &PathBuf,
    ) -> Result<()> {
        if let Some(backup) = self.backups.get(backup_id) {
            // Verify target exists
            if !target_path.exists() {
                fs::create_dir_all(target_path)?;
            }

            // Copy backup to target
            copy_recursively(&backup.backup_path, target_path)?;
            Ok(())
        } else {
            Err(Error::Other(format!("Backup not found: {}", backup_id)))
        }
    }
}

// Helper function for recursive directory copy
fn copy_recursively(src: &PathBuf, dst: &PathBuf) -> Result<()> {
    fs::create_dir_all(dst)?;

    for entry in fs::read_dir(src)? {
        let entry = entry?;
        let path = entry.path();
        let file_name = entry.file_name();
        let dest_path = dst.join(file_name);

        if path.is_dir() {
            copy_recursively(&path, &dest_path)?;
        } else {
            fs::copy(&path, &dest_path)?;
        }
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_profile_creation() {
        let mut manager = AdvancedGameManager::new();
        let profile_id = manager.create_profile("game1".to_string(), "High Quality".to_string());

        let profile = manager.get_profile(&profile_id);
        assert!(profile.is_some());
        assert_eq!(profile.unwrap().name, "High Quality");
    }

    #[test]
    fn test_profile_settings() {
        let mut manager = AdvancedGameManager::new();
        let profile_id = manager.create_profile("game1".to_string(), "Profile".to_string());

        if let Some(profile) = manager.get_profile_mut(&profile_id) {
            profile.set_setting("graphics".to_string(), "ultra".to_string());
            profile.set_launch_args("--fullscreen".to_string());
        }

        let profile = manager.get_profile(&profile_id).unwrap();
        assert_eq!(profile.settings.get("graphics").unwrap(), "ultra");
        assert_eq!(profile.launch_args, "--fullscreen");
    }

    #[test]
    fn test_active_profile() {
        let mut manager = AdvancedGameManager::new();
        let profile_id1 = manager.create_profile("game1".to_string(), "Profile 1".to_string());
        let profile_id2 = manager.create_profile("game1".to_string(), "Profile 2".to_string());

        manager.set_active_profile("game1", &profile_id1).unwrap();
        assert!(manager.get_profile(&profile_id1).unwrap().is_active);

        manager.set_active_profile("game1", &profile_id2).unwrap();
        assert!(!manager.get_profile(&profile_id1).unwrap().is_active);
        assert!(manager.get_profile(&profile_id2).unwrap().is_active);
    }

    #[test]
    fn test_mod_management() {
        let mut manager = AdvancedGameManager::new();
        let mod_path = PathBuf::from("/tmp/test_mod");

        let mod_info = Mod::new(
            "game1".to_string(),
            "Test Mod".to_string(),
            mod_path,
        ).unwrap();

        let mod_id = manager.install_mod(mod_info).unwrap();
        assert!(manager.get_mod(&mod_id).is_some());
    }
}