using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Azimuth;
using Annulus;
using Azimuth.DenseLinearAlgebra;
using Annulus.Barycentric;

namespace Annulus.UnitTests.Barycentric
{
    public class MeanValueCoordinatesTests : UnitTestSharp.TestFixture
    {
        public class Ctor : UnitTestSharp.TestFixture
        {
            public class Square : UnitTestSharp.TestFixture
            {
                SimplePolygon square = new SimplePolygon(new Vector[] 
                {
                    new Vector(10, -10),
                    new Vector(10, 10),
                    new Vector(-10, 10),
                    new Vector(-10, -10),
                });

                public void OnVertex()
                {
                    var point = new Vector(10, 10);

                    DenseVector coordinatesOut;
                    var sum = MeanValueCoodinates.CalculateMVC(out coordinatesOut, point, square);

                    DenseVector expected = new Scalar[] { 0, 1, 0, 0, };

                    CheckEqual(expected, coordinatesOut);
                    CheckEqual(Scalar.PositiveInfinity, sum);
                }

                public void OnEdge()
                {
                    var point = new Vector(5, 10);

                    DenseVector coordinatesOut;
                    var sum = MeanValueCoodinates.CalculateMVC(out coordinatesOut, point, square);

                    DenseVector expected = new Scalar[] { 0, 0.75, 0.25, 0, };

                    CheckEqual(expected, coordinatesOut);
                    CheckEqual(20, sum);
                }

                public void Inside()
                {
                    var point = new Vector(0, 0);

                    DenseVector coordinatesOut;
                    var sum = MeanValueCoodinates.CalculateMVC(out coordinatesOut, point, square);

                    DenseVector expected = new Scalar[] { 0.25, 0.25, 0.25, 0.25, };

                    CheckEqual(expected, coordinatesOut);
                    CheckEqual(0.5656854249, sum);
                }

                public void Outside()
                {
                    var point = new Vector(100, 0);

                    DenseVector coordinatesOut;
                    var sum = MeanValueCoodinates.CalculateMVC(out coordinatesOut, point, square);

                    DenseVector expected = new Scalar[] { 2.75, 2.75, -2.25, -2.25, };

                    CheckEqual(expected, coordinatesOut);
                    CheckEqual(-0.0004060351, sum);
                }
            }
        }

        public class Evaluate : UnitTestSharp.TestFixture
        {
            public class Square : UnitTestSharp.TestFixture
            {
                SimplePolygon square = new SimplePolygon(new Vector[] 
                {
                    new Vector(10, -10),
                    new Vector(10, 10),
                    new Vector(-10, 10),
                    new Vector(-10, -10),
                });

                public void OnVertex()
                {
                    DenseVector coordinates = new Scalar[] { 0, 1, 0, 0, };

                    var expected = new Vector(10, 10);

                    var actual = MeanValueCoodinates.Evaluate(coordinates, square);

                    CheckEqual(expected, actual);
                }

                public void OnEdge()
                {
                    var expected = new Vector(5, 10);

                    DenseVector coordinates = new Scalar[] { 0, 0.75, 0.25, 0, };

                    var actual = MeanValueCoodinates.Evaluate(coordinates, square);

                    CheckEqual(expected, actual);
                }

                public void Inside()
                {
                    var expected = new Vector(0, 0);

                    DenseVector coordinates = new Scalar[] { 0.25, 0.25, 0.25, 0.25, };

                    var actual = MeanValueCoodinates.Evaluate(coordinates, square);

                    CheckEqual(expected, actual);
                }

                public void Outside()
                {
                    var expected = new Vector(100, 0);

                    DenseVector coordinates = new Scalar[] { 2.75, 2.75, -2.25, -2.25, };

                    var actual = MeanValueCoodinates.Evaluate(coordinates, square);

                    CheckEqual(expected, actual);
                }
            }
        }

        public class DistanceAnalog : UnitTestSharp.TestFixture
        {
            public class Square : UnitTestSharp.TestFixture
            {
                SimplePolygon square = new SimplePolygon(new Vector[] 
                {
                    new Vector(10, -10),
                    new Vector(10, 10),
                    new Vector(-10, 10),
                    new Vector(-10, -10),
                });

                public void OnVertex()
                {
                    var point = new Vector(10, 10);

                    var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                    CheckEqual(0, distance);
                }

                public void OnEdge()
                {
                    var point = new Vector(0, 10);

                    var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                    CheckEqual(0, distance);
                }

                public void Inside()
                {
                    var point = new Vector(9, 9);

                    var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                    CheckEqual(-0.2864169055, distance);
                }

                public void Outside()
                {
                    var point = new Vector(11, 11);

                    var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                    CheckEqual(1.9204576245, distance);
                }

                public void DistanceValues()
                {
                    var distances = new List<Scalar>();

                    for (Scalar y = -15; y < -10; ++y)
                    {
                        var point = new Vector(5, y);
                        var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                        CheckGreater(distance, 0.0);
                    }

                    for (Scalar y = -9; y < 10; ++y)
                    {
                        var point = new Vector(5, y);
                        var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                        CheckLess(distance, 0.0);
                    }

                    for (Scalar y = 11; y < 15; ++y)
                    {
                        var point = new Vector(5, y);
                        var distance = MeanValueCoodinates.CalculateDistanceAnalog(point, square);

                        CheckGreater(distance, 0.0);
                    }
                }

                /*public void CheckChebyshev()
                {
                    var hammerandanvil = new SimplePolygon(new Vector[]
                    {
                        new Vector(0, 0),
                        new Vector(1, 0),
                        new Vector(1, 2),
                        new Vector(-2, 2),
                        new Vector(-2, -2),
                        new Vector(1, -2),
                        new Vector(1, 0),
                        new Vector(0, 0),
                        new Vector(0, -1),
                        new Vector(-1, -1),
                        new Vector(-1, 1),
                        new Vector(0, 1),
                    });

                    Func<Scalar, Vector> transform = (t) =>
                    {
                        var arm = Vector.BuildFromAngleMagnitude(Math.PI * t, 2);

                        return arm + new Vector(1, -2) * t;
                    };

                    Func<Scalar, Scalar> distance = (t) =>
                    {
                        return MeanValueCoodinates.CalculateDistanceAnalog(transform(t), hammerandanvil);
                    };

                    var cheb = new Azimuth.Approximation.Chebyshev(distance, new Interval(1, 2));

                    var input = new Annulus.SweptCollisionDetection.CollidingInput
                    {
                        impactWindow = new Interval(0, 1),
                        pointMotion = new Annulus.SweptCollisionDetection.Motion
                        {
                            AngularVelocity = Math.PI,
                            LinearVelocity = new Vector(1, -2),
                        },

                        collideeFrame = new Annulus.SweptCollisionDetection.RotatingFrame
                        {
                            
                        },

                        pointLeverArm = new Vector(20, 0),
                    };

                    var hits = Annulus.SweptCollisionDetection.PolygonvsPoint.FindIntersectionsInWindow(
                        input, hammerandanvil);

                    CheckEqual(0, cheb.Coefficients.Length);
                }*/
            }
        }
    }
}