MultiSaveManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;

public class MultiSaveManager : MonoBehaviour
{
    [SerializeField] private string saveDirectoryName = "MyGameSaves";
    [SerializeField] private string currentSaveId;
    
    private IDataOperationService dataOps;
    private Dictionary<string, GameSaveInfo> availableSaves;
    private GameSaveInfo currentSave;
    
    // Events for UI updates
    public event Action<List<GameSaveInfo>> OnSaveListUpdated;
    public event Action<GameSaveInfo> OnSaveLoaded;
    public event Action<string> OnSaveDeleted;
    
    // Public properties
    public PlayerData PlayerData => dataOps?.GetDataPack<PlayerDataPack>()?.Data;
    public WorldData WorldData => dataOps?.GetDataPack<WorldDataPack>()?.Data;
    public SettingsData SettingsData => dataOps?.GetDataPack<SettingsDataPack>()?.Data;
    public GameSaveInfo CurrentSave => currentSave;
    public bool HasActiveSave => !string.IsNullOrEmpty(currentSaveId);
    
    private void Awake()
    {
        availableSaves = new Dictionary<string, GameSaveInfo>();
        InitializeSaveSystem();
    }

    private void Update()
    {
        // Test controls
        if (Input.GetKeyDown(KeyCode.A)) SaveCurrentGame();
        if (Input.GetKeyDown(KeyCode.D)) LoadGameById(currentSaveId);
        if (Input.GetKeyDown(KeyCode.S)) LevelUp();
        if (Input.GetKeyDown(KeyCode.N)) CreateNewSave("Test Save", "A test save file");
    }

    private async void InitializeSaveSystem()
    {
        await RefreshSaveList();
        Debug.Log($"Save system initialized! Found {availableSaves.Count} saves.");
    }

    #region Save Management
    
    public async Task<GameSaveInfo> CreateNewSave(string saveName, string description = "")
    {
        var saveId = GenerateUniqueSaveId();
        var saveInfo = new GameSaveInfo
        {
            SaveId = saveId,
            SaveName = saveName,
            Description = description
        };
        
        // Switch to new save
        await SwitchToSave(saveId);
        
        // Initialize with default data
        dataOps.ResetAll();
        
        // Save the new game
        await SaveGameAsync(saveInfo);
        
        Debug.Log($"Created new save: {saveName} ({saveId})");
        return saveInfo;
    }
    
    public async Task<bool> LoadGameById(string saveId)
    {
        if (string.IsNullOrEmpty(saveId) || !availableSaves.ContainsKey(saveId))
        {
            Debug.LogError($"Save not found: {saveId}");
            return false;
        }
        
        await SwitchToSave(saveId);
        await LoadGameDataAsync();
        
        // Update last played time
        currentSave.LastPlayedDate = DateTime.Now;
        await SaveMetadata(currentSave);
        
        OnSaveLoaded?.Invoke(currentSave);
        Debug.Log($"Loaded save: {currentSave.SaveName}");
        return true;
    }
    
    public async Task<bool> DeleteSave(string saveId)
    {
        if (string.IsNullOrEmpty(saveId) || !availableSaves.ContainsKey(saveId))
        {
            Debug.LogError($"Save not found: {saveId}");
            return false;
        }
        
        var saveInfo = availableSaves[saveId];
        var savePath = GetSaveDirectory(saveId);
        
        if (Directory.Exists(savePath))
        {
            Directory.Delete(savePath, true);
        }
        
        availableSaves.Remove(saveId);
        
        // If we deleted the current save, clear it
        if (currentSaveId == saveId)
        {
            currentSaveId = null;
            currentSave = null;
            dataOps = null;
        }
        
        OnSaveDeleted?.Invoke(saveId);
        Debug.Log($"Deleted save: {saveInfo.SaveName}");
        return true;
    }
    
    public async Task<bool> DuplicateSave(string sourceId, string newName)
    {
        if (!availableSaves.ContainsKey(sourceId))
        {
            Debug.LogError($"Source save not found: {sourceId}");
            return false;
        }
        
        var newSaveId = GenerateUniqueSaveId();
        var sourcePath = GetSaveDirectory(sourceId);
        var newPath = GetSaveDirectory(newSaveId);
        
        // Copy directory
        CopyDirectory(sourcePath, newPath);
        
        // Update metadata
        var newSaveInfo = new GameSaveInfo
        {
            SaveId = newSaveId,
            SaveName = newName,
            Description = $"Copy of {availableSaves[sourceId].SaveName}"
        };
        
        await SaveMetadata(newSaveInfo);
        availableSaves[newSaveId] = newSaveInfo;
        
        OnSaveListUpdated?.Invoke(GetSaveList());
        Debug.Log($"Duplicated save: {newName}");
        return true;
    }
    
