AppleHillsProduction/Assets/Scripts/Core/ItemManager.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using Interactions;

namespace Core
{
    /// <summary>
    /// Central registry for pickups and item slots.
    /// Mirrors the singleton pattern used by PuzzleManager.
    /// </summary>
    public class ItemManager : MonoBehaviour
    {
        private static ItemManager _instance;
        private static bool _isQuitting;

        public static ItemManager Instance
        {
            get
            {
                if (_instance == null && Application.isPlaying && !_isQuitting)
                {
                    _instance = FindAnyObjectByType<ItemManager>();
                    if (_instance == null)
                    {
                        var go = new GameObject("ItemManager");
                        _instance = go.AddComponent<ItemManager>();
                        // DontDestroyOnLoad(go);
                    }
                }
                return _instance;
            }
        }

        private readonly HashSet<Pickup> _pickups = new HashSet<Pickup>();
        private readonly HashSet<ItemSlot> _itemSlots = new HashSet<ItemSlot>();

        // Central events forwarded from registered pickups/slots
        // Broadcasts when any registered pickup was picked up (passes the picked item data)
        public event Action<PickupItemData> OnItemPickedUp;

        // Broadcasts when any registered ItemSlot reports a correct item slotted
        // Args: slot's itemData (the slot definition), then the slotted item data
        public event Action<PickupItemData, PickupItemData> OnCorrectItemSlotted;

        void Awake()
        {
            _instance = this;
        }

        void Start()
        {
            // Subscribe to scene load completed so we can clear registrations when scenes change
            // Access Instance directly to ensure the service is initialized and we get the event hookup.
            SceneManagerService.Instance.SceneLoadCompleted += OnSceneLoadCompleted;
        }

        void OnDestroy()
        {
            // Unsubscribe from SceneManagerService
            if (SceneManagerService.Instance != null)
                SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;

            // Ensure we clean up any subscriptions from registered items when the manager is destroyed
            ClearAllRegistrations();
        }

        void OnApplicationQuit()
        {
            _isQuitting = true;
        }

        private void OnSceneLoadCompleted(string sceneName)
        {
            // Clear all registrations when a new scene is loaded, so no stale references persist
            ClearAllRegistrations();
        }

        /// <summary>
        /// Unsubscribe all pickup/slot event handlers and clear registries and manager events.
        /// </summary>
        private void ClearAllRegistrations()
        {
            // Unsubscribe pickup handlers
            var pickupsCopy = new List<Pickup>(_pickups);
            foreach (var p in pickupsCopy)
            {
                if (p != null)
                    p.OnItemPickedUp -= Pickup_OnItemPickedUp;
            }
            _pickups.Clear();

            // Unsubscribe slot handlers
            var slotsCopy = new List<ItemSlot>(_itemSlots);
            foreach (var s in slotsCopy)
            {
                if (s != null)
                    s.OnCorrectItemSlotted -= ItemSlot_OnCorrectItemSlotted;
            }
            _itemSlots.Clear();

            // Clear manager-level event subscribers
            OnItemPickedUp = null;
            OnCorrectItemSlotted = null;
        }

        public void RegisterPickup(Pickup pickup)
        {
            if (pickup == null) return;
            // only subscribe if newly added to avoid duplicate subscriptions
            if (_pickups.Add(pickup))
            {
                pickup.OnItemPickedUp += Pickup_OnItemPickedUp;
            }
        }

        public void UnregisterPickup(Pickup pickup)
        {
            if (pickup == null) return;
            if (_pickups.Remove(pickup))
            {
                pickup.OnItemPickedUp -= Pickup_OnItemPickedUp;
            }
        }

        public void RegisterItemSlot(ItemSlot slot)
        {
            if (slot == null) return;
            if (_itemSlots.Add(slot))
            {
                slot.OnCorrectItemSlotted += ItemSlot_OnCorrectItemSlotted;
            }
        }

        public void UnregisterItemSlot(ItemSlot slot)
        {
            if (slot == null) return;
            if (_itemSlots.Remove(slot))
            {
                slot.OnCorrectItemSlotted -= ItemSlot_OnCorrectItemSlotted;
            }
        }

        // Handler that forwards pickup events
        private void Pickup_OnItemPickedUp(PickupItemData data)
        {
            OnItemPickedUp?.Invoke(data);
        }

        // Handler that forwards correct-slot events
        private void ItemSlot_OnCorrectItemSlotted(PickupItemData slotData, PickupItemData slottedItem)
        {
            OnCorrectItemSlotted?.Invoke(slotData, slottedItem);
        }

        /// <summary>
        /// Returns the current slot state for the given item data by searching registered slots.
        /// If the item is currently slotted in a slot, returns that slot's state; otherwise returns ItemSlotState.None.
        /// </summary>
        public ItemSlotState GetSlotStatusForItem(PickupItemData itemData)
        {
            if (itemData == null) return ItemSlotState.None;

            foreach (var slot in _itemSlots)
            {
                var slottedObj = slot.GetSlottedObject();
                if (slottedObj == null) continue;
                var pickup = slottedObj.GetComponent<Pickup>();
                if (pickup == null) continue;
                if (pickup.itemData == itemData)
                {
                    return slot.CurrentSlottedState;
                }
            }
            return ItemSlotState.None;
        }

        public IEnumerable<Pickup> Pickups => _pickups;
        public IEnumerable<ItemSlot> ItemSlots => _itemSlots;
    }
}