StorageSystem - Part 6.1

using UnityEngine;
using System.Collections.Generic;

public class StorageSystem : MonoBehaviour
{
    public static StorageSystem Instance { get; private set; }

    private Dictionary<Item, List<Item>> storageInventories = new Dictionary<Item, List<Item>>();
    private Dictionary<Item, Transform> storageHolders = new Dictionary<Item, Transform>();
    private Dictionary<Item, Dictionary<Item, int>> storageSlotPositions = new Dictionary<Item, Dictionary<Item, int>>();

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        if (InventorySystem.Instance.backpack != null)
        {
            InitializeStorage(InventorySystem.Instance.backpack);
        }
    }

    public void InitializeStorage(Item storageItem)
    {
        if (!storageInventories.ContainsKey(storageItem))
        {
            storageInventories[storageItem] = new List<Item>();
            storageHolders[storageItem] = storageItem.transform;
            storageSlotPositions[storageItem] = new Dictionary<Item, int>();
        }
    }

    public void RegisterStorage(Item storageItem, Transform holder)
    {
        if (!storageHolders.ContainsKey(storageItem))
        {
            storageHolders.Add(storageItem, holder);
            storageSlotPositions[storageItem] = new Dictionary<Item, int>();
        }
    }

    public bool AddToStorage(Item storageItem, Item itemToStore, int slotIndex = -1)
    {
        if (storageItem == null)
        {
            Debug.LogError("Attempted to add item to null storage");
            return false;
        }

        if (!storageInventories.ContainsKey(storageItem))
        {
            InitializeStorage(storageItem);
        }

        if (storageInventories[storageItem].Count < storageItem.storageCapacity)
        {
            storageInventories[storageItem].Add(itemToStore);
            itemToStore.gameObject.SetActive(false);

            if (storageHolders.ContainsKey(storageItem))
            {
                itemToStore.transform.SetParent(storageHolders[storageItem]);
            }

            if (slotIndex >= 0)
            {
                storageSlotPositions[storageItem][itemToStore] = slotIndex;
            }
            return true;
        }
        return false;
    }

    public void RemoveItemFromStorage(Item storageItem, Item itemToRemove)
    {
        if (storageInventories.TryGetValue(storageItem, out List<Item> items))
        {
            items.Remove(itemToRemove);
            itemToRemove.gameObject.SetActive(true);
            itemToRemove.transform.SetParent(null);

            if (storageSlotPositions.ContainsKey(storageItem))
            {
                storageSlotPositions[storageItem].Remove(itemToRemove);
            }
        }
    }

    public void OpenStorage(Item storageItem)
    {
        if (UIManager.Instance == null)
        {
            Debug.LogError("UIManager reference is null in StorageSystem");
            return;
        }

        if (storageItem == null)
        {
            Debug.LogError("Attempted to open storage for a null item");
            return;
        }

        UIManager.Instance.ShowInventoryPrompt(storageItem);
    }

    public List<Item> GetStorageInventory(Item storageItem)
    {
        if (storageInventories.TryGetValue(storageItem, out List<Item> items))
        {
            return items;
        }
        return new List<Item>();
    }

    public int GetAvailableSlots(Item storageItem)
    {
        if (!storageInventories.ContainsKey(storageItem))
        {
            return storageItem.storageCapacity;
        }
        return storageItem.storageCapacity - storageInventories[storageItem].Count;
    }

    public void UpdateItemPosition(Item storageItem, Item item, int newSlotIndex)
    {
        if (storageSlotPositions.ContainsKey(storageItem))
        {
            storageSlotPositions[storageItem][item] = newSlotIndex;
        }
    }

    public int GetItemSlotIndex(Item storageItem, Item item)
    {
        if (storageSlotPositions.ContainsKey(storageItem) && storageSlotPositions[storageItem].ContainsKey(item))
        {
            return storageSlotPositions[storageItem][item];
        }
        return -1;
    }
}