using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Azimuth;

namespace Annulus.UnitTests
{
    public class StarShapedPolygonTests : UnitTestSharp.TestFixture
    {
        public class CalculateAreaTests : UnitTestSharp.TestFixture
        {
            public void Square()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var area = StarShapedPolygon.CalculateArea(4, EdgeLengths, SpindleLengths);

                CheckEqual(4, area);
            }

            public void Rectangle()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 6, 8, 6, 8, 6, });
                var SpindleLengths = new DenseVector(new Scalar[] { 5, 5, 5, 5, 5, });

                var area = StarShapedPolygon.CalculateArea(4, EdgeLengths, SpindleLengths);

                CheckEqual(48, area);
            }

            public void IrregularQuad()
            {
                Scalar x = Math.Sqrt(5 - 8 / Math.Sqrt(40));
                var EdgeLengths = new DenseVector(new Scalar[] { 2, x, Math.Sqrt(40)-1, Math.Sqrt(40), 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 2, 0, x, 6, 2, });

                var area = StarShapedPolygon.CalculateArea(4, EdgeLengths, SpindleLengths);

                CheckEqual(12-Math.Sqrt(36.0/40.0), area);
            }

            public void Empty()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { });
                var SpindleLengths = new DenseVector(new Scalar[] { });

                var area = StarShapedPolygon.CalculateArea(0, EdgeLengths, SpindleLengths);

                CheckEqual(0, area);
            }

            public void Length1()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 1, 1, });
                var SpindleLengths = new DenseVector(new Scalar[] { 1, 1, });

                var area = StarShapedPolygon.CalculateArea(1, EdgeLengths, SpindleLengths);

                CheckEqual(Math.Sqrt(3)/4, area);
            }

            public void Length2()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 1, 1, 1, });
                var SpindleLengths = new DenseVector(new Scalar[] { 1, 1, 1, });

                var area = StarShapedPolygon.CalculateArea(2, EdgeLengths, SpindleLengths);

                CheckEqual(Math.Sqrt(3)/2, area);
            }
        }

        public class CalculateProportionalAreaTests : UnitTestSharp.TestFixture
        {
            public void Square()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }

            public void Rectangle()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 6, 8, 6, 8, 6, });
                var SpindleLengths = new DenseVector(new Scalar[] { 5, 5, 5, 5, 5, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 48, 48, 48, 48, });

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }

            public void IrregularQuad()
            {
                Scalar x = Math.Sqrt(5 - 8 / Math.Sqrt(40));
                var EdgeLengths = new DenseVector(new Scalar[] { 2, x, Math.Sqrt(40) - 1, Math.Sqrt(40), 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 2, 0, x, 6, 2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 0, 0, 4 * (6 - Math.Sqrt(36.0 / 40.0)), 4 * 6, });

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }

            public void DoesNotModifySpindleOrEdge()
            {
                Scalar x = Math.Sqrt(5 - 8 / Math.Sqrt(40));
                var EdgeLengths = new DenseVector(new Scalar[] { 2, x, Math.Sqrt(40) - 1, Math.Sqrt(40), 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 2, 0, x, 6, 2, });

                var ExpectedEdgeLengths = new DenseVector(new Scalar[] { 2, x, Math.Sqrt(40) - 1, Math.Sqrt(40), 2, });
                var ExpectedSpindleLengths = new DenseVector(new Scalar[] { 2, 0, x, 6, 2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(ExpectedEdgeLengths, EdgeLengths);
                CheckEqual(ExpectedSpindleLengths, SpindleLengths);
            }

            public void EdgeLengthsNotWrapping_NotLongEnough()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void EdgeLengthsNotWrapping_WrongWrap()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 1, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void SpindleLengthsNotWrapping_NotLongEnough()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void SpindleLengthsNotWrapping_WrongWrap()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, 1, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void AreasOutNotSizedCorrectly()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(4);
                var areasOut = new DenseVector(3);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void ScratchNotSizedCorrectly()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var scratch = new DenseVector(3);
                var areasOut = new DenseVector(4);

                var expectedAreasOut = new DenseVector(new Scalar[] { 4, 4, 4, 4, });

                CheckThrow(typeof(Exception));
                StarShapedPolygon.CalculateSubtriangleProportionalAreas(4, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);
            }

            public void Empty()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { });
                var SpindleLengths = new DenseVector(new Scalar[] { });

                var scratch = new DenseVector(0);
                var areasOut = new DenseVector(0);

                var expectedAreasOut = new DenseVector(new Scalar[] { });

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(0, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }

            public void Length1()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 1, 1, });
                var SpindleLengths = new DenseVector(new Scalar[] { 1, 1, });

                var scratch = new DenseVector(1);
                var areasOut = new DenseVector(1);

                var expectedAreasOut = new DenseVector(new Scalar[] { Math.Sqrt(3)});

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(1, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }

            public void Length2()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 1, 1, 1, });
                var SpindleLengths = new DenseVector(new Scalar[] { 1, 1, 1, });

                var scratch = new DenseVector(2);
                var areasOut = new DenseVector(2);

                var expectedAreasOut = new DenseVector(new Scalar[] { Math.Sqrt(3), Math.Sqrt(3) });

                StarShapedPolygon.CalculateSubtriangleProportionalAreas(2, EdgeLengths, SpindleLengths, ref areasOut, ref scratch);

                CheckEqual(expectedAreasOut, areasOut);
            }
        }

        public class BuildSimplePolygon : UnitTestSharp.TestFixture
        {
            public void Diamond()
            {
                var sqr2 = Math.Sqrt(2);
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { sqr2, sqr2, sqr2, sqr2, sqr2, });

                var polygon = StarShapedPolygon.BuildSimplePolygon(4, SpindleLengths, EdgeLengths);

                var expected = new SimplePolygon(new Vector[] { 
                    new Vector(sqr2, 0),
                    new Vector(0, sqr2),
                    new Vector(-sqr2, 0),
                    new Vector(0, -sqr2),                
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }

            public void RectangleDiamond()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 6, 8, 6, 8, 6, });
                var SpindleLengths = new DenseVector(new Scalar[] { 5, 5, 5, 5, 5, });

                var polygon = StarShapedPolygon.BuildSimplePolygon(4, SpindleLengths, EdgeLengths);

                var ang1 = Math.Acos(1 - 36.0/(2.0 * 25.0));
                var ang2 = Math.Acos(1 - 64.0/(2.0 * 25.0));

                var expected = new SimplePolygon(new Vector[] { 
                    Vector.BuildFromAngleMagnitude(0, 5),
                    Vector.BuildFromAngleMagnitude(ang1, 5),
                    Vector.BuildFromAngleMagnitude(ang1 + ang2, 5),
                    Vector.BuildFromAngleMagnitude(ang1 + ang2 + ang1, 5),
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }

            public void IrregularQuad()
            {
                Scalar x = Math.Sqrt(5 - 8 / Math.Sqrt(40));
                var l = Math.Sqrt(40) - 1;
                var EdgeLengths = new DenseVector(new Scalar[] { 2, Math.Sqrt(40), l, x, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 0, 2, 6, x, 0, });

                var polygon = StarShapedPolygon.BuildSimplePolygon(4, SpindleLengths, EdgeLengths);

                var expected = new SimplePolygon(new Vector[]
                {
                    new Vector(0, 0),
                    new Vector(0, 2),
                    new Vector(-6, 0),
                    Vector.BuildFromAngleMagnitude(Math.Acos((x*x + 36 - l * l)/(x*12)) + Math.PI, x),
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }

            public void EmptyPoly()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { });
                var SpindleLengths = new DenseVector(new Scalar[] { });

                var polygon = StarShapedPolygon.BuildSimplePolygon(0, SpindleLengths, EdgeLengths);

                var expected = new SimplePolygon(new Vector[]
                {
                    
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }

            public void Length1()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 2, 2, });

                var polygon = StarShapedPolygon.BuildSimplePolygon(1, SpindleLengths, EdgeLengths);

                var expected = new SimplePolygon(new Vector[]
                {
                    
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }

            public void Length2()
            {
                var EdgeLengths = new DenseVector(new Scalar[] { 2, 2, 2, });
                var SpindleLengths = new DenseVector(new Scalar[] { 2, 2, 2, });

                var polygon = StarShapedPolygon.BuildSimplePolygon(2, SpindleLengths, EdgeLengths);

                var expected = new SimplePolygon(new Vector[]
                {
                    
                });

                CheckEqual(expected.VertexList, polygon.VertexList);
            }
        }
    }
}