using ArduinoBluetoothAPI;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

public class o0Vector3Filter
{
    Vector3 state = default;
    float Variance = 1;
    public Vector3 Update(Vector3 v)
    {
        if (state == default)
            return state = v;
        Variance += 10;

        float mVariance = 1;
        state = Vector3.Lerp(state, v, mVariance/ (Variance + mVariance));

        Variance = Variance * mVariance / (Variance + mVariance);

        return state;
    }
}
public class o0MagneticCalibraterSimple//默认在无磁干扰环境下，有磁干扰则无法保证效果
{

    public Vector3 _Center = Vector3.zero;
    //Vector3 Center = new Vector3(0,0,0);
    public Vector3 _Radius = new Vector3(2, 2, 2);

    public o0Project.Vector3f Center
    {
        get
        {
            return new o0Project.Vector3f(_Center.x, _Center.y, _Center.z);
        }
        set
        {
            _Center = new Vector3(value.x, value.y, value.z);
        }
    }
    public o0Project.Vector3f Radius
    {
        get
        {
            return new o0Project.Vector3f(_Radius.x, _Radius.y, _Radius.z);
        }
        set
        {
            _Radius = new Vector3(value.x, value.y, value.z);
        }
    }

    public o0MagneticCalibraterSimple()
    {
        //Calibration = true;
    }
    public o0MagneticCalibraterSimple(o0Project.Vector3f Center, o0Project.Vector3f Radius)
    {
        this.Center = Center;
        this.Radius = Radius;
    }

    Vector3 Min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
    Vector3 Max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
    public bool Calibration
    {
        get
        {
            return Min != new Vector3(float.MaxValue, float.MaxValue, float.MaxValue) && Max != new Vector3(float.MinValue, float.MinValue, float.MinValue);
        }
        set
        {
            if (value == true)
            {
                Min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
                Max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
            }
            else
            {
                Min = default;
                Max = default;
            }
        }
    }
    public System.Random r = new System.Random();
    public Vector3 Update(Vector3 v)
    {
        if (v.magnitude > 30)
            Debug.Log(v);
        if (Calibration)
        {
            if (Min.x > v.x)
                Min.x = v.x;
            if (Min.y > v.y)
                Min.y = v.y;
            if (Min.z > v.z)
                Min.z = v.z;
            if (Max.x < v.x)
                Max.x = v.x;
            if (Max.y < v.y)
                Max.y = v.y;
            if (Max.z < v.z)
                Max.z = v.z;
            _Center = (Max + Min) / 2;
            _Radius = (Max - Min) / 2;
        }
        v -= _Center;
        v = new Vector3(v.x / _Radius.x, v.y / _Radius.y, v.z / _Radius.z);
        return v;
    }
    public float CalibratCompletionPercentage()
    {
        return 0;
    }
}
public class o0MagneticCalibrater//默认在无磁干扰环境下，有磁干扰则无法保证效果
{

    public Vector3 _Center = Vector3.zero;
    //Vector3 Center = new Vector3(0,0,0);
    public Vector3 _Radius = new Vector3(2, 2, 2);

    public o0Project.Vector3f Center
    {
        get
        {
            return new o0Project.Vector3f(_Center.x, _Center.y, _Center.z);
        }
        set
        {
            _Center = new Vector3(value.x, value.y, value.z);
        }
    }
    public o0Project.Vector3f Radius
    {
        get
        {
            return new o0Project.Vector3f(_Radius.x, _Radius.y, _Radius.z);
        }
        set
        {
            _Radius = new Vector3(value.x, value.y, value.z);
        }
    }

    public o0MagneticCalibrater()
    {
        //Calibration = true;
    }
    public o0MagneticCalibrater(o0Project.Vector3f Center, o0Project.Vector3f Radius)
    {
        this.Center = Center;
        this.Radius = Radius;
    }

