using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Video;

//using UnityEditor.Events;
using Sirenix.OdinInspector;

namespace Beyond
{
    [RequireComponent(typeof(VideoPlayer))]
    [RequireComponent(typeof(RawImage))]
    public class VideoCutsceneController : MonoBehaviour
    {
        public OnVideoStart OnVideoStart = new OnVideoStart();
        public OnVideoEnd OnVideoEnd = new OnVideoEnd();

        private VideoPlayer m_videoPlayer;
        public VideoClip m_clipToPlay;
        public CanvasGroup m_canvasGroup;
        public Canvas m_canvas;
        private RawImage m_rawImage;

        private enum State
        {
            IDLE,
            FADING_IN,
            PLAYING,
            FADING_OUT
        };

        private State m_state = State.IDLE;
        private float m_alpha = 0f;
        public float m_speed = 1f;
        public bool m_skipFadeIn;
        public bool m_skipFadeOut;

        public bool m_dontEnableUI = false;

        private static VideoCutsceneController s_instance;
        //private static bool m_wasLoaded = false;
        private const string RESOURCE_PATH = "Prefabs/VideoCutsceneCanvas Variant";

        public static VideoCutsceneController Instance
        {
            get
            {
                if (s_instance)
                {
                    return s_instance;
                }
                else
                {
                    var controller = FindObjectOfType<VideoCutsceneController>();
                    if (controller != null)
                    {
                        s_instance = controller;
                        return s_instance;
                    }
                    else
                    {
                        var resource = Resources.Load<GameObject>(RESOURCE_PATH);
                        if (resource)
                        {
                            //m_wasLoaded = true;
                            var gameobject = Instantiate<GameObject>(resource);
                            if (gameobject)
                            {
                                controller = gameobject.GetComponentInChildren<VideoCutsceneController>();
                                if (controller != null)
                                {
                                    s_instance = controller;
                                    return s_instance;
                                }
                                else
                                {
                                    Debug.LogError("Error initalizing video canvas");
                                }
                            }
                        }
                        else
                        {
                            Debug.LogError("Couldn't load resouce: " + RESOURCE_PATH);
                        }

                        return null;
                    }
                }
            }
        }

        private void Awake()
        {
            m_videoPlayer = GetComponent<VideoPlayer>();
            if (m_videoPlayer == null)
            {
                Debug.LogError("No video player!");
                enabled = false;
                return;
            }

            m_videoPlayer.playOnAwake = false;
            m_videoPlayer.Stop();
            if (m_canvasGroup == null)
                m_canvasGroup = gameObject.FindComponentUpHierarchy<CanvasGroup>();
            if (m_canvas == null)
                m_canvas = gameObject.FindComponentUpHierarchy<Canvas>();
            m_rawImage = GetComponent<RawImage>();
            SetState(State.IDLE);
            m_canvas.enabled = false;
            m_canvasGroup.alpha = 1.0f; 
        }

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

        [Button]
        public void PlayVideo()
        {
            m_videoPlayer.frame = 0;

            OnStartPlaying();
            SetState(State.FADING_IN);
        }

        public void PlayVideo(VideoClip clip)
        {
            m_clipToPlay = clip;
            PlayVideo();
        }

        private void SetState(State s)
        {
            switch (s)
            {
                case State.IDLE:
                    m_rawImage.enabled = false;
                    m_alpha = 0f;
                    m_canvasGroup.alpha = m_alpha;
                    m_canvas.enabled = false;
                    if (Player.Instance != null && Player.Instance.ThirdPersonController != null)
                    {
                        Player.Instance.ThirdPersonController.isImmortal = false;
                    }
                    break;

                case State.FADING_IN:

                    if (m_skipFadeIn)
                    {
                        m_alpha = 1f;
                        m_canvasGroup.alpha = m_alpha;
                        SetState(State.PLAYING);
                    }
                    else
                    {
                        m_alpha = 0f;
                        m_canvasGroup.alpha = m_alpha;
                    }

                    break;

                case State.FADING_OUT:
                    OnFinishPlaying();
                    if (m_skipFadeOut)
                        SetState(State.IDLE);
                    /*
                    HideUI.InvokeSetActiveUI(true);
                    if (SkipCanvas.Instance.gameObject.activeSelf)
                    {
                        SkipCanvas.Instance.gameObject.SetActive(false);
                        SkipCanvas.Instance.m_OnSkip -= Skip;
                        SkipCanvas.Instance.m_OnPause -= Pause;
                        SkipCanvas.Instance.m_OnRestart -= Replay;
                    }

                    m_alpha = 1f;
                    if (Player.Instance != null)
                    {
                        var dc = Player.Instance.GetComponent<bDrawHideMeleeWeapons>();
                        if (dc != null)
                        {
                            dc.HideWeapons(true);
                        }
                    }
                    */
                    break;

                case State.PLAYING:
                    if (m_clipToPlay != null)
                        m_videoPlayer.clip = m_clipToPlay;
                    m_videoPlayer.Play();
                    break;
            }

            m_state = s;
        }

