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

namespace BF
{
    public static class BFGesture
    {
        /// <summary>
        /// 获取当前手势中心屏幕坐标
        /// </summary>
        public static Vector2 GetScreenCenter()
        {
            return GetScreenCenter(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手势中心屏幕坐标
        /// </summary>
        public static Vector2 GetScreenCenter(List<BFFinger> fingers)
        {
            var center = Vector2.zero;
            TryGetScreenCenter(fingers, ref center);
            return center;
        }

        /// <summary>
        /// 获取手势中心屏幕坐标
        /// </summary>
        private static bool TryGetScreenCenter(List<BFFinger> fingers, ref Vector2 center)
        {
            if (fingers != null)
            {
                var total = Vector2.zero;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    BFFinger finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.curScreenPos;
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    center = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取手势上一帧中心屏幕坐标
        /// </summary>
        public static Vector2 GetLastScreenCenter()
        {
            return GetLastScreenCenter(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手势上一帧中心屏幕坐标
        /// </summary>
        public static Vector2 GetLastScreenCenter(List<BFFinger> fingers)
        {
            var center = Vector2.zero;
            TryGetLastScreenCenter(fingers, ref center);
            return center;
        }

        /// <summary>
        /// 获取手势上一帧中心屏幕坐标
        /// </summary>
        static bool TryGetLastScreenCenter(List<BFFinger> fingers, ref Vector2 center)
        {
            if (fingers != null)
            {
                var total = Vector2.zero;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    BFFinger finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.lastScreenPos;
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    center = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取手势起始中心屏幕坐标
        /// </summary>
        public static Vector2 GetStartScreenCenter()
        {
            return GetStartScreenCenter(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手势起始中心屏幕坐标
        /// </summary>
        public static Vector2 GetStartScreenCenter(List<BFFinger> fingers)
        {
            var center = Vector2.zero;
            TryGetScreenCenter(fingers, ref center);
            return center;
        }

        /// <summary>
        /// 获取手势起始中心屏幕坐标
        /// </summary>
        static bool TryGetStartScreenCenter(List<BFFinger> fingers, ref Vector2 center)
        {
            if (fingers != null)
            {
                var total = Vector2.zero;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.startScreenPos;
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    center = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取所有手指平均的屏幕坐标增量
        /// </summary>
        public static Vector2 GetScreenDelta()
        {
            return GetScreenDelta(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手指平均的屏幕坐标增量
        /// </summary>
        public static Vector2 GetScreenDelta(List<BFFinger> fingers)
        {
            var delta = Vector2.zero;
            TryGetScreenDelta(fingers, ref delta);
            return delta;
        }

        /// <summary>
        /// 获取手指平均的屏幕坐标增量
        /// </summary>
        static bool TryGetScreenDelta(List<BFFinger> fingers, ref Vector2 delta)
        {
            if (fingers != null)
            {
                var total = Vector2.zero;
                int count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.ScreenDelta;
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    delta = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取所有手指平均世界坐标增量
        /// </summary>
        public static Vector3 GetWorldDelta(float distance, Camera camera = null)
        {
            return GetWorldDelta(BFMain.Instance.TouchMgr.fingers, distance, camera);
        }

        /// <summary>
        /// 获取手指平均世界坐标增量
        /// </summary>
        public static Vector3 GetWorldDelta(List<BFFinger> fingers, float distance, Camera camera = null)
        {
            var delta = Vector3.zero;
            TryGetWorldDelta(fingers, distance, ref delta, camera);
            return delta;
        }

        /// <summary>
        /// 获取手指平均世界坐标增量
        /// </summary>
        static bool TryGetWorldDelta(List<BFFinger> fingers, float distance, ref Vector3 delta, Camera camera = null)
        {
            if (fingers != null)
            {
                var total = Vector3.zero;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.GetWorldDelta(distance, camera);
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    delta = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取所有手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetScreenDistance()
        {
            return GetScreenDistance(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetScreenDistance(List<BFFinger> fingers)
        {
            var distance = 0f;
            var center = Vector2.zero;
            if (TryGetScreenCenter(fingers, ref center))
            {
                TryGetScreenDistance(fingers, center, ref distance);
            }
            return distance;
        }

        /// <summary>
        /// 获取手指到center的平均距离(屏幕坐标)
        /// </summary>
        public static float GetScreenDistance(List<BFFinger> fingers, Vector2 center)
        {
            var distance = 0f;
            TryGetScreenDistance(fingers, center, ref distance);
            return distance;
        }

        /// <summary>
        /// 获取手指到center的平均距离(屏幕坐标)
        /// </summary>
        static bool TryGetScreenDistance(List<BFFinger> fingers, Vector2 center, ref float distance)
        {
            if (fingers != null)
            {
                var total = 0.0f;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.GetScreenDistance(center);
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    distance = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取上一帧所有手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetLastScreenDistance()
        {
            return GetLastScreenDistance(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取上一帧手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetLastScreenDistance(List<BFFinger> fingers)
        {
            var distance = 0.0f;
            var center = Vector2.zero;
            if (TryGetLastScreenCenter(fingers, ref center))
            {
                TryGetLastScreenDistance(fingers, center, ref distance);
            }
            return distance;
        }

        /// <summary>
        /// 获取上一帧手指到center的平均距离(屏幕坐标)
        /// </summary>
        public static float GetLastScreenDistance(List<BFFinger> fingers, Vector2 center)
        {
            float distance = 0.0f;
            TryGetLastScreenDistance(fingers, center, ref distance);
            return distance;
        }

        /// <summary>
        /// 获取上一帧手指到center的平均距离(屏幕坐标)
        /// </summary>
        static bool TryGetLastScreenDistance(List<BFFinger> fingers, Vector2 center, ref float distance)
        {
            if (fingers != null)
            {
                var total = 0.0f;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.GetLastScreenDistance(center);
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    distance = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取起始状态所有手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetStartScreenDistance()
        {
            return GetStartScreenDistance(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取起始状态手指到手势中心的平均距离(屏幕坐标)
        /// </summary>
        public static float GetStartScreenDistance(List<BFFinger> fingers)
        {
            var distance = 0f;
            var center = Vector2.zero;
            if (TryGetStartScreenCenter(fingers, ref center))
            {
                TryGetStartScreenDistance(fingers, center, ref distance);
            }
            return distance;
        }

        /// <summary>
        /// 获取起始状态手指到center的平均距离(屏幕坐标)
        /// </summary>
        public static float GetStartScreenDistance(List<BFFinger> fingers, Vector2 center)
        {
            var distance = 0f;
            TryGetStartScreenDistance(fingers, center, ref distance);
            return distance;
        }

        /// <summary>
        /// 获取起始状态手指到center的平均距离(屏幕坐标)
        /// </summary>
        static bool TryGetStartScreenDistance(List<BFFinger> fingers, Vector2 center, ref float distance)
        {
            if (fingers != null)
            {
                var total = 0.0f;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.GetStartScreenDistance(center);
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    distance = total / count;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取手势拉捏比例
        /// </summary>
        /// <param name="useWheel">是否可以使用鼠标滚轮</param>
        public static float GetPinchScale(bool useWheel = false)
        {
            return GetPinchScale(BFMain.Instance.TouchMgr.fingers, useWheel);
        }

        /// <summary>
        /// 获取手势拉捏比例
        /// </summary>
        /// <param name="useWheel">是否可以使用鼠标滚轮</param>
        public static float GetPinchScale(List<BFFinger> fingers, bool useWheel = false)
        {
            var scale = 1.0f;
            var center = GetScreenCenter(fingers);
            var lastCenter = GetLastScreenCenter(fingers);
            TryGetPinchScale(fingers, center, lastCenter, ref scale, useWheel);
            return scale;
        }

        /// <summary>
        /// 获取手势拉捏比例
        /// </summary>
        static bool TryGetPinchScale(List<BFFinger> fingers, Vector2 center, Vector2 lastCenter,
            ref float scale, bool useWheel = false)
        {
            if (useWheel)
            {
                var scroll = Input.mouseScrollDelta.y;

                if (scroll > 0.0f)
                {
                    scale = 1.0f - 0.1f;
                    return true;
                }

                if (scroll < 0.0f)
                {
                    scale = 1.0f + 0.1f;
                    return true;
                }
            }

            var distance = GetScreenDistance(fingers, center);
            var lastDistance = GetLastScreenDistance(fingers, lastCenter);
            if (lastDistance > 0.0f)
            {
                scale = distance / lastDistance;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 获取手势的扭曲度(单位为度)
        /// </summary>
        public static float GetTwistDegrees()
        {
            return GetTwistDegrees(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手势的扭曲度(单位为度)
        /// </summary>
        public static float GetTwistDegrees(List<BFFinger> fingers)
        {
            return GetTwistRadians(fingers) * Mathf.Rad2Deg;
        }

        /// <summary>
        /// 获取手势的扭曲度(单位为弧度)
        /// </summary>
        public static float GetTwistRadians()
        {
            return GetTwistRadians(BFMain.Instance.TouchMgr.fingers);
        }

        /// <summary>
        /// 获取手势的扭曲度(单位为弧度)
        /// </summary>
        public static float GetTwistRadians(List<BFFinger> fingers)
        {
            var center = GetScreenCenter(fingers);
            var lastCenter = GetLastScreenCenter(fingers);
            var radians = 0.0f;
            TryGetTwistRadians(fingers, center, lastCenter, ref radians);
            return radians;
        }

        /// <summary>
        /// 获取手势的扭曲度(单位为弧度)
        /// </summary>
        static bool TryGetTwistRadians(List<BFFinger> fingers, Vector2 center, Vector2 lastCenter, ref float radians)
        {
            if (fingers != null)
            {
                var total = 0.0f;
                var count = 0;
                for (int i = fingers.Count - 1; i >= 0; i--)
                {
                    var finger = fingers[i];
                    if (finger != null)
                    {
                        total += finger.GetDeltaRadians(center, lastCenter);
                        count += 1;
                    }
                }
                if (count > 0)
                {
                    radians = total / count;
                    return true;
                }
            }
            return false;
        }
    }
}