using FishNet.Object;
using FishNet.Object.Synchronizing;
using Types;
using Types.Items;
using Types.UI;
using UnityEngine;

// InventoryManager.cs
namespace Managers.Item
{
    public class ToolbarManager : NetworkBehaviour, IItemManager<GameSlot>
    {
        public delegate void ActiveSlotChangedHandler();

        public PlayerManager playerManager;
        private readonly SyncVar<GameSlot> _activeGameSlot = new(new SyncTypeSettings(1f));

        // private static ToolbarManager Instance;
        private readonly SyncDictionary<int, GameSlot> _slots = new();

        private readonly SlotType _slotType = SlotType.Toolbar;


        private void Awake()
        {
            _slots.OnChange += slots_OnChange;
            _activeGameSlot.Value = null;
            _activeGameSlot.OnChange += activeGameSlot_OnChange;
        }

        private void Start()
        {
            Debug.Log("ToolbarManager Start");
        }

        public GameItem GetItemFromSlot(int slotId)
        {
            return _slots.TryGetValue(slotId, out var slot) ? slot.Item : null;
        }

        public void RemoveItemFromSlot(int slotId)
        {
            if (_slots.TryGetValue(slotId, out var slot))
                slot.Item = null;
            else
                Debug.LogWarning("Slot not found: " + slotId);
        }

        public void AddItemToOpenSlot(GameItem item)
        {
            /*foreach (var slot in Slots.Values)
            if (slot.IsEmpty())
            {
                slot.item = item.GameItem;
                Debug.Log("Added item to slot: " + slot.position + " / " + item.GameItem.itemName + " / " +
                          item.GameItem.quantity);
                return;
            }

        Debug.LogWarning("No empty slots available to add item: " + item.GameItem.itemName);*/
        }


        [ServerRpc]
        public void AddSlotServerRpc(GameSlot gameSlot)
        {
            // get max slot position
            var maxSlotPosition = 0;
            foreach (var slot in _slots.Values)
                if (slot.Position > maxSlotPosition)
                    maxSlotPosition = slot.Position;
            gameSlot.Position = maxSlotPosition + 1;
            gameSlot.SlotType = _slotType;
            _slots[gameSlot.GetId()] = gameSlot;
            _slots.Dirty(gameSlot.Position);
        }


        public void RemoveSlot(int slotId)
        {
            _slots.Remove(slotId);
        }

        public GameSlot GetSlot(int slotId)
        {
            return _slots[slotId];
        }

        public void SwapItems(int slotId1, int slotId2)
        {
            if (_slots.TryGetValue(slotId1, out var slot1) &&
                _slots.TryGetValue(slotId2, out var slot2))
                (slot1.Item, slot2.Item) = (slot2.Item, slot1.Item);
        }


        [ServerRpc]
        public void AddItemToSlot(GameItem item, int slotId)
        {
            if (_slots.TryGetValue(slotId, out var slot))
                slot.Item = item;
            else
                Debug.LogWarning("Slot not found: " + slotId);
        }


        // public void AddItemToOpenSlot(GameItem item)
        // {
        //     foreach (var slot in Slots.Values)
        //         if (slot.IsEmpty())
        //         {
        //             slot.item = item;
        //             Debug.Log("Added item to slot: " + slot.position + " / " + item.itemName + " / " + item.quantity);
        //             return;
        //         }
        //
        //     Debug.LogWarning("No empty slots available to add item: " + item.itemName);
        // }

        public SyncDictionary<int, GameSlot> GetSlots()
        {
            return _slots;
        }

        private void activeGameSlot_OnChange(GameSlot prev, GameSlot next, bool asServer)
        {
            Debug.Log("Active GameSlot changed:");
        }

        private void slots_OnChange(SyncDictionaryOperation op, int key,
            GameSlot value, bool asServer)
        {
            Debug.Log("Slots changed:");
        }

        [ServerRpc]
        private void SetActiveSlotServerRpc(int slotId)
        {
            SetActiveSlot(slotId);
        }

        [ObserversRpc]
        private void SetActiveSlotObserversRpc(int slotId)
        {
            SetActiveSlot(slotId);
        }

        public event ActiveSlotChangedHandler OnActiveSlotChanged;

        public void RemoveItemFromSlot(GameItem item)
        {
            foreach (var slot in _slots.Values)
                if (slot.Item == item)
                {
                    slot.Item = null;
                    Debug.Log("Removed item from slot: " + item.ItemName);
                    return;
                }

            Debug.LogWarning("Item not found in any slot: " + item.ItemName);
        }


        public void SetItemInSlot(int slotId, GameItem item)
        {
            if (_slots.TryGetValue(slotId, out var slot))
                slot.Item = item;
            else
                Debug.LogWarning("Slot not found: " + slotId);
        }

        public void SetActiveSlot(int slotId)
        {
            _activeGameSlot.Value = _slots[slotId];
            OnActiveSlotChanged?.Invoke();
        }


        public void Initialize(GamePlayer playerData)
        {
            // add toolbar hotkeys 1 to 0 on keyboard
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 1", KeyCode.Alpha1, () => SetActiveSlot(0));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 2", KeyCode.Alpha2, () => SetActiveSlot(1));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 3", KeyCode.Alpha3, () => SetActiveSlot(2));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 4", KeyCode.Alpha4, () => SetActiveSlot(3));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 5", KeyCode.Alpha5, () => SetActiveSlot(4));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 6", KeyCode.Alpha6, () => SetActiveSlot(5));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 7", KeyCode.Alpha7, () => SetActiveSlot(6));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 8", KeyCode.Alpha8, () => SetActiveSlot(7));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 9", KeyCode.Alpha9, () => SetActiveSlot(8));
            HotkeyManager.Instance.RegisterHotkey("Activate Toolbar Slot 10", KeyCode.Alpha0, () => SetActiveSlot(9));

            Debug.Log("Toolbar size: " + playerData.ToolbarSize);
            Debug.Log("Toolbar slots: " + playerData.ToolbarSlots.Count);

            // print all the toolbar slots keys
            // foreach (var slot in playerData.ToolbarSlots) Debug.Log("Slot key: " + slot.Key);

            // create player slots for inventory
            /*for (var i = 0; i < playerData.ToolbarSize; i++)
            {
                // find slot at position i and map it
                var slot = playerData.ToolbarSlots.FirstOrDefault(x => x.Value.Position == i);
                if (slot.Value != null) AddSlotServerRpc(slot.Value);
            }*/
            // copy slots from Dictionary to SyncDictionary

            Debug.Log("Completed Initialized hotkeys in ToolbarManager");
        }


        public override void OnStartClient()
        {
            base.OnStartClient();
        }


        // on client connected,


        // on client, add slot to toolbar
        [ObserversRpc]
        public void AddSlotObserversRpc(GameSlot slot)
        {
            // AddSlot(slot);
        }

        public GameSlot GetActiveToolbarSlot()
        {
            return _activeGameSlot.Value;
        }
    }
}