using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using Amrita.Meta.ScriptableObjects;
using Amrita.Meta.Audio;
using System;

namespace Amrita.Meta.Utility
{
    public class ButtonOnClickController : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IPointerClickHandler
    {
        private const float CLICK_COOLDOWN = 100f;
        private const float HOVER_DELAY = 0.3f;
        public bool Interactable
        {
            get { return m_interactable; }
            set
            {
                m_interactable = value;
                IsInteractable();
            }
        }
        public Material disabledMaterial;
        public Image targetImage;
        public Transform trToTween;
        public bool isScrollable;
        public bool shouldBeDisabled;
        public Button.ButtonClickedEvent onClick;
        public Button.ButtonClickedEvent onPointerDown;
        public AnimationData AnimationData;
        [SerializeField] private bool m_interactable = true;
        [SerializeField] private bool m_canPlaySound = false;
        private Vector2 m_startPos;
        private Vector2 m_endPos;

        private RectTransform m_rectTransform;
        private bool m_isClicked;
        private Camera m_camera;
        private DateTime m_clickDateTime;

        private void OnEnable()
        {
            trToTween.localScale = Vector3.one;
        }

        private void Awake()
        {
            if (shouldBeDisabled)
            {
                targetImage = GetComponent<Image>();
                disabledMaterial = disabledMaterial == null ? Resources.Load<Material>("DesaturatedButtonsUI") : disabledMaterial;
            }

            m_clickDateTime = DateTime.Now;
            m_camera = Camera.main;
            m_rectTransform = GetComponent<RectTransform>();
            trToTween = trToTween == null ? transform : trToTween;
            AnimationData = AnimationData == null ? Resources.Load<AnimationData>("GamePlaySO/AnimationsData/OnClickAnimationData") : AnimationData;
        }

        public void IsInteractable()
        {
            if (shouldBeDisabled)
            {
                targetImage.material = m_interactable ? null : disabledMaterial;
            }
        }
        public void OnHover()
        {
            if (gameObject.activeInHierarchy)
            {
                StartCoroutine(RunPointerAnimation(AnimationData.OnHoverTime, AnimationData.OnHoverCurve));
            }

        }

        public void OnPointerClick()
        {
            OnPointerClick(null);
        }

        public void OnPointerClick(PointerEventData eventData)
        {
            if (m_interactable && isScrollable)
            {
                OnHover();
                InvokeOnClick();
                if (m_canPlaySound)
                {
                    MetaAudioManager.Instance.PlayUIAudio(UIAudioType.OkButton);
                }
                m_isClicked = true;
            }
        }


        public void OnPointerUp(PointerEventData eventData)
        {
            if (m_interactable)
            {
                if (isScrollable)
                {
                    m_endPos = eventData.position;
                    var diff = Mathf.Abs(Vector2.Distance(m_startPos, m_endPos));

                    if (diff <= 5f)
                    {

                        onClick.Invoke();
                        if (m_canPlaySound)
                        {
                            MetaAudioManager.Instance.PlayUIAudio(UIAudioType.OkButton);
                        }
                        m_isClicked = true;
                    }
                    else
                    {
                        OnHover();
                    }

                }
                else
                {
                    OnHover();
                    InvokeOnClick();
                    if (m_canPlaySound)
                    {
                        MetaAudioManager.Instance.PlayUIAudio(UIAudioType.OkButton);
                    }
                    m_isClicked = true;
                }

            }
        }

        private void InvokeOnClick()
        {
            var clickTime = DateTime.Now;
            var span = clickTime - m_clickDateTime;
            if (span.TotalMilliseconds > CLICK_COOLDOWN)
            {
                onClick.Invoke();
                m_clickDateTime = clickTime;
            }
        }

		private IEnumerator WaitUntilUp()
		{
			yield return new WaitForSeconds(HOVER_DELAY);
			var pos = Input.mousePosition;

				if (RectTransformUtility.RectangleContainsScreenPoint(m_rectTransform,pos,m_camera))
				{
					if(!m_isClicked)
					{
						onClick.Invoke();
					}
				}
				else
				{
					m_isClicked = false;
				}

		}

        public void OnPointerDown(PointerEventData eventData)
		{
			if(m_interactable)
			{
                m_startPos = eventData.position;
				onPointerDown.Invoke();
				StartCoroutine(RunPointerAnimation(AnimationData.OnClickTime,AnimationData.OnClickCurve));
			}
		}

		private IEnumerator RunPointerAnimation(float animationLength, AnimationCurve animationCurve)
		{
			var timeElapsed = 0f;
			while(timeElapsed < animationLength)
			{
				timeElapsed += Time.deltaTime;
				yield return new WaitForEndOfFrame();
				var currentValue = animationCurve.Evaluate(timeElapsed);
				trToTween.localScale = new Vector3(currentValue,currentValue,currentValue);
			}
		}

		private void OnDisable()
		{
			StopAllCoroutines();
		}
	}
}