using System.Collections;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;

public class DraggableHandler : MonoBehaviour, IBeginDragHandler, IEndDragHandler, IDragHandler
{
    [SerializeField] private RectTransform objectHolder;
    [SerializeField] private int dragMargin;
    [SerializeField] private UnityEvent onDragComplete;
    [SerializeField] private UnityEvent onExitScreen;
    [SerializeField] private UnityEvent onDragLessThenMargin;

    private Vector2 startingPosition;
    private Vector2 startingClickPosition;
    private bool isDragging;
    private Canvas parentCanvas;
    private RectTransform canvasRectTransform;
    private Vector2 dragOffset;
    private Vector2 lastPointerPosition;
    private bool isAnimating;

    private void Awake()
    {
        InitializeComponents();
    }

    private void InitializeComponents()
    {
        startingPosition = objectHolder.anchoredPosition;
        parentCanvas = GetComponentInParent<Canvas>();
        canvasRectTransform = parentCanvas.GetComponent<RectTransform>();
    }

    public void OnBeginDrag(PointerEventData _eventData)
    {
        if (isAnimating)
        {
            return;
        }
        isDragging = true;
        startingClickPosition = _eventData.position;
        lastPointerPosition = GetLocalPoint(_eventData.position);
        dragOffset = objectHolder.anchoredPosition - lastPointerPosition;
    }

    public void OnEndDrag(PointerEventData _eventData)
    {
        if (!isDragging)
        {
            return;
        }

        isDragging = false;
        var _distanceDragged = Mathf.Abs(startingClickPosition.y - _eventData.position.y);
        if (_distanceDragged<=dragMargin)
        {
            StartCoroutine(AnimateBackToStartingPosition());
        }
        else
        {
            onDragComplete?.Invoke();
        }
    }

    private IEnumerator AnimateBackToStartingPosition(float _duration = 0.1f)
    {
        float _elapsed = 0f;
        Vector2 _currentPos = objectHolder.anchoredPosition;
        isAnimating = true;
        while (_elapsed < _duration)
        {
            objectHolder.anchoredPosition = Vector2.Lerp(_currentPos, startingPosition, _elapsed / _duration);
            _elapsed += Time.deltaTime;
            yield return null;
        }
        isAnimating = false;

        objectHolder.anchoredPosition = startingPosition;
    }


    public void OnDrag(PointerEventData _eventData)
    {
        if (!isDragging)
        {
            return;
        }

        SetNewPosition(_eventData);
        CheckScreenVisibility();
    }

    private void SetNewPosition(PointerEventData _eventData)
    {
        Vector2 _localPoint = GetLocalPoint(_eventData.position);
        lastPointerPosition = _localPoint;

        float _newY = Mathf.Min((_localPoint + dragOffset).y, startingPosition.y);
        objectHolder.anchoredPosition = new Vector2(objectHolder.anchoredPosition.x, _newY);
    }

    private Vector2 GetLocalPoint(Vector2 _position)
    {
        Camera _camera = parentCanvas.renderMode == RenderMode.ScreenSpaceOverlay ? null : parentCanvas.worldCamera;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRectTransform, _position, _camera, out Vector2 _localPoint);

        return _localPoint;
    }

    private void CheckScreenVisibility()
    {
        if (IsObjectVisible())
        {
            return;
        }

        isDragging = false;
        onExitScreen?.Invoke();
    }

    private bool IsObjectVisible()
    {
        Vector3[] _corners = new Vector3[4];
        objectHolder.GetWorldCorners(_corners);

        Camera _camera = parentCanvas.renderMode == RenderMode.ScreenSpaceOverlay ? null : parentCanvas.worldCamera;
        Rect _screenRect = new Rect(0, 0, Screen.width, Screen.height);

        foreach (var _corner in _corners)
        {
            Vector3 _screenPoint = _camera ? _camera.WorldToScreenPoint(_corner) : _corner;
            if (_screenRect.Contains(new Vector2(_screenPoint.x, _screenPoint.y)))
            {
                return true;
            }
        }

        return false;
    }
}