using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Beyond { 
    public class DistanceAlphaFader : MonoBehaviour
    {
        protected Camera m_Camera;
        public enum Mode { KEEP_SHOWING, SHOW_WHEN_CLOSE, SHOW_ONCE, FROM_CURVE, REMOTELY_CONTROLLED };
        public enum State { HIDDEN, FADE_IN, SHOW, FADE_OUT, ENDED };
        State m_State = State.HIDDEN;
        public Mode m_Mode = Mode.SHOW_WHEN_CLOSE;
        [Tooltip("Minimum distance at which the tag is shown - used to calculate blend value")]
        public float m_MinDist = 5f;
        [Tooltip("Maximum distance at which the tag is shown")]
        public float m_MaxDist = 10f;
        [Tooltip("Works in SHOW_ONCE mode. How long should it show?")]
        public float m_ShotTime = 5f;
        public float m_FadeTime = 1f;
        protected float m_timer = 0f;
        protected float m_alpha;

        public AnimationCurve m_curve;
        // bool m_active = true;
        // public void SetActive(bool active)
        // {
        //     m_active = active;
        // }
        private void OnDisable()
        {
            SetAlpha(0.0f);
        }
        public void SetMode(Mode mode)
        {
            m_Mode = mode;
            switch (m_Mode)
            {
                case Mode.KEEP_SHOWING:
                case Mode.FROM_CURVE:
                    m_State = State.SHOW;
                    break;
                case Mode.SHOW_WHEN_CLOSE:
                case Mode.SHOW_ONCE:
                    m_State = State.HIDDEN;
                    break;
            }
            switch (m_State)
            {
                case State.HIDDEN:
                case State.FADE_IN:
                   SetAlpha(0f);
                    break;
                case State.SHOW:
                    SetAlpha(1f);
                    break;
            }

        }
        virtual protected void Awake()
        {
          
        }

        // Start is called before the first frame update
        virtual protected void Start()
        {
            SetMode(m_Mode);
            m_Camera = Camera.main;
        }

        virtual public void SetAlpha(float a)
        {
            m_alpha = a;
        }

        // Update is called once per frame
        virtual protected void Update()
        {
            //if (m_TurnToCamera)
            //{
            //    transform.rotation = m_Camera.transform.rotation;
            //}
            Vector3 diff = transform.position - m_Camera.transform.position;
            float dist = diff.magnitude;
            switch (m_Mode)
            {
                case Mode.KEEP_SHOWING:
                    break;
                case Mode.FROM_CURVE:
                    SetAlpha(Mathf.Clamp01(m_curve.Evaluate(dist)));
                    break;
                case Mode.SHOW_ONCE:
                 //   if (!m_active)
                 //       break;
                    switch (m_State)
                    {
                        case State.HIDDEN:
                            if (dist < m_MaxDist)
                            {
                                m_State = State.FADE_IN;
                                m_timer = 0f;
                            }
                            else
                            {
                                SetAlpha(0f);
                            }
                            break;
                        case State.FADE_IN:
                            if (m_timer > m_FadeTime)
                            {
                                SetAlpha(1f);
                                m_State = State.SHOW;
                                m_timer = 0f;
                            }
                            else
                            {
                                SetAlpha(m_timer / m_FadeTime);
                            }
                            break;
                        case State.FADE_OUT:
                            if (m_timer > m_FadeTime)
                            {
                                SetAlpha(0f);
                                m_State = State.ENDED;
                                m_timer = 0f;
                            }
                            else
                            {
                                SetAlpha(1.0f - m_timer / m_FadeTime);
                            }
                            break;
                        case State.SHOW:
                            if (m_timer > m_ShotTime)
                            {
                                m_State = State.FADE_OUT;
                                m_timer = 0f;
                            }
                            break;
                    }
                    break;
                case Mode.SHOW_WHEN_CLOSE:
                    if (dist > m_MaxDist)
                    {
                        SetAlpha(0f);
                    }
                    else if (dist < m_MinDist)
                    {
                        SetAlpha(1f);
                    }
                    else
                    {
                        SetAlpha((m_MaxDist - dist) / (m_MaxDist - m_MinDist));
                    }
                    break;
            }

            m_timer += Time.deltaTime;
        }
    }
}