ERIC WILLIAMS

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

// http://trinary.tech/category/mec/ more efficient coroutines documentation
using MEC;

// to use .ToList or .ToArray
using System.Linq;


// Eric's Inventory script, controls opening and closing of items and collectibles so far
public class Inventory : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, IPointerDownHandler  // IDragHandler, IPointerUpHandler
{
    #region open/close inventory variables
    [Header("inventory open/close animation")]
    public RectTransform itemsRectTransform;
    public RectTransform itemsBackpack;
    public RectTransform collectiblesRectTransform;
    public RectTransform collectiblesBackpack;

    private CoroutineHandle openHandle;
    private CoroutineHandle closeHandle;
    private bool waiting = false;

    private bool itemsBackpackUsed = false;
    private bool itemsOpening = false;
    private bool itemsClosing = false;
    private bool itemsOpen = false;
    private bool itemsClosed = true;

    private bool collectiblesBackpackUsed = false;
    private bool collectiblesOpening = false;
    private bool collectiblesClosing = false;
    private bool collectiblesOpen = false;
    private bool collectiblesClosed = true;


    // Doesn't matter where it's at, always requires tiny bit of maths...
    private Vector3 openInventoryPosition = new Vector3(0, 100, 0);
    private Vector3 closeInventoryPosition = new Vector3(0, -100, 0);

    private float invAnimDistance; // inventory aniamtion distance

    private float openIncrement = 0f; //debug variable don't need in final
    private float closeIncrement = 0f; //debug veriable don't need in final

    public float speed = 1f;
    #endregion

    #region raycast open/close testing variables
    private GraphicRaycaster myGraphRaycast;
    private PointerEventData myPointerEventData;
    private EventSystem myEventSystem;

    [HideInInspector]
    public bool canvasRaycastRunning = false;

    [HideInInspector]
    public GameObject lastRaycastHit;
    #endregion

    #region drag item variables
    [Header("card storage areas")]
    public Transform itemsCards; // itemsPanel collectiblesPanel could probably be removed and use itemsRectTransform.gameObject collectiblesRectTransform.gameObject instead
    public GameObject collectiblesCards;
    public GameObject deck;

    //private List<Transform> itemSlots;
    private Transform[] itemSlots;
    private GameObject[] collectibleSlots;
    private InventoryItem inventoryItem;
    private Vector3 itemZeroSlot = new Vector3(0, 1600 - 64, 0); //height of slot minus half the height of card
    private Vector3 itemZeroDeck = new Vector3(0, 0, 0); //height of slot minus half the height of card
    #endregion


    private void Awake() // trying on awake as it's on this item only
    {
        // start items and collectibles closed
        itemsRectTransform.localPosition = closeInventoryPosition;
        collectiblesRectTransform.localPosition = closeInventoryPosition;

        invAnimDistance = openInventoryPosition.y - closeInventoryPosition.y; // animation distance of items and collectibles

        // graphics raycaster setup
        myGraphRaycast = GetComponent<GraphicRaycaster>();
        myEventSystem = GetComponent<EventSystem>();

        // add slots to slot list, .ToList or .ToArray requires using System.Linq
        itemSlots = itemsCards.GetComponentsInChildren<Transform>();// .ToList();
        itemSlots = itemSlots.Skip(1).ToArray(); // skips the first transform which is the parent and recreates the array

        // moved to proper method
        //for (int i = 0; i < itemSlots.Length; i++)
        //{
        //    Debug.Log("This is Stuipd!" + itemSlots[i]);
        //}
    }



    // gui debugging stuff
    private void OnGUI()
    {
        // trying to sort out these booleans
        GUI.Label(new Rect(10, 10, 300, 20), "itemsClosed = " + itemsClosed);
        GUI.Label(new Rect(10, 30, 300, 20), "itemsClosing = " + itemsClosing);
        GUI.Label(new Rect(10, 50, 300, 20), "itemsOpen = " + itemsOpen);
        GUI.Label(new Rect(10, 70, 300, 20), "itemsOpening = " + itemsOpening);

        GUI.Label(new Rect(10, 110, 300, 20), "collectiblesClosed = " + collectiblesClosed);
        GUI.Label(new Rect(10, 130, 300, 20), "collectiblesClosing = " + collectiblesClosing);
        GUI.Label(new Rect(10, 150, 300, 20), "collectiblesOpen = " + collectiblesOpen);
        GUI.Label(new Rect(10, 170, 300, 20), "collectiblesOpening = " + collectiblesOpening);

        GUI.Label(new Rect(10, 210, 300, 20), "closeIncrement = " + closeIncrement);
        GUI.Label(new Rect(10, 230, 300, 20), "openIncrement = " + openIncrement);
    }

    #region Coroutine canvas raycast start/stop
    public void OnPointerEnter(PointerEventData pointerEventData)
    {
        if (!canvasRaycastRunning) Timing.RunCoroutine(_CanvasRaycast());// start canvas raycasting if it isn't running, should stop physics raycasting
        CancelInvoke(); // prevent onpointerexit invokes from building up
    }

