using SaveSystem;
using SaveSystem.Examples;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    private SaveManager _saveManager;
    
    void Start()
    {
        // Setup SaveManager with fluent builder
        _saveManager = new SaveManagerBuilder()
            .UseJsonSerializer()         // or .UseBinarySerializer()
            .UseLocalFileStorage()       // or .UsePlayerPrefsStorage()
            .Build();
    }
    
    // Save game
    async void SaveGame()
    {
        var playerData = new PlayerData 
        { 
            Name = "Hero", 
            Level = 10, 
            Gold = 5000 
        };
        
        var result = await _saveManager.SaveAsync("slot1", playerData);
        
        if (result.Success)
            Debug.Log("Game saved!");
        else
            Debug.LogError($"Save failed: {result.ErrorMessage}");
    }
    
    // Load game
    async void LoadGame()
    {
        var result = await _saveManager.LoadAsync<PlayerData>("slot1");
        
        if (result.Success)
        {
            var data = result.Data;
            Debug.Log($"Loaded: {data.Name}, Level {data.Level}");
        }
    }
}

async void SaveWithProgress()
{
    var progress = new Progress<float>(p => 
    {
        Debug.Log($"Saving: {p * 100:F0}%");
        // Update UI progress bar
    });
    
    var result = await _saveManager.SaveAsync("slot1", playerData, progress);
}

using SaveSystem.Core;
using SaveSystem.Models;
using System.Collections.Generic;

[Serializable]
public class PlayerInventory : ISaveData
{
    public int Version => 1;
    
    public List<Card> OwnedCards;
    public SerializableDictionary<string, int> CardCounts;
    
    public PlayerInventory()
    {
        OwnedCards = new List<Card>();
        CardCounts = new SerializableDictionary<string, int>();
    }
    
    public bool Validate()
    {
        return OwnedCards != null && CardCounts != null;
    }
    
    public string GetChecksum()
    {
        // Implement checksum calculation
        return "";
    }
}

public class GameController : MonoBehaviour
{
    private SaveManager _saveManager;
    
    // Can be called from Unity UI Button!
    public async void OnSaveButtonClick()
    {
        var result = await _saveManager.SaveAsync("slot1", data);
        
        if (result.Success)
            statusText.text = "Saved!";
    }
}

using SaveSystem.Features.Backup;

// Create backup manager (keeps last 3 backups)
var backupManager = new BackupManager(_saveManager, maxBackupCount: 3);

// Create backup
await backupManager.CreateBackupAsync("profile1");

// List backups
var backups = backupManager.GetBackups("profile1");

// Restore from most recent backup
await backupManager.RestoreFromBackupAsync("profile1", backupIndex: 0);

using SaveSystem.Features.Versioning;

// Setup migration manager
var migrationManager = new VersionMigrationManager();

// Register migration from v1 to v2
migrationManager.RegisterMigration<PlayerData>(
    fromVersion: 1,
    toVersion: 2,
    migrationAction: data =>
    {
        // Add default value for new field in v2
        data.NewFieldInV2 = "default_value";
    }
);

// Migration happens automatically when loading old saves
var result = await _saveManager.LoadAsync<PlayerData>("old_save");

using SaveSystem.Installers;
using Zenject;

// Add SaveSystemInstaller to your SceneContext
public class GameInstaller : MonoInstaller
{
    public override void InstallBindings()
    {
        // Install SaveSystem
        SaveSystemInstaller.Install(Container);
    }
}

using SaveSystem;
using SaveSystem.Features.AutoSave;
using SaveSystem.Features.Backup;
using Zenject;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    private SaveManager _saveManager;
    private AutoSaveManager _autoSave;
    private BackupManager _backup;
    
    // Constructor injection
    [Inject]
    public void Construct(
        SaveManager saveManager,
        AutoSaveManager autoSave,
        BackupManager backup)
    {
        _saveManager = saveManager;
        _autoSave = autoSave;
        _backup = backup;
    }
    
    async void SaveGame()
    {
        await _saveManager.SaveAsync("profile", playerData);
    }
}

public override void InstallBindings()
{
    // Different strategies per platform
    #if UNITY_ANDROID || UNITY_IOS
        Container.Bind<ISaveStrategy>()
            .To<PlayerPrefsSaveStrategy>()
            .AsSingle();
    #else
        Container.Bind<ISaveStrategy>()
            .To<LocalFileSaveStrategy>()
            .AsSingle();
    #endif
}

// Configure in Inspector (SaveSystemInstaller component)
- Use Json Serializer: ✓
- Use Compression: ✓
- Enable Auto Save: ✓
- Auto Save Interval: 300
- Max Backup Count: 3

// JSON (human-readable, debug-friendly)
.UseJsonSerializer()

// Binary (compact, faster)
.UseBinarySerializer()

// Custom serializer
.UseSerializer(new MyCustomSerializer())

// Local file system (recommended for most cases)
.UseLocalFileStorage()

// PlayerPrefs (simple, cross-platform, limited size)
.UsePlayerPrefsStorage()

// Custom storage
.UseStorage(new MyCustomStorage())

using SaveSystem.Core;
using System;

[Serializable]
public class MyGameData : ISaveData
{
    public int Version => 1;  // Increment when format changes
    
    public string PlayerName;
    public int Level;
    
    // Validate business rules
    public bool Validate()
    {
        return !string.IsNullOrEmpty(PlayerName) && Level >= 1;
    }
    
    // Calculate checksum for corruption detection
    public string GetChecksum()
    {
        // Use CorruptionDetector helper or implement your own
        return "";
    }
}