    #endregion
    
    #region Current Save Operations
    
    public async Task SaveCurrentGame()
    {
        if (!HasActiveSave)
        {
            Debug.LogError("No active save to save to!");
            return;
        }
        
        await SaveGameAsync(currentSave);
    }
    
    public void SaveCurrentGameSync()
    {
        if (!HasActiveSave)
        {
            Debug.LogError("No active save to save to!");
            return;
        }
        
        SaveGameSync(currentSave);
    }
    
    #endregion
    
    #region Internal Methods
    
    private async Task SwitchToSave(string saveId)
    {
        currentSaveId = saveId;
        currentSave = availableSaves.ContainsKey(saveId) ? availableSaves[saveId] : new GameSaveInfo { SaveId = saveId };
        
        // Create new data operation service for this save
        var dataService = new FileDataService(GetSaveDirectory(saveId));
        dataOps = new DataOperationService(dataService);
    }
    
    private async Task LoadGameDataAsync()
    {
        if (dataOps == null)
        {
            Debug.LogError("No data operation service available!");
            return;
        }
        
        await dataOps.LoadAsync();
        
        if (dataOps.IsAllLoaded())
        {
            Debug.Log("All data loaded successfully!");
            Debug.Log($"Player level: {PlayerData.Level}");
            Debug.Log($"Completed quests: {WorldData.CompletedQuests.Count}");
        }
        else
        {
            Debug.LogWarning("Some data packs failed to load, using defaults");
        }
    }
    
    private async Task SaveGameAsync(GameSaveInfo saveInfo)
    {
        if (dataOps == null)
        {
            Debug.LogError("No data operation service available!");
            return;
        }
        
        // Update play time (simple example)
        if (saveInfo.LastPlayedDate != default)
        {
            saveInfo.PlayTime = saveInfo.PlayTime.Add(DateTime.Now - saveInfo.LastPlayedDate);
        }
        saveInfo.LastPlayedDate = DateTime.Now;
        
        // Save game data
        await dataOps.SaveAsync();
        
        // Save metadata
        await SaveMetadata(saveInfo);
        
        // Update our cache
        availableSaves[saveInfo.SaveId] = saveInfo;
        
        Debug.Log($"Game saved: {saveInfo.SaveName}");
    }
    
    private void SaveGameSync(GameSaveInfo saveInfo)
    {
        if (dataOps == null)
        {
            Debug.LogError("No data operation service available!");
            return;
        }
        
        // Update play time
        if (saveInfo.LastPlayedDate != default)
        {
            saveInfo.PlayTime = saveInfo.PlayTime.Add(DateTime.Now - saveInfo.LastPlayedDate);
        }
        saveInfo.LastPlayedDate = DateTime.Now;
        
        // Save game data
        dataOps.Save();
        
        // Save metadata (sync version)
        SaveMetadataSync(saveInfo);
        
        // Update our cache
        availableSaves[saveInfo.SaveId] = saveInfo;
        
        Debug.Log($"Game saved: {saveInfo.SaveName}");
    }
    
    private async Task SaveMetadata(GameSaveInfo saveInfo)
    {
        var metadataPath = Path.Combine(GetSaveDirectory(saveInfo.SaveId), "metadata.json");
        var json = JsonUtility.ToJson(saveInfo, true);
        await File.WriteAllTextAsync(metadataPath, json);
    }
    
    private void SaveMetadataSync(GameSaveInfo saveInfo)
    {
        var metadataPath = Path.Combine(GetSaveDirectory(saveInfo.SaveId), "metadata.json");
        var json = JsonUtility.ToJson(saveInfo, true);
        File.WriteAllText(metadataPath, json);
    }
    
    private async Task<GameSaveInfo> LoadMetadata(string saveId)
    {
        var metadataPath = Path.Combine(GetSaveDirectory(saveId), "metadata.json");
        
        if (!File.Exists(metadataPath))
        {
            // Create default metadata if it doesn't exist
            var defaultInfo = new GameSaveInfo
            {
                SaveId = saveId,
                SaveName = $"Save {saveId}",
                Description = "Legacy save file"
            };
            await SaveMetadata(defaultInfo);
            return defaultInfo;
        }
        
        try
        {
            var json = await File.ReadAllTextAsync(metadataPath);
            return JsonUtility.FromJson<GameSaveInfo>(json);
        }
        catch (Exception ex)
        {
            Debug.LogError($"Failed to load metadata for save {saveId}: {ex.Message}");
            return null;
        }
    }
    
