SaveLoadUI.cs

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System;

public class SaveLoadUI : MonoBehaviour
{
    [Header("UI References")]
    [SerializeField] private GameObject saveLoadPanel;
    [SerializeField] private GameObject saveSlotPrefab;
    [SerializeField] private Transform saveSlotContainer;
    [SerializeField] private Button createNewSaveButton;
    [SerializeField] private Button closePanelButton;
    
    [Header("New Save Dialog")]
    [SerializeField] private GameObject newSaveDialog;
    [SerializeField] private TMP_InputField saveNameInput;
    [SerializeField] private TMP_InputField saveDescriptionInput;
    [SerializeField] private Button confirmCreateButton;
    [SerializeField] private Button cancelCreateButton;
    
    [Header("Delete Confirmation")]
    [SerializeField] private GameObject deleteConfirmDialog;
    [SerializeField] private TextMeshProUGUI deleteConfirmText;
    [SerializeField] private Button confirmDeleteButton;
    [SerializeField] private Button cancelDeleteButton;
    
    private MultiSaveManager saveManager;
    private List<SaveSlotUI> saveSlots = new List<SaveSlotUI>();
    private string saveToDelete;
    
    private void Awake()
    {
        saveManager = FindObjectOfType<MultiSaveManager>();
        SetupUI();
    }
    
    private void Start()
    {
        // Subscribe to save manager events
        saveManager.OnSaveListUpdated += RefreshSaveList;
        saveManager.OnSaveLoaded += OnSaveLoaded;
        saveManager.OnSaveDeleted += OnSaveDeleted;
        
        // Hide panels initially
        saveLoadPanel.SetActive(false);
        newSaveDialog.SetActive(false);
        deleteConfirmDialog.SetActive(false);
    }
    
    private void SetupUI()
    {
        createNewSaveButton.onClick.AddListener(ShowNewSaveDialog);
        closePanelButton.onClick.AddListener(HideSaveLoadPanel);
        
        confirmCreateButton.onClick.AddListener(CreateNewSave);
        cancelCreateButton.onClick.AddListener(HideNewSaveDialog);
        
        confirmDeleteButton.onClick.AddListener(ConfirmDeleteSave);
        cancelDeleteButton.onClick.AddListener(HideDeleteConfirmDialog);
    }
    
    public void ShowSaveLoadPanel()
    {
        saveLoadPanel.SetActive(true);
        saveManager.RefreshSaveList();
    }
    
    public void HideSaveLoadPanel()
    {
        saveLoadPanel.SetActive(false);
    }
    
    private void ShowNewSaveDialog()
    {
        newSaveDialog.SetActive(true);
        saveNameInput.text = "";
        saveDescriptionInput.text = "";
        saveNameInput.Select();
    }
    
    private void HideNewSaveDialog()
    {
        newSaveDialog.SetActive(false);
    }
    
    private async void CreateNewSave()
    {
        string saveName = saveNameInput.text.Trim();
        string description = saveDescriptionInput.text.Trim();
        
        if (string.IsNullOrEmpty(saveName))
        {
            saveName = "New Save";
        }
        
        await saveManager.CreateNewSave(saveName, description);
        HideNewSaveDialog();
        HideSaveLoadPanel();
    }
    
    private void ShowDeleteConfirmDialog(string saveId, string saveName)
    {
        saveToDelete = saveId;
        deleteConfirmText.text = $"Are you sure you want to delete '{saveName}'?\nThis action cannot be undone.";
        deleteConfirmDialog.SetActive(true);
    }
    
    private void HideDeleteConfirmDialog()
    {
        deleteConfirmDialog.SetActive(false);
        saveToDelete = null;
    }
    
    private async void ConfirmDeleteSave()
    {
        if (!string.IsNullOrEmpty(saveToDelete))
        {
            await saveManager.DeleteSave(saveToDelete);
            HideDeleteConfirmDialog();
        }
    }
    
    private void RefreshSaveList(List<GameSaveInfo> saves)
    {
        // Clear existing slots
        foreach (var slot in saveSlots)
        {
            if (slot != null)
                Destroy(slot.gameObject);
        }
        saveSlots.Clear();
        
        // Create new slots
        foreach (var save in saves)
        {
            GameObject slotObj = Instantiate(saveSlotPrefab, saveSlotContainer);
            SaveSlotUI slot = slotObj.GetComponent<SaveSlotUI>();
            if (slot != null)
            {
                slot.Initialize(save, this);
                saveSlots.Add(slot);
            }
        }
    }
    
    private void OnSaveLoaded(GameSaveInfo saveInfo)
    {
        Debug.Log($"UI: Save loaded - {saveInfo.SaveName}");
        // Update UI to show current save
        RefreshCurrentSaveDisplay();
    }
    
    private void OnSaveDeleted(string saveId)
    {
        Debug.Log($"UI: Save deleted - {saveId}");
        // Refresh the list
        saveManager.RefreshSaveList();
    }
    
    private void RefreshCurrentSaveDisplay()
    {
        // Update current save indicators in UI
        foreach (var slot in saveSlots)
        {
            slot.RefreshCurrentSaveIndicator(saveManager.CurrentSave?.SaveId);
        }
    }
    
    // Called by SaveSlotUI
    public async void LoadSave(string saveId)
    {
        bool success = await saveManager.LoadGameById(saveId);
        if (success)
        {
            HideSaveLoadPanel();
        }
    }
    
    public void DeleteSave(string saveId, string saveName)
    {
        ShowDeleteConfirmDialog(saveId, saveName);
    }
    
    public async void DuplicateSave(string saveId, string originalName)
    {
        string newName = $"{originalName} - Copy";
        await saveManager.DuplicateSave(saveId, newName);
    }
    
    private void OnDestroy()
    {
        if (saveManager != null)
        {
            saveManager.OnSaveListUpdated -= RefreshSaveList;
            saveManager.OnSaveLoaded -= OnSaveLoaded;
            saveManager.OnSaveDeleted -= OnSaveDeleted;
        }
    }
}