    IEnumerator<float> _CanvasRaycast()
    {
        canvasRaycastRunning = true;

        while (canvasRaycastRunning) // onPointerExit switches this to false
        {
            myPointerEventData = new PointerEventData(myEventSystem);
            myPointerEventData.position = Input.mousePosition;

            List<RaycastResult> results = new List<RaycastResult>();

            myGraphRaycast.Raycast(myPointerEventData, results); // requires graphicraycaster component added to the object, event data doesn't seem to need to be added?

            MyRaycastResults(results); // this function is probably not necessary

            yield return 0;
        }
    }


    private void MyRaycastResults(List<RaycastResult> results)
    {
        foreach (RaycastResult result in results)
        {

            //Debug.Log("Hit " + result.gameObject.name);
            lastRaycastHit = result.gameObject;

            if (lastRaycastHit.name == itemsBackpack.name || lastRaycastHit.name == collectiblesBackpack.name
                || lastRaycastHit.name == itemsRectTransform.name || lastRaycastHit.name == collectiblesRectTransform.name)
            { OpenInventory(); }

            // yield return 0; // would use this if the for each were in a coroutine, this would also cause the items to cycle 60 items per second
        }
    }

    #endregion

    #region open/close inventory
    private void OpenInventory()// public void OnPointerEnter(PointerEventData pointerEventData)
    {
        // set this condition to raycast instead of pointer enter, that way if the backpacks are overlaying other interface components this condition can still resolve to true
        if (lastRaycastHit.name == itemsBackpack.name) // old pointerEventData.pointerEnter.name == itemsBackpack.name
        {
            collectiblesBackpackUsed = false;

            if (!itemsBackpackUsed && !itemsOpening && !itemsOpen)
            {
                itemsBackpackUsed = true;
                Timing.KillCoroutines(openHandle);

                if (itemsClosing)
                {
                    waiting = false;
                    Timing.KillCoroutines(closeHandle);
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(itemsRectTransform));
                }

                else if (itemsClosed && collectiblesClosed)
                {
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(itemsRectTransform));
                }

                else if (collectiblesOpen)
                {
                    waiting = true;
                    closeHandle = Timing.RunCoroutine(_LerpInventoryClose(collectiblesRectTransform));
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(itemsRectTransform));
                }

