using System;
using System.Collections;
using System.Collections.Generic;
using PixelCrushers;
using Sirenix.OdinInspector;
using UnityEngine;

//using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

namespace Beyond
{
    [RequireComponent(typeof(CanvasGroup))]
    public class FadeCanvasGroup : Saver
    {
        private static FadeCanvasGroup _instance;
        public UnityEvent OnLoadingFadeOutEnd;
        public UnityEvent OnFadeInEnd;
        public UnityEvent OnFadeOutEnd;

        private bool isFadingBeforLoading;

        public static FadeCanvasGroup Instance
        {
            get
            {
                //CreateInstance();
                return _instance;
            }
        }

        public CanvasGroup canvasGroup;
        private AnimationCurve curve;
        private float fadeTime = 1f;
        private float time;
        private float fadeDelay = .2f;

        public enum State
        { IDLE, FADE_IN, FADE_OUT_IN, FADE_DELAY, FADE_OUT };

        private State state = State.IDLE;
        private Coroutine m_delayedFade;

        public static void CreateInstance()
        {
            if (_instance == null)
            {
                _ = Instantiate(Resources.Load("CANVAS OVERLAY", typeof(GameObject))) as GameObject;
            }
        }

        private void Awake()
        {
            if (_instance == null)
            {
                _instance = this;
                /*
                if (gameObject.transform.parent)
                {
                    DontDestroyOnLoad(gameObject.transform.parent.gameObject);
                }
                else
                {
                    DontDestroyOnLoad(gameObject);
                }
                */
            }
            else if (_instance != this)
            {
                Debug.LogError("Multiple Fade canvases!, Destroying...");
                Destroy(this);
            }

            var canvas = GetComponent<Canvas>();
            if (canvas)
            {
                canvas.sortingOrder = 1000;
            }
            canvasGroup = GetComponent<CanvasGroup>();
            canvasGroup.alpha = 1f;
            canvasGroup.interactable = false;
            canvasGroup.blocksRaycasts = false;
            //BeforeLoadingFade();
        }

        private void OnEnable()
        {
            SceneManager.sceneLoaded += OnSceneLoaded;
        }

        private void OnSceneLoaded(Scene arg0, LoadSceneMode arg1)
        {
            //fadeTime = 2f;
            //SetState(State.FADE_IN);
            DelayedFadeIn(2f, 2f);
        }

        public void BeforeLoadingFade()
        {
            fadeTime = 1f;
            isFadingBeforLoading = true;
            SetState(State.FADE_OUT);
        }

        private void OnDisable()
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
        }

        public override string RecordData()
        {
            return "";
        }

        public override void ApplyData(string s)
        {
            //FadeIn(1f);
        }

        public void DelayedFadeIn(float time, float delay)
        {
            m_delayedFade = StartCoroutine(DelayedFade(State.FADE_IN, time, delay));
        }

        private IEnumerator DelayedFade(State s, float time, float delay)
        {
            yield return new WaitForSecondsRealtime(delay);
            fadeTime = time;
            SetState(s);
        }

        public void SetState(State s)
        {
            if (m_delayedFade != null)
            {
                //return;
                StopCoroutine(m_delayedFade);
                m_delayedFade = null;
            }

            switch (s)
            {
                case State.IDLE:
                    if (isFadingBeforLoading)
                    {
                        isFadingBeforLoading = false;
                        OnLoadingFadeOutEnd?.Invoke();
                    }
                    break;

                case State.FADE_IN:
                    if (state == State.FADE_DELAY || state == State.FADE_OUT_IN)
                    {
                        DelayedFadeIn(fadeTime, fadeDelay);
                        canvasGroup.alpha = 1f;

                        state = State.IDLE;
                        time = 0f;
                        return;
                    }
                    break;

                case State.FADE_OUT:
                    break;

                case State.FADE_OUT_IN:
                    break;
            }
            state = s;

            time = 0f;
        }

        public void Update()
        {
            float a = 0f;
            switch (state)
            {
                case State.IDLE:
                    break;

                case State.FADE_IN:
                    if (time > fadeTime)
                    {
                        a = 0;
                        SetState(State.IDLE);
                        OnFadeInEnd?.Invoke();
                    }
                    else
                    {
                        a = 1f - time / fadeTime;
                    }
                    canvasGroup.alpha = a;
                    break;

                case State.FADE_OUT:
                    if (time > fadeTime)
                    {
                        a = 1f;
                        SetState(State.IDLE);
                        OnFadeOutEnd?.Invoke();
                    }
                    else
                    {
                        a = time / fadeTime;
                    }
                    canvasGroup.alpha = a;
                    break;

                case State.FADE_OUT_IN:
                    /*
                    if (time > fadeTime)
                    {
                        a = 0f;
                        SetState(State.IDLE);
                    }
                    else
                    {
                        float t = time / fadeTime;
                        if (t <  0.5)
                        {
                            a = t * 2f;
                        }
                        else
                        {
                            a = 2f - 2f*t;
                        }
                    }
                    */
                    if (time > fadeTime)
                    {
                        a = 1f;
                        SetState(State.FADE_DELAY);
                        OnFadeOutEnd?.Invoke();
                    }
                    else
                    {
                        a = time / fadeTime;
                    }
                    canvasGroup.alpha = a;
                    break;

                case State.FADE_DELAY:
                    if (time > fadeDelay)
                    {
                        SetState(State.FADE_IN);
                    }
                    break;
            }

            time += Time.deltaTime;
        }

        [Button]
        public void FadeIn(float fadeTime)
        {
            this.fadeTime = fadeTime;
            SetState(State.FADE_IN);
        }

        [Button]
        public void FadeOut(float fadeTime)
        {
            this.fadeTime = fadeTime;
            SetState(State.FADE_OUT);
        }

        public void FadeButtonClick()
        {
            Debug.Log("FadeButton click");
        }
/*
        private void OnValidate()
        {
            var canvas = GetComponent<Canvas>();
            if (canvas)
            {
                canvas.sortingOrder = 1000;
            }
            canvasGroup = GetComponent<CanvasGroup>();
            canvasGroup.alpha = 0f;
            canvasGroup.interactable = false;
            canvasGroup.blocksRaycasts = false;
        }
*/
        [Button]
        public void FadeOutIn(float t)
        {
            fadeTime = t;
            SetState(State.FADE_OUT_IN);
        }
    }
}