        private void OnStartPlaying()
        {
            m_canvas.enabled = true;
            HideUI.InvokeSetActiveUI(false);
            SkipCanvas.Instance.gameObject.SetActive(true);
            SkipCanvas.Instance.m_OnSkip += Skip;
            SkipCanvas.Instance.m_OnPause += Pause;
            SkipCanvas.Instance.m_OnRestart += Replay;
        }

        private void OnFinishPlaying()
        {
            if (m_dontEnableUI)
                HideUI.InvokeSetActiveUI(true);
            if (SkipCanvas.Instance.gameObject.activeSelf)
            {
                SkipCanvas.Instance.gameObject.SetActive(false);
                SkipCanvas.Instance.m_OnSkip -= Skip;
                SkipCanvas.Instance.m_OnPause -= Pause;
                SkipCanvas.Instance.m_OnRestart -= Replay;
            }

            m_alpha = 1f;
            if (Player.Instance != null)
            {
                var dc = Player.Instance.GetComponent<bDrawHideMeleeWeapons>();
                if (dc != null)
                {
                    dc.HideWeapons(true);
                }
            }
            //if (m_dontEnableUI)
            //{
                OnVideoEnd?.Invoke();
            //}
        }

        // Update is called once per frame
        private void Update()
        {
            switch (m_state)
            {
                case State.FADING_IN:
                    m_alpha += Time.deltaTime * m_speed;

                    if (m_alpha > 1f)
                    {
                        OnVideoStart.Invoke();
                        m_alpha = 1f;
                        SetState(State.PLAYING);
                    }

                    m_canvasGroup.alpha = m_alpha;

                    break;

                case State.FADING_OUT:
                    m_alpha -= Time.deltaTime * m_speed;
                    if (m_alpha < 0f)
                    {
                        m_alpha = 0f;
                        SetState(State.IDLE);
                    }

                    m_canvasGroup.alpha = m_alpha;
                    break;

                case State.PLAYING:
                    if (m_videoPlayer.frame >= (long)m_videoPlayer.frameCount - 1)
                    {
                        //isImmortal stays here
                        SetState(State.FADING_OUT);
                    }
                    else if (m_videoPlayer.frame > 0 && !m_rawImage.enabled)
                        m_rawImage.enabled = true;

                    break;

                case State.IDLE:
                    break;
            }
        }

        [Button]
        public void Replay()
        {
            m_videoPlayer.frame = 0;
        }

        [Button]
        public void Pause()
        {
            if (!m_videoPlayer.isPaused)
            {
                m_videoPlayer.Pause();
            }
            else
            {
                m_videoPlayer.Play();
            }
        }

        [Button]
        public void Skip()
        {
            m_videoPlayer.frame = (long)m_videoPlayer.frameCount - 1;
            //OnVideoEnd?.Invoke();
            SetState(State.FADING_OUT);
            m_skipFadeIn = false;
        }

        public bool IsPlaying()
        {
            return m_videoPlayer.isPlaying || m_state != State.IDLE;
        }
    }

    [System.Serializable]
    public class OnVideoStart : UnityEngine.Events.UnityEvent
    {
    }

    [System.Serializable]
    public class OnVideoEnd : UnityEngine.Events.UnityEvent
    {
    }
}