DataOperationService.cs

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

// Enhanced data operation service
public class DataOperationService : IDataOperationService
{
    private readonly IDataService dataService;
    private readonly Dictionary<Type, IDataPack> dataPacks;
    private readonly List<IDataPack> orderedPacks;

    public DataOperationService(IDataService dataService)
    {
        this.dataService = dataService;
        this.dataPacks = new Dictionary<Type, IDataPack>();
        
        // Register all data packs
        RegisterDataPack(new PlayerDataPack());
        RegisterDataPack(new WorldDataPack());
        RegisterDataPack(new SettingsDataPack());
        
        // Order packs by priority for loading
        orderedPacks = dataPacks.Values.OrderBy(p => p.Priority).ToList();
    }

    private void RegisterDataPack<T>(T dataPack) where T : IDataPack
    {
        dataPacks[typeof(T)] = dataPack;
    }

    // Get specific data pack
    public T GetDataPack<T>() where T : class, IDataPack
    {
        return dataPacks.TryGetValue(typeof(T), out var pack) ? pack as T : null;
    }

    // Save operations
    public void Save()
    {
        foreach (var pack in dataPacks.Values)
        {
            try
            {
                pack.Save(dataService);
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to save {pack.FileName}: {ex.Message}");
            }
        }
    }

    public void Save<T>() where T : class, IDataPack
    {
        var pack = GetDataPack<T>();
        if (pack != null)
        {
            try
            {
                pack.Save(dataService);
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to save {pack.FileName}: {ex.Message}");
            }
        }
    }

    public async Task SaveAsync()
    {
        var tasks = dataPacks.Values.Select(pack => SavePackAsync(pack));
        await Task.WhenAll(tasks);
    }

    private async Task SavePackAsync(IDataPack pack)
    {
        try
        {
            await pack.SaveAsync(dataService);
        }
        catch (Exception ex)
        {
            Debug.LogError($"Failed to save {pack.FileName}: {ex.Message}");
        }
    }

    // Load operations
    public void Load()
    {
        foreach (var pack in orderedPacks)
        {
            try
            {
                pack.Load(dataService);
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to load {pack.FileName}: {ex.Message}");
            }
        }
    }

    public void Load<T>() where T : class, IDataPack
    {
        var pack = GetDataPack<T>();
        if (pack != null)
        {
            try
            {
                pack.Load(dataService);
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to load {pack.FileName}: {ex.Message}");
            }
        }
    }

    public async Task LoadAsync()
    {
        // Load in priority order (can't parallelize due to dependencies)
        foreach (var pack in orderedPacks)
        {
            try
            {
                await pack.LoadAsync(dataService);
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to load {pack.FileName}: {ex.Message}");
            }
        }
    }

    // Utility methods
    public void ResetAll()
    {
        foreach (var pack in dataPacks.Values)
        {
            pack.Reset();
        }
    }

    public void Reset<T>() where T : class, IDataPack
    {
        var pack = GetDataPack<T>();
        pack?.Reset();
    }

    public bool IsAllLoaded()
    {
        return dataPacks.Values.All(p => p.IsLoaded);
    }

    public IEnumerable<string> GetLoadedPackNames()
    {
        return dataPacks.Values.Where(p => p.IsLoaded).Select(p => p.FileName);
    }
}