using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System;
using static SimpleInventorySystem.GridUI;

namespace SimpleInventorySystem
{
    public class SlotUI : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
    {
        public int width;
        public int height;
        public bool useImageAsSlotHolder;
        public Image image;
        public GridUI grid;
        public GridUI.Cell cell;
        public bool CellInUse;
        public ItemUI itemUI;
        [HideInInspector] public GroupSlotUI groupSlot;
        private AppendUI appendUI;
        [SerializeField] public int cellX;
        [SerializeField] public int cellY;
        public bool EquipSlot;
        public List<SlotUI> LinkedSlots = new List<SlotUI>();
        private LinkedSlotUI linkedSlotUI;
        public bool PointerIsHoveredOver;
        private bool droppedStackOntoEmptySlot;

        internal ItemUI GetItemUI()
        {
            return itemUI;
        }

        public float imageScale = 1f;
        public List<ItemTags> AllowedItemTags;

        /*public void OnDrop(PointerEventData eventData)
        {
            //
            //("OnDrop");
            if (eventData.pointerDrag != null && AllowedDraggable(eventData.pointerDrag))
            {
                DropOntoSlot(eventData.pointerDrag);
            }
        }*/

        public bool AllowedDraggable(GameObject gameObject)
        {
            return gameObject.GetComponent<ItemUI>() != null;
        }

        public bool IsLinkedSlot()
        {
            return linkedSlotUI != null;
        }

