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

namespace YKMoon.Math
{
    public partial class YKMath
    {
        public static Vector2 GetVector2IgnoreYAxis(Vector2 v)
        {
            v.y = 0;
            return v;
        }

        public static Vector2 GetDeltaIgnoreZAxis(Vector3 from, Vector3 to)
        {
            return new Vector2((to - from).x, (to - from).y);
        }

        public static Vector2 GetDisIgnoreZAxis(Vector3 posA, Vector3 posB)
        {
            return new Vector2(Mathf.Abs((posA - posB).x), Mathf.Abs((posA - posB).y));
        }

        /// <summary>
        /// 三点确认抛物线, 获得抛物线内的percent%的点
        /// </summary>
        /// <param name="P1">起点</param>
        /// <param name="P2">终点</param>
        /// <param name="P3">轨迹内任意点</param>
        /// <param name="maxHeightPos">最高点</param>
        /// <param name="percent">百分比</param>
        /// <returns></returns>
        public static Vector2 GetParabolaPos(Vector2 P1, Vector2 P2, Vector2 P3, out Vector2 maxHeightPos, float percent)
        {
            float a, b, c;
            CalculateABC(P1, P2, P3, out a, out b, out c);

            float x = Mathf.Lerp(P1.x, P2.x, percent);
            float y = a * x * x + b * x + c;

            Vector2 position = new Vector2(x, y);

            maxHeightPos.x = -b / (2 * a);
            maxHeightPos.y = c - b * b / (4 * a);
            return position;
        }
        /// <summary>
        /// 三点确认抛物线, 获得抛物线内的percent%的点，只计算XY平面投影
        /// </summary>
        /// <param name="P1"></param>
        /// <param name="P2"></param>
        /// <param name="P3"></param>
        /// <param name="maxHeightPos"></param>
        /// <param name="percent"></param>
        /// <returns></returns>
        public static Vector3 GetParabolaPos3DXY(Vector3 P1, Vector3 P2, Vector3 P3, out Vector3 maxHeightPos, float percent)
        {
            //先计算2D投影
            float a, b, c;
            CalculateABC(P1, P2, P3, out a, out b, out c);
            float x = Mathf.Lerp(P1.x, P2.x, percent);
            float y = a * x * x + b * x + c;
            float z = Mathf.Lerp(P1.z, P2.z, percent);

            Vector3 position = new Vector3(x, y, z);

            maxHeightPos.x = -b / (2 * a);
            maxHeightPos.y = c - b * b / (4 * a);
            maxHeightPos.z = Mathf.Lerp(P1.z, P2.z, (maxHeightPos.x - P1.x) / (P2.x - P1.x));
            return position;
        }

