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

public class staminaSystem : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public bool useStaminaEnabled = true;

    public bool showStaminaUIEnabled = true;

    public Color regularStaminaColor;
    public Color closeToEmptyStaminaColor;

    public float closeToEmptyStaminaAmount;

    public float staminaAmount;

    [Space]
    [Header ("Refill Settings")]
    [Space]

    public bool autoRefillStaminaEnabled = true;

    public bool hideStaminaUIAfterDelayIfNoAutoRefillEnabled;

    public float refillStaminaRate = 18;
    public float refillStaminaDelayAfterUse;
    public float refillStaminaDelayAfterEmpty;

    public bool waitToStaminaFilledToUseAgain;

    [Space]
    [Header ("Stamina UI Settings")]
    [Space]

    public bool staminaObjectAlwaysActive;
    public float timeToDisableStaminaObject;

    public bool useFade;
    public float fadeSpeed;
    public float enabledAlphaValue;

    public bool useSliderCircle = true;

    [Space]
    [Header ("Stamina States Settings")]
    [Space]

    public List<staminaStateInfo> staminaStateInfoList = new List<staminaStateInfo> ();

    [Space]
    [Header ("Debug")]
    [Space]

    public bool staminaEmpty;
    public bool refillingStamina;
    public bool usingStamina;
    public bool staminaRefilled = true;

    public bool staminaUsePaused;

    public float totalStaminaRateAmount;

    public float customRefillStaminaDelayAfterUse;

    [Space]
    [Header ("Components")]
    [Space]

    public bool UIElementsAssigned = true;
    public Image circleStaminaSlider;

    public Text staminaAmountText;

    public GameObject staminaPanel;

    public Slider regularStaminaSlider;

    public CanvasGroup staminaCanvasGroup;

    float originalStaminaAmount;

    float lastTimeStaminaRefilled;
    float lastTimeStaminaUsed;

    Coroutine refillCoroutine;

    bool staminaSliderHidden;

    float auxStaminaAmount;

    bool useStaminaStateOnce;


    void Start ()
    {
        originalStaminaAmount = staminaAmount;
        auxStaminaAmount = staminaAmount;

        if (UIElementsAssigned) {
            if (!staminaObjectAlwaysActive || !showStaminaUIEnabled || !useStaminaEnabled) {
                if (staminaPanel.activeSelf) {
                    staminaPanel.SetActive (false);
                }
            }

            regularStaminaColor.a = enabledAlphaValue;
            closeToEmptyStaminaColor.a = enabledAlphaValue;

            if (useSliderCircle) {
                if (staminaAmountText != null) {
                    staminaAmountText.text = Mathf.RoundToInt (staminaAmount).ToString ();
                }

                circleStaminaSlider.color = regularStaminaColor;
            } else {
                regularStaminaSlider.maxValue = staminaAmount;

                regularStaminaSlider.value = staminaAmount;
            }
        }
    }

    void FixedUpdate ()
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (!staminaObjectAlwaysActive) {

            if (!refillingStamina) {
                if (UIElementsAssigned && !staminaSliderHidden) {
                    bool updateUIStateResult = false;

                    updateUIStateResult = (!autoRefillStaminaEnabled || staminaRefilled);

                    if (!autoRefillStaminaEnabled && !staminaRefilled) {
                        if (hideStaminaUIAfterDelayIfNoAutoRefillEnabled) {
                            updateUIStateResult = true;
                        } else {
                            updateUIStateResult = false;
                        }
                    }

                    if (updateUIStateResult) {
                        if (Time.time > lastTimeStaminaRefilled + timeToDisableStaminaObject || useFade) {
                            if (useFade) {
                                staminaCanvasGroup.alpha -= Time.deltaTime / fadeSpeed;

                                if (staminaCanvasGroup.alpha <= 0) {
                                    staminaSliderHidden = true;
                                }
                            } else {
                                if (!staminaSliderHidden) {
                                    if (staminaPanel.activeSelf) {
                                        staminaPanel.SetActive (false);
                                    }

                                    staminaSliderHidden = true;
                                }
                            }
                        }
                    }
                }
            }
        }

        if (autoRefillStaminaEnabled) {
            if (!refillingStamina) {
                if (!staminaRefilled && !usingStamina) {
                    if (Time.time > lastTimeStaminaUsed + refillStaminaDelayAfterUse && Time.time > lastTimeStaminaUsed + customRefillStaminaDelayAfterUse) {
                        if (!anyStaminaStateInUse ()) {
                            refillStamina (0);
                        }
                    }
                }
            }
        }

        if (!refillingStamina && usingStamina && !staminaUsePaused) {
            useStaminaAmount (totalStaminaRateAmount * Time.fixedDeltaTime);
        }
    }

    public bool anyStaminaStateInUse ()
    {
        for (int i = 0; i < staminaStateInfoList.Count; i++) {
            if (staminaStateInfoList [i].staminaStateInUse) {
                return true;
            }
        }

        return false;
    }

    public void activeStaminaStateWithCustomAmount (string staminaName, float customAmountToUse, float newDelayAfterUse)
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (staminaEmpty && (waitToStaminaFilledToUseAgain || staminaAmount <= 0) || customAmountToUse <= 0) {
            return;
        }

        for (int i = 0; i < staminaStateInfoList.Count; i++) {
            staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [i];

            if (currentStaminaStateInfoToCheck.Name.Equals (staminaName)) {
                if (!currentStaminaStateInfoToCheck.stateEnabled) {
                    return;
                }

                stopRefillCoroutine ();

                refillingStamina = false;

                staminaRefilled = false;

                if (currentStaminaStateInfoToCheck.useCustomRefillStaminaDelayAfterUse) {
                    if (newDelayAfterUse > 0) {
                        if (newDelayAfterUse > customRefillStaminaDelayAfterUse) {
                            customRefillStaminaDelayAfterUse = newDelayAfterUse;
                        }
                    } else {
                        if (currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse > customRefillStaminaDelayAfterUse) {
                            customRefillStaminaDelayAfterUse = currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse;
                        }
                    }
                } else {
                    if (newDelayAfterUse > 0) {
                        if (newDelayAfterUse > customRefillStaminaDelayAfterUse) {
                            customRefillStaminaDelayAfterUse = newDelayAfterUse;
                        }
                    } else {
                        customRefillStaminaDelayAfterUse = 0;
                    }
                }

                useStaminaAmount (customAmountToUse);
            }
        }
    }

    public void activeStaminaState (string staminaName)
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (staminaEmpty && (waitToStaminaFilledToUseAgain || staminaAmount <= 0)) {
            for (int i = 0; i < staminaStateInfoList.Count; i++) {
                staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [i];

                if (currentStaminaStateInfoToCheck.stateEnabled &&
                    !currentStaminaStateInfoToCheck.stateInPause &&
                    currentStaminaStateInfoToCheck.Name.Equals (staminaName)) {

                    currentStaminaStateInfoToCheck.eventOnStaminaEmpty.Invoke ();

                    return;
                }
            }

            return;
        }

        int stateIndex = staminaStateInfoList.FindIndex (s => s.Name == staminaName);

        if (stateIndex > -1) {
            staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [stateIndex];

            if (!currentStaminaStateInfoToCheck.stateInPause) {
                if (!currentStaminaStateInfoToCheck.stateEnabled) {
                    return;
                }

                if (!useStaminaStateOnce) {
                    currentStaminaStateInfoToCheck.staminaStateInUse = true;
                }

                totalStaminaRateAmount += currentStaminaStateInfoToCheck.staminaUseRate;

                if (useStaminaStateOnce) {
                    useStaminaAmount (currentStaminaStateInfoToCheck.staminaAmountToUseOnce);
                }

                stopRefillCoroutine ();

                refillingStamina = false;

                staminaRefilled = false;

                if (currentStaminaStateInfoToCheck.useCustomRefillStaminaDelayAfterUse) {
                    if (currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse > customRefillStaminaDelayAfterUse) {
                        customRefillStaminaDelayAfterUse = currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse;
                    }
                } else {
                    customRefillStaminaDelayAfterUse = 0;
                }

                if (!useStaminaStateOnce) {
                    usingStamina = true;
                }
            }
        }
    }

    public void useStaminaStateByName (string staminaName)
    {
        useStaminaStateOnce = true;

        activeStaminaState (staminaName);

        useStaminaStateOnce = false;
    }

    public void setStaminaStateAsPaused (string staminaName)
    {
        setStaminaPausedState (true, staminaName);
    }

    public void setStaminaStateAsNotPaused (string staminaName)
    {
        setStaminaPausedState (false, staminaName);
    }

    public void setStaminaPausedState (bool state, string staminaName)
    {
        if (!useStaminaEnabled) {
            return;
        }

        int stateIndex = staminaStateInfoList.FindIndex (s => s.Name == staminaName);

        if (stateIndex > -1) {
            staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [stateIndex];

            currentStaminaStateInfoToCheck.stateInPause = state;

            if (state) {
                if (currentStaminaStateInfoToCheck.stopStaminaStateIfPaused && currentStaminaStateInfoToCheck.staminaStateInUse) {
                    disableStaminaState (staminaName);
                }
            }
        }
    }

    public void useAllRemainStamina ()
    {
        if (staminaAmount == 0) {
            return;
        }

        useStaminaAmountExternally (staminaAmount);
    }

    public void useStaminaAmountExternally (float amount)
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (amount <= 0) {
            return;
        }

        stopRefillCoroutine ();

        refillingStamina = false;

        staminaRefilled = false;

        customRefillStaminaDelayAfterUse = 1;

        useStaminaAmount (amount);
    }

    public void setCustomRefillStaminaDelayAfterUseValue (float newValue)
    {
        if (!useStaminaEnabled) {
            return;
        }

        customRefillStaminaDelayAfterUse = newValue;
    }

    void useStaminaAmount (float amount)
    {
        lastTimeStaminaUsed = Time.time;

        if (UIElementsAssigned && showStaminaUIEnabled) {
            if (!staminaPanel.activeSelf) {
                staminaPanel.SetActive (true);
            }
        }

        if (useFade) {
            setStaminaSliderAlphaValue (enabledAlphaValue);
        }

        staminaSliderHidden = false;

        staminaAmount -= amount;

        if (staminaAmount < 0) {
            staminaAmount = 0;
        }

        if (UIElementsAssigned) {
            if (useSliderCircle) {
                if (staminaAmount <= closeToEmptyStaminaAmount) {
                    circleStaminaSlider.color = closeToEmptyStaminaColor;
                }

                circleStaminaSlider.fillAmount = staminaAmount / originalStaminaAmount;
            } else {
                regularStaminaSlider.value = staminaAmount;
            }

            if (staminaAmountText != null) {
                staminaAmountText.text = Mathf.RoundToInt (staminaAmount).ToString ();
            }
        }

        auxStaminaAmount = staminaAmount;

        if (staminaAmount <= 0) {
            setStaminaRefilledOrEmptyOnStateList (false);

            staminaEmpty = true;

            if (autoRefillStaminaEnabled) {
                if (!anyStaminaStateInUse ()) {
                    refillStamina (refillStaminaDelayAfterEmpty);
                }
            } else {
                lastTimeStaminaRefilled = Time.time;
            }
        }
    }

    public void disableStaminaState (string staminaName)
    {
        if (!useStaminaEnabled) {
            return;
        }

        for (int i = 0; i < staminaStateInfoList.Count; i++) {
            staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [i];

            if (currentStaminaStateInfoToCheck.stateEnabled) {
                if (currentStaminaStateInfoToCheck.Name.Equals (staminaName)) {
                    currentStaminaStateInfoToCheck.staminaStateInUse = false;

                    totalStaminaRateAmount -= currentStaminaStateInfoToCheck.staminaUseRate;

                    if (currentStaminaStateInfoToCheck.useCustomRefillStaminaDelayAfterUse) {
                        if (currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse > customRefillStaminaDelayAfterUse) {
                            customRefillStaminaDelayAfterUse = currentStaminaStateInfoToCheck.customRefillStaminaDelayAfterUse;
                        }
                    } else {
                        customRefillStaminaDelayAfterUse = 0;
                    }
                }
            }
        }

        if (totalStaminaRateAmount <= 0) {
            totalStaminaRateAmount = 0;
            usingStamina = false;
        }
    }

    public void disableCurrentStaminaState ()
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (usingStamina || anyStaminaStateInUse ()) {

            for (int i = 0; i < staminaStateInfoList.Count; i++) {
                if (staminaStateInfoList [i].staminaStateInUse) {
                    disableStaminaState (staminaStateInfoList [i].Name);

                    return;
                }
            }
        }
    }

    public void refillStamina (float refillDelay)
    {
        stopRefillCoroutine ();

        refillCoroutine = StartCoroutine (refillStaminaCoroutine (refillDelay));
    }

    public void stopRefillCoroutine ()
    {
        if (refillCoroutine != null) {
            StopCoroutine (refillCoroutine);
        }
    }

    IEnumerator refillStaminaCoroutine (float refillDelay)
    {
        refillingStamina = true;

        WaitForSeconds delay = new WaitForSeconds (refillDelay);

        yield return delay;

        if (!waitToStaminaFilledToUseAgain) {
            setStaminaRefilledOrEmptyOnStateList (true);
        }

        while (staminaAmount < originalStaminaAmount) {
            staminaAmount += Time.deltaTime * refillStaminaRate;

            if (UIElementsAssigned) {
                if (useSliderCircle) {
                    circleStaminaSlider.fillAmount = staminaAmount / originalStaminaAmount;
                } else {
                    regularStaminaSlider.value = staminaAmount;
                }
            }

            updateStaminaState ();

            yield return null;
        }

        if (waitToStaminaFilledToUseAgain) {
            setStaminaRefilledOrEmptyOnStateList (true);
        }

        refillingStamina = false;

        lastTimeStaminaRefilled = Time.time;

        staminaRefilled = true;

        staminaEmpty = false;

        totalStaminaRateAmount = 0;
    }

    public void getStamina (float amount)
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (!waitToStaminaFilledToUseAgain) {
            setStaminaRefilledOrEmptyOnStateList (true);
        }

        staminaAmount += amount;

        updateStaminaState ();

        if (waitToStaminaFilledToUseAgain) {
            setStaminaRefilledOrEmptyOnStateList (true);
        }

        staminaEmpty = false;
    }

    public void refillFullStamina ()
    {
        if (!useStaminaEnabled) {
            return;
        }

        getStamina (originalStaminaAmount);
    }

    void updateStaminaState ()
    {
        if (!useStaminaEnabled) {
            return;
        }

        if (UIElementsAssigned) {
            if (useSliderCircle) {
                circleStaminaSlider.fillAmount = staminaAmount / originalStaminaAmount;
            } else {
                regularStaminaSlider.value = staminaAmount;
            }

            if (staminaAmountText != null) {
                staminaAmountText.text = Mathf.RoundToInt (staminaAmount).ToString ();
            }

            if (staminaAmount > closeToEmptyStaminaAmount) {
                circleStaminaSlider.color = regularStaminaColor;
            }
        }

        if (staminaAmount >= originalStaminaAmount) {
            staminaAmount = originalStaminaAmount;
        }

        auxStaminaAmount = staminaAmount;
    }

    public void setStaminaSliderAlphaValue (float value)
    {
        if (UIElementsAssigned) {
            staminaCanvasGroup.alpha = value;
        }
    }

    public void increaseTotalStaminaAmount (float extraValue)
    {
        staminaAmount = originalStaminaAmount + extraValue;

        originalStaminaAmount = staminaAmount;

        auxStaminaAmount = staminaAmount;

        if (UIElementsAssigned) {
            if (!useSliderCircle) {
                regularStaminaSlider.maxValue = originalStaminaAmount;
            }
        }
    }

    public float getCurrentStaminaAmount ()
    {
        return staminaAmount;
    }

    public float getOriginalStaminaAmount ()
    {
        return originalStaminaAmount;
    }

    public void initializeStaminaAmount (float newValue)
    {
        staminaAmount = newValue;
    }

    public void updateStaminaAmountWithoutUpdatingStatManager (int statId, float amount)
    {
        staminaAmount = amount;
    }

    public void updateRefillStaminaRateAmountWithoutUpdatingStatManager (int statId, float amount)
    {
        refillStaminaRate = amount;
    }

    public void increaseTotalRefillStaminaRate (float extraValue)
    {
        refillStaminaRate = refillStaminaRate + extraValue;
    }

    public void initializeRefillStaminaRate (float newValue)
    {
        refillStaminaRate = newValue;
    }

    public void setStaminaUsePausedState (bool state)
    {
        staminaUsePaused = state;
    }

    public void setStaminaRefilledOrEmptyOnStateList (bool state)
    {
        for (int i = 0; i < staminaStateInfoList.Count; i++) {
            staminaStateInfo currentStaminaStateInfoToCheck = staminaStateInfoList [i];

            if (currentStaminaStateInfoToCheck.stateEnabled) {
                if (state) {
                    currentStaminaStateInfoToCheck.eventOnStaminaRefilled.Invoke ();
                } else {
                    currentStaminaStateInfoToCheck.eventOnStaminaEmpty.Invoke ();
                }
            }
        }
    }

    public float getStaminaAmountToLimit ()
    {
        return originalStaminaAmount - auxStaminaAmount;
    }

    public void addAuxStaminaAmount (float amount)
    {
        auxStaminaAmount += amount;
    }

    public void setUseStaminaEnabledState (bool state)
    {
        useStaminaEnabled = state;
    }

    public void setShowStaminaUIEnabledState (bool state)
    {
        showStaminaUIEnabled = state;

        if (!showStaminaUIEnabled) {
            if (GKC_Utils.isApplicationPlaying ()) {
                if (UIElementsAssigned) {
                    if (staminaPanel.activeSelf) {
                        staminaPanel.SetActive (false);
                    }
                }
            }
        }
    }

    public void setShowStaminaUIEnabledStateOnEditor (bool state)
    {
        setShowStaminaUIEnabledState (state);

        updateComponent ();
    }

    public void setUseStaminaEnabledStateFromEditor (bool state)
    {
        setUseStaminaEnabledState (state);

        updateComponent ();
    }

    void updateComponent ()
    {
        GKC_Utils.updateComponent (this);

        GKC_Utils.updateDirtyScene ("Update Stamina System", gameObject);
    }

    [System.Serializable]
    public class staminaStateInfo
    {
        [Header ("Main Settings")]
        [Space]

        public string Name;
        public bool stateEnabled = true;
        public float staminaUseRate;

        public float staminaAmountToUseOnce;

        [Space]
        [Header ("Other Settings")]
        [Space]

        public bool useCustomRefillStaminaDelayAfterUse;
        public float customRefillStaminaDelayAfterUse;

        public bool stopStaminaStateIfPaused;

        [Space]
        [Header ("Debug")]
        [Space]

        public bool staminaStateInUse;
        public bool stateInPause;

        [Space]
        [Header ("Event Settings")]
        [Space]

        public UnityEvent eventOnStaminaEmpty;
        public UnityEvent eventOnStaminaRefilled;
    }
}