using System.Collections;
using Unity.Cinemachine;
using UnityEngine;

namespace RR.Game2D.Behaviour.Camera
{
    public class CameraManager : MonoBehaviour
    {
        public static CameraManager instance;

        [SerializeField] private CinemachineCamera[] _allVirtualCameras;

        [SerializeField] private float _fallPanAmount = 0.25f;
        [SerializeField] private float _fallYPanTime = 0.35f;
        public float _fallSpeedYDampingChangeThreshold = -15f;

        public bool IsLerpingYDamping { get; private set; }
        public bool LerpedFromPlayerFalling { get; set; }

        private Coroutine _lerpYPanCoroutine;
        private Coroutine _panCameraCoroutine;

        private CinemachineCamera _currentCamera;
        private CinemachinePositionComposer _positionComposer;

        private float _normalYPanAmount;

        private Vector2 _startingTrackedObjectOffset;

        private void Awake()
        {
            if (instance == null)
            {
                instance = this;
            }

            for (int i = 0; i < _allVirtualCameras.Length; i++)
            {
                if (_allVirtualCameras[i].enabled)
                {
                    _currentCamera = _allVirtualCameras[i];

                    _positionComposer = _currentCamera.GetComponent<CinemachinePositionComposer>();
                }
            }

            _normalYPanAmount = _positionComposer.Damping.y;

            _startingTrackedObjectOffset = _positionComposer.TargetOffset;
        }

        #region Lerp Y Damping

        public void LerpYDamping(bool isPlayerFalling)
        {
            _lerpYPanCoroutine = StartCoroutine(LerpYAction(isPlayerFalling));
        }

        private IEnumerator LerpYAction(bool isPlayerFalling)
        {
            IsLerpingYDamping = true;

            float startDampAmount = _positionComposer.Damping.y;
            float endDampAmount = 0f;

            if (isPlayerFalling)
            {
                endDampAmount = _fallPanAmount;
                LerpedFromPlayerFalling = true;
            }
            else
            {
                endDampAmount = _normalYPanAmount;
            }

            float elapsedTime = 0f;
            while (elapsedTime < _fallYPanTime)
            {
                elapsedTime += Time.deltaTime;

                float lerpedPanAmount = Mathf.Lerp(startDampAmount, endDampAmount, (elapsedTime / _fallYPanTime));
                _positionComposer.Damping.y = lerpedPanAmount;

                yield return null;
            }

            IsLerpingYDamping = false;
        }

        #endregion

        #region Pan camera

        public void PanCameraOnContact(float panDistance, float panTime, PanDirection panDirection, bool panToStartingPos)
        {
            _panCameraCoroutine = StartCoroutine(PanCamera(panDistance, panTime, panDirection, panToStartingPos));
        }

        private IEnumerator PanCamera(float panDistance, float panTime, PanDirection panDirection, bool panToStartingPos)
        {
            Vector2 endPos = Vector2.zero;
            Vector2 startPos = Vector2.zero;

            if (!panToStartingPos)
            {
                switch (panDirection)
                {
                    case PanDirection.Up:
                        endPos = Vector2.up;
                        break;
                    case PanDirection.Down:
                        endPos = Vector2.down;
                        break;
                    case PanDirection.Left:
                        endPos = Vector2.left;
                        break;
                    case PanDirection.Right:
                        endPos = Vector2.right;
                        break;
                    default:
                        break;
                }

                endPos *= panDistance;
                startPos = _startingTrackedObjectOffset;
                endPos += startPos;
            }
            else
            {
                startPos = _positionComposer.TargetOffset;
                endPos = _startingTrackedObjectOffset;
            }

            float elapsedTime = 0f;
            while (elapsedTime < panTime)
            {
                elapsedTime += Time.deltaTime;

                Vector3 panLerp = Vector3.Lerp(startPos, endPos, (elapsedTime / panTime));
                _positionComposer.TargetOffset = panLerp;

                yield return null;
            }

        }

        #endregion
    }
}