        public bool DropOntoSlot(GameObject item, bool dropStack = true)
        {
            ItemUI itemDrop = item.GetComponent<ItemUI>();

            if (IsLinkedSlot())
            {
                GameObject newItemDrop = Instantiate(item);
                itemDrop = newItemDrop.GetComponent<ItemUI>();
                itemDrop.IsLinkedSlotClone = true;
            }

            List<Cell> occupiedCells = new List<Cell>();

            if (!itemDrop.IsLinkedSlotClone && ((HasStack() && itemUI != null && itemUI.itemPrefab == itemDrop.itemPrefab) || !dropStack))
            {
                Debug.Log("Handling Stack");
                // TODO: HANDLE STACKING HERE
                int maxStackDrop = 1;
                if (dropStack)
                {
                    maxStackDrop = itemDrop.Count;
                    if (maxStackDrop > itemUI.StackLimit - itemUI.Count)
                    {
                        maxStackDrop = itemDrop.Count - itemUI.Count;
                    }
                }

                if(itemUI != null)
                {
                    if (itemUI.AddToStack(maxStackDrop))
                    {
                        Debug.Log("Add to stack");
                        itemDrop.RemoveFromStack(maxStackDrop);
                        return true;
                    }
                }
                else
                {
                    GameObject GO = Instantiate(item, transform, false);
                    GO.transform.localPosition = new Vector3(0, 0, 0);
                    ItemUI oldItemDrop = itemDrop;
                    itemDrop = GO.GetComponent<ItemUI>();
                    if (itemDrop.AddToStack(maxStackDrop))
                    {
                        oldItemDrop.RemoveFromStack(maxStackDrop);
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            bool dropCheck = (grid != null && grid.CanMoveInCells(itemDrop, this, occupiedCells) || (grid == null && !cell.inUse));

            ItemTags itemTag = itemDrop.ItemTag;

            bool allowed = AllowedItemTags == null || AllowedItemTags.Count == 0 || AllowedItemTags.Contains(ItemTags.Any) || AllowedItemTags.Contains(itemTag);

            /*Debug.Log("GridUI: DropOntoSlot(): " + gameObject.name + ": " + "dropCheck: " + dropCheck);
            Debug.Log("GridUI: DropOntoSlot(): " + gameObject.name + ": " + "allowed: " + allowed);*/

            if (dropCheck && allowed)
            {
                if (occupiedCells != null && occupiedCells.Count > 1)
                {
                    //Debug.Log("SlotUI: " + occupiedCells.Count);
                    itemDrop.SetSlots(occupiedCells);
                }
                else
                {
                    Debug.Log("In Use");
                    cell.inUse = true;
                    CellInUse = cell.inUse;
                }

                Transform parent = transform;
                if (useImageAsSlotHolder && image != null)
                {
                    parent = image.gameObject.transform;
                }
                item.GetComponent<Transform>().SetParent(parent);
                item.GetComponent<RectTransform>().anchoredPosition = GetComponent<RectTransform>().anchoredPosition;
                //item.GetComponent<RectTransform>().pivot = new Vector2(0, 1);
                itemDrop.SetImageScale(imageScale);
                itemDrop.SetSlot(this);
                this.itemUI = itemDrop;

                itemUI.Drop();

                if (itemUI.Stackable)
                {
                    droppedStackOntoEmptySlot = true;
                }

                if (!IsLinkedSlot())
                {
                    foreach (SlotUI ls in LinkedSlots)
                    {
                        if (ls == this)
                        {
                            Debug.LogWarning("No self-referencing for this array ;)");
                            continue;
                        }
                        //ls.DropOntoSlot(item);
                    }
                }

                if (grid != null)
                {
                    grid.HideSlotsOfItem(itemDrop);
                }
                HideImage();

                if (groupSlot != null)
                {
                    groupSlot.OnItemDropped();
                }
                if (appendUI != null)
                {
                    appendUI.AppendUIToTransform(itemUI);
                }
                return true;
            }
            else if (itemDrop.previousSlot != this)
            {
                // TODO: See why this is outputting at beginning, probably from test objects in Loot
                //Debug.LogWarning("SlotUI: Failed to drop. dropCheck: " + dropCheck + ", allowed: " + allowed);
                // return item to previous parent
                itemDrop.ReturnToSlot();
                return false;
                //Debug.Log("Resetting parent");
            }
            else
            {
                //Debug.LogWarning("SlotUI: Failed to drop. dropCheck: " + dropCheck + ", allowed: " + allowed);
                Debug.LogError("SlotUI: Something wrong has happened.");
                return false;
            }
        }

        void Awake()
        {
            if (image == null)
            {
                Image[] images = GetComponentsInChildren<Image>(); // This will retrieve the first instance of an image in the FIRST child with the component
                //Debug.Log(images.Length);
                if (images.Length > 0)
                {
                    if (images[0].transform == transform)
                    {
                        if (images.Length > 1)
                        {
                            image = images[1];
                        }
                    }
                    else
                    {
                        image = images[0];
                    }
                }
            }

            if (grid == null)
                grid = GetComponentInParent<GridUI>();

            // Check again
            if (grid == null)
            {
                cell = new Cell(0, 0, this, true);
            }

            if (TryGetComponent(out AppendUI aui))
            {
                appendUI = aui;
            }

            if (TryGetComponent(out LinkedSlotUI lui))
            {
                linkedSlotUI = lui;
            }

        }

        public void RemoveDragDropItem()
        {
            ShowImage();

            if (appendUI != null)
            {
                appendUI.RemoveUIFromTransform(itemUI);
            }

            foreach (SlotUI linked in LinkedSlots)
            {
                linked.RemoveDragDropItem();
            }

            itemUI = null;

            if (cell != null)
            {
                cell.inUse = false;
                CellInUse = cell.inUse;
            }

            if (groupSlot != null)
            {
                groupSlot.OnItemRemoved();
            }
        }

        public bool IsSingleCellSlot()
        {
            return width == 1 && height == 1;
        }

        public bool HasStack()
        {
            return itemUI != null && itemUI.Stackable;
        }

        // Start is called before the first frame update
        void Start()
        {
        }

        // Update is called once per frame
        void Update()
        {
            if (PointerIsHoveredOver)
            {
                ItemUI droppedItem = InventorySystem.instance.DraggedItem;
                if (droppedItem != null && !droppedItem.PickedUpOnFrame)
                {
                    if (Input.GetMouseButtonDown(0))
                    {
                        bool callback = DropOntoSlot(droppedItem.gameObject);
                        if (callback && droppedItem.Stackable)
                        {
                            if (droppedItem.Count <= 0)
                                Destroy(droppedItem.gameObject);
                            else if (itemUI.Count < droppedItem.Count && !droppedStackOntoEmptySlot)
                            {
                                InventorySystem.instance.DraggedItem = droppedItem;
                                droppedStackOntoEmptySlot = false;
                            }
                        }
                    }
                    else if (Input.GetMouseButtonDown(1) && droppedItem.Stackable)
                    {
                        Debug.Log("Right Click");
                        if(DropOntoSlot(droppedItem.gameObject, false))
                        {
                            if (droppedItem.Count <= 0)
                                Destroy(droppedItem.gameObject);
                            else
                            {
                                InventorySystem.instance.DraggedItem = droppedItem;
                                droppedItem.transform.SetParent(InventorySystem.instance.inventoryUI.transform);
                                droppedStackOntoEmptySlot = false;
                            }
                        }
                    }
                }
            }
        }

        public void SetCell(Cell cell)
        {
            this.cell = cell;
            cellX = this.cell.X;
            cellY = this.cell.Y;
        }

        internal void HideImage()
        {
            if(image != null)
            {
                image.color = new Color(image.color.r, image.color.g, image.color.b, 0);
            }
        }
        internal void ShowImage()
        {
            if (image != null)
            {
                image.color = new Color(image.color.r, image.color.g, image.color.b, 1);
            }
        }

        public void OnPointerClick(PointerEventData eventData)
        {
        }

        public void OnPointerDown(PointerEventData eventData)
        {
            ItemUI droppedItem = InventorySystem.instance.DraggedItem;
            if (droppedItem != null && !droppedItem.PickedUpOnFrame)
            {
                DropOntoSlot(droppedItem.gameObject);
            }
        }
        public void OnPointerExit(PointerEventData eventData)
        {
            PointerIsHoveredOver = false;
        }

        public void OnPointerEnter(PointerEventData eventData)
        {
            PointerIsHoveredOver = true;
        }
    }
}