    public async Task RefreshSaveList()
    {
        availableSaves.Clear();
        var baseDirectory = Path.Combine(Application.persistentDataPath, saveDirectoryName);
        
        if (!Directory.Exists(baseDirectory))
        {
            Directory.CreateDirectory(baseDirectory);
            OnSaveListUpdated?.Invoke(new List<GameSaveInfo>());
            return;
        }
        
        var saveDirectories = Directory.GetDirectories(baseDirectory);
        
        foreach (var saveDir in saveDirectories)
        {
            var saveId = Path.GetFileName(saveDir);
            var saveInfo = await LoadMetadata(saveId);
            
            if (saveInfo != null)
            {
                availableSaves[saveId] = saveInfo;
            }
        }
        
        OnSaveListUpdated?.Invoke(GetSaveList());
    }
    
    private string GetSaveDirectory(string saveId)
    {
        return Path.Combine(Application.persistentDataPath, saveDirectoryName, saveId);
    }
    
    private string GenerateUniqueSaveId()
    {
        string saveId;
        do
        {
            saveId = DateTime.Now.ToString("yyyyMMdd_HHmmss_") + UnityEngine.Random.Range(1000, 9999);
        } while (availableSaves.ContainsKey(saveId));
        
        return saveId;
    }
    
    private void CopyDirectory(string sourceDir, string destDir)
    {
        Directory.CreateDirectory(destDir);
        
        foreach (var file in Directory.GetFiles(sourceDir))
        {
            var fileName = Path.GetFileName(file);
            var destFile = Path.Combine(destDir, fileName);
            File.Copy(file, destFile);
        }
        
        foreach (var directory in Directory.GetDirectories(sourceDir))
        {
            var dirName = Path.GetFileName(directory);
            var destSubDir = Path.Combine(destDir, dirName);
            CopyDirectory(directory, destSubDir);
        }
    }
    
    #endregion
    
    #region Public API
    
    public List<GameSaveInfo> GetSaveList()
    {
        return availableSaves.Values.OrderByDescending(s => s.LastPlayedDate).ToList();
    }
    
    public GameSaveInfo GetSaveInfo(string saveId)
    {
        return availableSaves.TryGetValue(saveId, out var info) ? info : null;
    }
    
    public async Task RenameSave(string saveId, string newName)
    {
        if (availableSaves.ContainsKey(saveId))
        {
            availableSaves[saveId].SaveName = newName;
            await SaveMetadata(availableSaves[saveId]);
            OnSaveListUpdated?.Invoke(GetSaveList());
        }
    }
    
    public async Task UpdateSaveDescription(string saveId, string description)
    {
        if (availableSaves.ContainsKey(saveId))
        {
            availableSaves[saveId].Description = description;
            await SaveMetadata(availableSaves[saveId]);
        }
    }
    
    public void AddCustomMetadata(string key, object value)
    {
        if (currentSave != null)
        {
            currentSave.CustomMetadata[key] = value;
        }
    }
    
    public T GetCustomMetadata<T>(string key)
    {
        if (currentSave?.CustomMetadata.ContainsKey(key) == true)
        {
            return (T)currentSave.CustomMetadata[key];
        }
        return default(T);
    }
    
    #endregion
    
    #region Game Logic Examples
    
    public void LevelUp()
    {
        if (PlayerData != null)
        {
            PlayerData.Level++;
            PlayerData.Experience = 0;
            dataOps.Save<PlayerDataPack>();
            Debug.Log($"Player leveled up to {PlayerData.Level}!");
        }
    }
    
    public void CompleteQuest(string questId)
    {
        if (WorldData != null && !WorldData.CompletedQuests.Contains(questId))
        {
            WorldData.CompletedQuests.Add(questId);
            dataOps.Save<WorldDataPack>();
            Debug.Log($"Quest {questId} completed!");
        }
    }
    
    #endregion
    
    #region Application Lifecycle
    
    private void OnApplicationPause(bool pauseStatus)
    {
        if (pauseStatus && HasActiveSave)
        {
            SaveCurrentGameSync();
        }
    }
    
    private void OnApplicationFocus(bool hasFocus)
    {
        if (!hasFocus && HasActiveSave)
        {
            SaveCurrentGameSync();
        }
    }
    
    #endregion
}