        /// <summary>
        /// 三点确认抛物线，获得抛物线的二次方程abc参数, ax^2+bx+c=0
        /// </summary>
        private static void CalculateABC(Vector2 P1, Vector2 P2, Vector2 P3, out float a, out float b, out float c)
        {
            float x1 = P1.x;
            float y1 = P1.y;
            float x2 = P3.x;
            float y2 = P3.y;
            float x3 = P2.x;
            float y3 = P2.y;

            a = (y1 * x2) + (x1 * y3) + (y2 * x3) - (y3 * x2) - (x3 * y1) - (y2 * x1);
            a /= x1 * x1 * x2 + x3 * x3 * x1 + x3 * x2 * x2 - x3 * x3 * x2 - x3 * x1 * x1 - x2 * x2 * x1;
            b = x1 * x1 * y2 + y1 * x3 * x3 + x2 * x2 * y3 - x3 * x3 * y2 - x1 * x1 * y3 - x2 * x2 * y1;
            b /= x1 * x1 * x2 + x3 * x3 * x1 + x3 * x2 * x2 - x3 * x3 * x2 - x3 * x1 * x1 - x2 * x2 * x1;
            c = (x1 * x1 * x2 * y3) + (x1 * y2 * x3 * x3) + (y1 * x3 * x2 * x2) - (x3 * x3 * x2 * y1) - (x3 * y2 * x1 * x1) - (y3 * x1 * x2 * x2);
            c /= x1 * x1 * x2 + x3 * x3 * x1 + x3 * x2 * x2 - x3 * x3 * x2 - x3 * x1 * x1 - x2 * x2 * x1;
        }
        /// <summary>
        /// 在圆内均匀分布点。
        /// </summary>
        /// <param name="radius">圆的半径，要生成点在该半径的圆内</param>
        /// <param name="count">要生成点的数量</param>
        /// <returns></returns>
        public static List<Vector2> RandomPointInCircle(float radius, int count, float minDisBetweenPos)
        {
            List<Vector2> result = new List<Vector2>();
            /*float r;//公式的r系数
            float theta;//公式的角度系数
            float x;
            float y;
            float randomValue;//0-1的随机值
            System.Random random = new System.Random();
            for(int i = 0; i < count; i++) {
                // Tip 此处要注意! r和theta的生成要分别生成随机数，公式概念中明确说明，r和theta要互不相干
                randomValue = (float)random.NextDouble();
                r = math.sqrt(randomValue) * radius;
                randomValue = (float)random.NextDouble();
                theta = 2 * math.PI * randomValue;
                //生成x，y坐标，
                x = (float)r * math.cos(theta);
                y = (float)r * math.sin(theta);
                result.Add(new Vector2(x, y));//* 0.5; 若要变成椭圆，将X和Y结果值乘上你想要的比例系数即可
            }*/
            while(result.Count < count) {
                var pos = UnityEngine.Random.insideUnitCircle * radius;
                bool isMatch = true;
                for(int i = 0; i < result.Count; i++) {
                    if(Vector3.Distance(result[i], pos) < minDisBetweenPos) {
                        isMatch = false;
                        break;
                    }
                }
                if(isMatch) {
                    result.Add(pos);
                } else {
                    break;
                }
            }
            while(result.Count < count) {
                var pos = UnityEngine.Random.insideUnitCircle * radius;
                result.Add(pos);
            }
            return result;
        }
        /// <summary>
        /// 生成随机点均匀分布在圆内
        /// </summary>
        /// <param name="radius">半径</param>
        /// <param name="count">点个数</param>
        /// <returns></returns>
        public static List<Vector2> RandomPointsInCircleUniformly(float radius, int count)
        {
            List<Vector2> result = new List<Vector2>();
            System.Random random = new System.Random();
            for(int i=0; i<count; i++) {
                var randomValue = Random.value;//random.NextDouble();
                var r = Mathf.Sqrt(randomValue) * radius;
                var theta = 2 * Mathf.PI * randomValue;
                var x = r * Mathf.Cos(theta);
                var y = r * Mathf.Sin(theta);
                result.Add(new Vector2(x, y));
            }
            return result;
        }

        /// <summary>
        /// 简谐运动cos版
        /// </summary>
        /// <param name="time">时间点</param>
        /// <param name="Amplitude">振幅</param>
        /// <param name="frequency">频率 = 1/一个周期时长</param>
        /// <param name="phi">初相位，单位为弧度</param>
        /// <param name="isCos">if true use cos else sin.</param>
        /// <returns>位移</returns>
        public static float SimpleHarmonicMotion(float time, float frequency, float Amplitude = 0.5f, float phi = 0, bool isCos = true)
        {
            //位移时间方程 x = Acos(ωt + φ)
            //圆频率ω = 2πf
            //频率f
            //相位φ
            //振幅A
            float omega = 2 * Mathf.PI * frequency;
            if(isCos) {
                return Amplitude * Mathf.Cos(omega * time + phi);
            } else {
                return Amplitude * Mathf.Sin(omega * time + phi);
            }
        }
    }
}