                else if (collectiblesOpening)
                {
                    waiting = true;
                    closeHandle = Timing.RunCoroutine(_LerpInventoryClose(collectiblesRectTransform));
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(itemsRectTransform));
                }

                // at face value it would seem this isn't need but if it's closing after invoke time period then still need this
                else if (collectiblesClosing)
                {
                    waiting = true;
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(itemsRectTransform));
                }
            }
        }

        if (lastRaycastHit.name == collectiblesBackpack.name) //  ||
        {
            itemsBackpackUsed = false;

            if (!collectiblesBackpackUsed && !collectiblesOpening && !collectiblesOpen)
            {
                collectiblesBackpackUsed = true;
                Timing.KillCoroutines(openHandle);

                if (collectiblesClosing)
                {
                    waiting = false;
                    Timing.KillCoroutines(closeHandle);
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(collectiblesRectTransform));
                }

                // set bools, start opening items
                else if (itemsClosed && collectiblesClosed)
                {
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(collectiblesRectTransform));
                }

                else if (itemsOpen)
                {
                    waiting = true;
                    closeHandle = Timing.RunCoroutine(_LerpInventoryClose(itemsRectTransform));
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(collectiblesRectTransform));
                }

                else if (itemsOpening)
                {
                    waiting = true;
                    closeHandle = Timing.RunCoroutine(_LerpInventoryClose(itemsRectTransform));
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(collectiblesRectTransform));
                }

                // at face value it would seem this isn't need but if it's closing after invoke time period then still need this
                else if (itemsClosing)
                {
                    waiting = true;
                    openHandle = Timing.RunCoroutine(_LerpInventoryOpen(collectiblesRectTransform));
                }
            }
        }
    }


    public void OnPointerExit(PointerEventData pointerEventData)
    {
        // stop canvas raycast, also stop when F key is released
        canvasRaycastRunning = false;
        lastRaycastHit = null;
        //Debug.Log(lastRaycastHit.name);
        //Debug.Log(itemsRectTransform.name);

        Invoke("CloseInventory", 5);
    }


    private void CloseInventory()
    {
        itemsBackpackUsed = false;
        collectiblesBackpackUsed = false;

        if (itemsOpen) closeHandle = Timing.RunCoroutine(_LerpInventoryClose(itemsRectTransform));
        if (collectiblesOpen) closeHandle = Timing.RunCoroutine(_LerpInventoryClose(collectiblesRectTransform));
    }
    #endregion

    #region coroutine lerp items collectibles panels
    IEnumerator<float> _LerpInventoryClose(RectTransform currentRectTransform) // send parameters in for whatever needs to be closed
    {
        if (currentRectTransform.name == itemsRectTransform.name) { itemsClosing = true; itemsClosed = false; itemsOpening = false; itemsOpen = false; }
        if (currentRectTransform.name == collectiblesRectTransform.name) { collectiblesClosing = true; collectiblesClosed = false; collectiblesOpening = false; collectiblesOpen = false; }

        float percentClosed = 0f;
        float percentClosedSqr;

        while (percentClosed < 1) // While not closed
        {
            openIncrement = invAnimDistance - closeIncrement;

            percentClosed = (closeIncrement / invAnimDistance);

            // https://stackoverflow.com/questions/13462001/ease-in-and-ease-out-animation-formula, parametric function
            percentClosedSqr = percentClosed * percentClosed;
            percentClosed = percentClosedSqr / (2f * (percentClosedSqr - percentClosed) + 1f);

            currentRectTransform.localPosition = Vector3.Lerp(openInventoryPosition, closeInventoryPosition, percentClosed);

            closeIncrement = Time.deltaTime * speed + closeIncrement; // put this at the end so that the first frame is 0 lerp

            if (closeIncrement >= invAnimDistance)
            {
                openIncrement = 0f;
                percentClosed = 1f; // prevents bounceback
                waiting = false;

                if (currentRectTransform.name == itemsRectTransform.name) { itemsClosing = false; itemsClosed = true; itemsOpening = false; itemsOpen = false; }
                if (currentRectTransform.name == collectiblesRectTransform.name) { collectiblesClosing = false; collectiblesClosed = true; collectiblesOpening = false; collectiblesOpen = false; }
            }

            yield return 0;
        }
    }

    IEnumerator<float> _LerpInventoryOpen(RectTransform currentRectTransform)
    {
        // wait until other is closed
        while (waiting) yield return Timing.WaitUntilDone(closeHandle);

        if (currentRectTransform.name == itemsRectTransform.name) { itemsClosing = false; itemsClosed = false; itemsOpening = true; itemsOpen = false; }
        if (currentRectTransform.name == collectiblesRectTransform.name) { collectiblesClosing = false; collectiblesClosed = false; collectiblesOpening = true; collectiblesOpen = false; }

        float percentOpen = 0f;
        float percentOpenSqr;

        while (percentOpen < 1) // While not closed
        {
            closeIncrement = invAnimDistance - openIncrement;

            percentOpen = (openIncrement / invAnimDistance);

            // https://stackoverflow.com/questions/13462001/ease-in-and-ease-out-animation-formula, parametric function
            percentOpenSqr = percentOpen * percentOpen;
            percentOpen = percentOpenSqr / (2f * (percentOpenSqr - percentOpen) + 1f);

            currentRectTransform.localPosition = Vector3.Lerp(closeInventoryPosition, openInventoryPosition, percentOpen);

            openIncrement = Time.deltaTime * speed + openIncrement; // put this at the end so that the first frame is 0 lerp

            if (openIncrement >= invAnimDistance)
            {
                closeIncrement = 0f;
                percentOpen = 1f; // prevents bounceback

                if (currentRectTransform.name == itemsRectTransform.name) { itemsClosing = false; itemsClosed = false; itemsOpening = false; itemsOpen = true; }
                if (currentRectTransform.name == collectiblesRectTransform.name) { collectiblesClosing = false; collectiblesClosed = false; collectiblesOpening = false; collectiblesOpen = true; }
            }

            yield return 0;
        }
    }

    IEnumerator<float> _WaitUntilDone() // not sure how to do this yet
    {
        yield return 0;
    }
    #endregion

    #region start item drag and slot sorting

    public void OnPointerDown(PointerEventData pointerEventData) // OnPointerDown over OnDrag so only send one start item drag
    {
        //Debug.Log(pointerEventData.pointerEnter.name + " is being dragged by OnPointerDown");

        inventoryItem = pointerEventData.pointerEnter.GetComponent<InventoryItem>();

        if (inventoryItem != null)
        {
            //Debug.Log("found InvenotryItem script");
            inventoryItem.StartItemDrag(inventoryItem.gameObject);
        }
    }

    public void SlotSort(GameObject item)
    {
        // sort slots
    }


    #endregion

    #region world, hand, deck
    public void InWorld()
    {
        // objects in world
    }

    public void InHand(GameObject item, RectTransform itemRectTransform)
    {
        //item.transform.SetParent(slot01.transform);

        for (int i = 0; i < itemSlots.Length; i++)
        {
            Debug.Log("This is Stuipd!" + itemSlots[i]);
            if (itemSlots[i].childCount == 0)
            {
                item.transform.SetParent(itemSlots[i]);
                break;
            }
        }
        itemRectTransform.localPosition = itemZeroSlot;
    }

    public void InDeck(GameObject item, RectTransform itemRectTransform)
    {
        item.transform.SetParent(deck.transform);
        itemRectTransform.localPosition = itemZeroDeck;
    }
    #endregion



}