    HashSet<Vector3> Point = default;
    int PointMaxCount = 50;
    Dictionary<(Vector3, Vector3), float> Distance = default;
    public void AddPoint(Vector3 v)
    {
        if (Point.Contains(v))
            return;
        foreach (var i in Point)
            Distance.Add((i, v), Vector3.Distance(v, i));
        Point.Add(v);
    }
    public void RemovePoint(Vector3 v)
    {
        Point.Remove(v);
        foreach (var i in Point)
        {
            Distance.Remove((v, i));
            Distance.Remove((i, v));
        }
    }
    public float TotalDistance(Vector3 v)
    {
        float t = 0;
        foreach (var i in Point)
        {
            if (Distance.ContainsKey((i, v)))
            {
                t += Distance[(i, v)];
                continue;
            }
            else if (Distance.ContainsKey((v, i)))
            {
                t += Distance[(v, i)];
                continue;
            }
        }
        return t;
    }
    public Vector3 MinDistancePoint()
    {
        Vector3 minV = default;
        float minD = float.MaxValue;
        foreach (var i in Point)
        {
            float d = TotalDistance(i);
            if (minV == default || minD > d)
            {
                minD = d;
                minV = i;
            }
        }
        return minV;
    }
    public Vector3 RadiusScale()
    {
        Vector3 min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
        Vector3 max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
        foreach (var i in Point)
        {
            if (min.x > i.x)
                min.x = i.x;
            if (min.y > i.y)
                min.y = i.y;
            if (min.z > i.z)
                min.z = i.z;
            if (max.x < i.x)
                max.x = i.x;
            if (max.y < i.y)
                max.y = i.y;
            if (max.z < i.z)
                max.z = i.z;
        }
        return (max - min) / 2;
    }
    public bool Calibration
    {
        get
        {
            return Distance != null;
        }
        set
        {
            if (value == true)
            {
                Point = new HashSet<Vector3>();
                Distance = new Dictionary<(Vector3, Vector3), float>();
            }
            else
            {
                Distance = null;
            }
        }
    }
    public System.Random r = new System.Random();
    public Vector3 Update(Vector3 v)
    {
        if (v.magnitude > 30)
            Debug.Log(v);
        if (Calibration)
        {
            AddPoint(v);
            if (Point.Count > PointMaxCount)
            {
                RemovePoint(MinDistancePoint());
                _Radius = RadiusScale();
            }


            Vector3 randomV = Point.ElementAt(r.Next(Point.Count));
            var scaledCenter = new Vector3(_Center.x / _Radius.x, _Center.y / _Radius.y, _Center.z / _Radius.z);
            var scaledV = new Vector3(randomV.x / _Radius.x, randomV.y / _Radius.y, randomV.z / _Radius.z);
            float diff = Vector3.Distance(scaledCenter, scaledV) - 1;
            scaledCenter += (scaledV - scaledCenter).normalized * diff * 0.1f;
            _Center = new Vector3(scaledCenter.x * _Radius.x, scaledCenter.y * _Radius.y, scaledCenter.z * _Radius.z);
        }

        /*
        if (diff > 0)
        {
            Center -= v * diff;
        }
        else
        {

        }/**/

        //Point.Add(v);
        //Debug.Log(v.magnitude);
        v -= _Center;
        v = new Vector3(v.x / _Radius.x, v.y / _Radius.y, v.z / _Radius.z);
        return v;
    }
    public float CalibratCompletionPercentage()
    {
        if (Point == null)
            return 0;
        List<float> ScaleDistance = new List<float>();
        foreach (var i in Point)
        {
            var v = i - _Center;
            ScaleDistance.Add(new Vector3(v.x / _Radius.x, v.y / _Radius.y, v.z / _Radius.z).magnitude);
        }
        while (ScaleDistance.Count < PointMaxCount)
            ScaleDistance.Add(0);
        float average = 0;
        foreach (var i in ScaleDistance)
            average += i;
        average /= ScaleDistance.Count;
        float variance = 0;
        foreach (var i in ScaleDistance)
            variance += Mathf.Pow(average - i, 2);
        variance /= ScaleDistance.Count;
        return Mathf.Pow((1 - variance / average), 10) * 100;
        //return variance;
    }
}
public class o0GyrCalibrater
{
    public Vector3 _Average = Vector3.zero;
    public long Count = -1;
    public bool Calibration
    {
        get
        {
            return Count != -1;
        }
        set
        {
            if (value)
                Count = 0;
            else
                Count = -1;
        }
    }
    public o0Project.Vector3f Average
    {
        get
        {
            return new o0Project.Vector3f(_Average.x, _Average.y, _Average.z);
        }
        set
        {
            _Average = new Vector3(value.x, value.y, value.z);
        }
    }
    public o0GyrCalibrater()
    {

    }
    public o0GyrCalibrater(o0Project.Vector3f Average)
    {
        this.Average = Average;
    }
    public Vector3 Update(Vector3 v)
    {
        if (Calibration)
            _Average += (v - _Average) / ++Count;
        v -= _Average;
        if (v.magnitude < 0.0002)
            return Vector3.zero;
        return v;
    }
}
public class o09Axis
{
    static Vector3 AccIdentity = new Vector3(0, -1, 0);
    static Vector3 MagIdentity = new Vector3(-1, 2, 0).normalized;
    public class State
    {
        public long TimeGap;
        public Vector3 Acc = AccIdentity;
        public Vector3 Gyr;
        public Vector3 Mag = MagIdentity;
        public Quaternion Qua;
        public double Variance = 1;
    }

