using System.Collections.Generic;
using Fort23.Core;
using UnityEngine;

namespace Core.Utility
{
    /// <summary>
    /// 贝塞尔曲线
    /// </summary>
    public class BesselPath :CObject
    {
        public BetterList<Vector3> controlPoints = new BetterList<Vector3>();

        public Vector3 CalculatePoint(float t)
        {
            if (controlPoints.Count < 2)
            {
                Debug.LogError("需要至少2个控制点来计算贝塞尔曲线");
                return Vector3.zero;
            }

            t = Mathf.Clamp01(t);
            int n = controlPoints.Count - 1; // 阶数

            Vector3 point = Vector3.zero;
            for (int i = 0; i <= n; i++)
            {
                // 计算伯恩斯坦多项式
                float bernstein = Bernstein(n, i, t);
                point += bernstein * controlPoints[i];
            }
            return point;
        }

        // 计算伯恩斯坦多项式
        private float Bernstein(int n, int i, float t)
        {
            return BinomialCoefficient(n, i) * Mathf.Pow(1 - t, n - i) * Mathf.Pow(t, i);
        }

        // 计算二项式系数 C(n,i)
        private float BinomialCoefficient(int n, int i)
        {
            return Factorial(n) / (Factorial(i) * Factorial(n - i));
        }

        // 计算阶乘
        private float Factorial(int n)
        {
            if (n <= 1) return 1;
            float result = 1;
            for (int i = 2; i <= n; i++)
            {
                result *= i;
            }
            return result;
        }

        // 获取曲线的切线（数值近似）
        public Vector3 GetTangent(float t)
        {
            const float delta = 0.001f;
            t = Mathf.Clamp01(t);

            // 使用数值微分近似切线
            Vector3 p1 = CalculatePoint(t - delta);
            Vector3 p2 = CalculatePoint(t + delta);
            return (p2 - p1).normalized;
        }

        public override void ActiveObj()
        {
            
        }

        public override void DormancyObj()
        {
            controlPoints.Clear();
        }
    }
}