    o0Project.Variance HardwareVarianceGyr = new o0Project.Variance(1000);
    o0Project.Variance HardwareVarianceAcc = new o0Project.Variance(1000);
    o0Project.Variance HardwareVarianceMag = new o0Project.Variance(1000);

    List<State> States = new List<State>();

    Vector3 AccOld;
    Vector3 GyrOld;
    Vector3 MagOld;
    long TimeGapOld;
    /////////////////////g       degree/ms         
    public Quaternion Update(Vector3 AccOld, Vector3 GyrOld, Vector3 MagOld, long TimeGapOld)
    {
        var Acc = this.AccOld;
        var Gyr = this.GyrOld;
        var Mag = this.MagOld;
        float TimeGap = (TimeGapOld + this.TimeGapOld) / 2;
        this.AccOld = AccOld;
        this.GyrOld = GyrOld;
        this.MagOld = MagOld;
        this.TimeGapOld = TimeGapOld;
        var Last = States.LastOrDefault() ?? new State();
        if (this.TimeGapOld <= 0)
            return Last.Qua;
        States.Add(new State());
        if (States.Count > 200)
            States.RemoveAt(0);
        var state = States.Last();
        state.Acc = Acc;
        state.Gyr = Gyr;
        state.Mag = Mag;

        HardwareVarianceGyr.Update((Gyr).magnitude);//每毫秒方差2.331017E-09 度左右   0.00000002331017
        HardwareVarianceAcc.Update(Vector3.Angle(state.Acc, Last.Acc));//方差0.0012度左右
        HardwareVarianceMag.Update(Vector3.Angle(state.Mag, Last.Mag));//方差3.5度左右

        var LastQuaternion = Last.Qua;

        var newQua = new Quaternion();
        newQua.eulerAngles = Gyr * TimeGap;
        var quaGyr = LastQuaternion * newQua;

        double AccLengthToAngle = 5;//1倍引力差相当于多少度方差
        double MagLengthToAngle = 5;//1倍磁力差相当于多少度方差

        double GyrVariance = Last.Variance + 0.00000002331017 * TimeGap + Math.Pow((Gyr * TimeGap).magnitude * 0.03, 2);// 指数4 = 方差2 * 欧拉角旋转误差2     移动导致累计误差
        double AccVariance = Math.Max(0.01, Math.Pow((Acc.magnitude - 9.8) / 9.8 * AccLengthToAngle, 4) + Math.Pow(Math.Max(Gyr.magnitude, Vector3.Angle(Acc, Last.Acc) / TimeGap) * 20, 2));
        double MagVariance = Math.Max(3.5, Math.Pow((Mag.magnitude - 1) / 1 * MagLengthToAngle, 4) + Math.Pow(Vector3.Angle(Mag, Last.Mag) * 0.07, 2));

        state.Variance = GyrVariance;
        state.Variance = state.Variance * (AccVariance+ MagVariance) / (state.Variance + (AccVariance + MagVariance));

        var quaAccMag = o0Project.o0.FormQuaternion(AccIdentity, MagIdentity, Acc, Mag, (float)(AccVariance / (AccVariance + MagVariance)));

        var quaMinRate = GyrVariance / (GyrVariance + Math.Max(AccVariance, MagVariance));
        var quaMaxRate = GyrVariance / (GyrVariance + Math.Min(AccVariance, MagVariance));
        Quaternion quaFirst = Quaternion.Slerp(quaGyr, quaAccMag, (float)quaMinRate).normalized;

        var quaSecondRate = (quaMaxRate - quaMinRate) / (1 - quaMinRate);

        state.Qua = AccVariance < MagVariance ? o0Project.o0.FormQuaternion(quaFirst, AccIdentity, Acc, (float)quaSecondRate) : o0Project.o0.FormQuaternion(quaFirst, MagIdentity, Mag, (float)quaSecondRate);
        
        return state.Qua;
    }

    public void SetIdentity()
    {
        AccIdentity = AccOld;
        MagIdentity = MagOld;
        States.Last().Qua = Quaternion.identity;
        States.Last().Variance = 0.0000001;
    }
    
    public void SetIdentityAccordingToRecords()
    {
        AccIdentity = Vector3.zero;
        foreach (var i in States)
            AccIdentity += i.Acc;
        AccIdentity /= States.Count;
        MagIdentity = Vector3.zero;
        foreach (var i in States)
            MagIdentity += i.Mag;
        MagIdentity /= States.Count;
        States.Last().Qua = Quaternion.identity;
        States.Last().Variance = 0.0000001;
    }
}