using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Annulus.CSG;
using Azimuth;

namespace Annulus.UnitTests.CSG
{
    public class StraightSkeletonTests : UnitTestSharp.TestFixture
    {
        public class EdgeTests : UnitTestSharp.TestFixture
        {
            //StraightSkeleton.Vertex OriginVertex = new StraightSkeleton.Vertex
            //{
            //    Position = new Azimuth.Vector(0, 0),
            //};

            //StraightSkeleton.Vertex XAxis = new StraightSkeleton.Vertex
            //{
            //    Position = new Azimuth.Vector(7, 0),
            //};

            //StraightSkeleton.Vertex YAxis = new StraightSkeleton.Vertex
            //{
            //    Position = new Azimuth.Vector(0, -3),
            //};

            //StraightSkeleton.Vertex Quad4Vertex = new StraightSkeleton.Vertex
            //{
            //    Position = new Azimuth.Vector(7, -3),
            //};

            //public void CompareTo_DifferentTimes()
            //{
            //    StraightSkeleton.Edge edge1 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };                

            //    var edge2 = new StraightSkeleton.Edge
            //    {
            //        TOI = 7,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };

            //    Check(edge1.CompareTo(edge2) < 0);
            //    Check(edge2.CompareTo(edge1) > 0);
            //}

            //public void CompareTo_DifferentVertex1()
            //{
            //    StraightSkeleton.Edge edge1 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };

            //    var edge2 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = XAxis,
            //        vertex2 = Quad4Vertex,
            //    };

            //    Check(edge1.CompareTo(edge2) < 0);
            //    Check(edge2.CompareTo(edge1) > 0);
            //}

            //public void CompareTo_DifferentVertex2()
            //{
            //    StraightSkeleton.Edge edge1 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };

            //    var edge2 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = XAxis,
            //    };

            //    Check(edge1.CompareTo(edge2) < 0);
            //    Check(edge2.CompareTo(edge1) > 0);
            //}

            //public void CompareTo_Same()
            //{
            //    StraightSkeleton.Edge edge1 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };

            //    var edge2 = new StraightSkeleton.Edge
            //    {
            //        TOI = 0,
            //        vertex1 = OriginVertex,
            //        vertex2 = Quad4Vertex,
            //    };

            //    Check(edge1.CompareTo(edge2) == 0);
            //    Check(edge2.CompareTo(edge1) == 0);
            //}
        }

        public class BuildSVGTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var Vertices = new List<StraightSkeleton.ExportVertex>
                {
                    new StraightSkeleton.ExportVertex
                    {
                        Position = new Vector(-1, 1),
                        Edges = new List<StraightSkeleton.ExportEdge>(),
                    },

                    new StraightSkeleton.ExportVertex
                    {
                        Position = new Vector( 1, 1),
                        Edges = new List<StraightSkeleton.ExportEdge>(),
                    },

                    new StraightSkeleton.ExportVertex
                    {
                        Position = new Vector( 1,-1),
                        Edges = new List<StraightSkeleton.ExportEdge>(),
                    },

                    new StraightSkeleton.ExportVertex
                    {
                        Position = new Vector(-1,-1),
                        Edges = new List<StraightSkeleton.ExportEdge>(),
                    },
                };

                var straightSkeleton = new StraightSkeleton
                {
                    Edges = new List<StraightSkeleton.ExportEdge>
                    {
                        new StraightSkeleton.ExportEdge
                        {
                            vertex1 = Vertices[0],
                            vertex2 = Vertices[1],
                        },

                        new StraightSkeleton.ExportEdge
                        {
                            vertex1 = Vertices[1],
                            vertex2 = Vertices[2],
                        },

                        new StraightSkeleton.ExportEdge
                        {
                            vertex1 = Vertices[2],
                            vertex2 = Vertices[3],
                        },

                        new StraightSkeleton.ExportEdge
                        {
                            vertex1 = Vertices[3],
                            vertex2 = Vertices[0],
                        },
                    },

                    Vertices = Vertices,
                };

                straightSkeleton.Edges.ForEach(edge => 
                {
                    edge.vertex1.Edges.Add(edge);
                    edge.vertex2.Edges.Add(edge);
                });

                var expected =
@"<path d = ""M -1 1 L 1 1 M 1 1 L 1 -1 M 1 -1 L -1 -1 M -1 -1 L -1 1 "" STYLE2 />
<g class=""non-scaling"">
<circle transform=""translate(-1,1)"" r = ""1.5"" STYLE1 />
<circle transform=""translate(1,1)"" r = ""1.5"" STYLE1 />
<circle transform=""translate(1,-1)"" r = ""1.5"" STYLE1 />
<circle transform=""translate(-1,-1)"" r = ""1.5"" STYLE1 />
<text transform=""translate(0,1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE4 >0</text>
<text transform=""translate(1,0)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE4 >1</text>
<text transform=""translate(0,-1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE4 >2</text>
<text transform=""translate(-1,0)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE4 >3</text>
<text transform=""translate(-1,1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE3 >0</text>
<text transform=""translate(1,1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE3 >1</text>
<text transform=""translate(1,-1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE3 >2</text>
<text transform=""translate(-1,-1)"" font-size=""20"" xml:space=""preserve"" dy=""-.25em"" dx="".25em"" STYLE3 >3</text>
</g>
";

                var actual = straightSkeleton.BuildSVG("STYLE1", "STYLE2", "STYLE3", "STYLE4");

                CheckEqual(expected, actual);
            }
        }

        public class CalculateAABBTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var poly = new PerforatedPolygon(new SimplePolygon(new Vector[]
                {
                    new Vector(0, 0),
                    new Vector(1, 0),
                    new Vector(0, -1),
                }));

                var ss = StraightSkeleton.BuildStraightSkeleton(poly);

                var aabb = ss.CalculateAABB();
                var expected = new AABB<Vector>(new Vector(0, -1), new Vector(1, 0));

                CheckEqual(expected, aabb);
            }
        }

        public class DecomposeTests : UnitTestSharp.TestFixture
        {
            [UnitTestSharp.IgnoreTest]
            private void CheckEqual(IList<SimplePolygon> actualFaces, List<SimplePolygon> expectedFaces)
            {
                CheckEqual(expectedFaces.Count, actualFaces.Count);
                if (expectedFaces.Count == actualFaces.Count)
                {
                    for (int i = 0; i < expectedFaces.Count; ++i)
                    {
                        var oldFailures = this.internals.FailedChecks;
                        CheckEqual(expectedFaces[i].VertexList, actualFaces[i].VertexList);
                        if (oldFailures != this.internals.FailedChecks)
                        {
                            TODO("In sub polygon " + i);
                        }
                    }
                }
            }

            public void Triangle()
            {
                var vertices = new PerforatedPolygon(new SimplePolygon(new Vector[]
                {
                    new Vector(0, 0),
                    new Vector(1, 0),
                    new Vector(0.5, Math.Sqrt(3)/2),
                }));

                var centerVertex = new Vector(0.5, Math.Sqrt(3) / 6);

                var straightSkeleton = StraightSkeleton.BuildStraightSkeleton(vertices);

                var actualFaces = straightSkeleton.Decompose();

                var expectedFaces = new List<SimplePolygon>
                {
                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[0],
                        vertices.Silhouette.VertexList[1],
                        centerVertex,
                    }),

                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[1],
                        vertices.Silhouette.VertexList[2],
                        centerVertex,
                    }),

                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[2],
                        vertices.Silhouette.VertexList[0],
                        centerVertex,
                    }),
                };

                CheckEqual(actualFaces, expectedFaces);
            }

            public void ReverseTriangle()
            {
                var vertices = new PerforatedPolygon(new SimplePolygon(new Vector[]
                {
                    new Vector(0, 0),
                    new Vector(0.5, Math.Sqrt(3)/2),
                    new Vector(1, 0),
                }));

                var centerVertex = new Vector(0.5, Math.Sqrt(3) / 6);

                var straightSkeleton = StraightSkeleton.BuildStraightSkeleton(vertices);

                var actualFaces = straightSkeleton.Decompose();

                var expectedFaces = new List<SimplePolygon>
                {
                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[0],
                        vertices.Silhouette.VertexList[1],
                        centerVertex,
                    }),

                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[1],
                        vertices.Silhouette.VertexList[2],
                        centerVertex,
                    }),

                    new SimplePolygon(new Vector[] 
                    {
                        vertices.Silhouette.VertexList[2],
                        vertices.Silhouette.VertexList[0],
                        centerVertex,
                    }),
                };

                CheckEqual(actualFaces, expectedFaces);
            }

            public void HammerAndAnvil()
            {
                var vertices = new PerforatedPolygon(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),
                }));

                var expectedStraightSkeleton_AdditionalVerts = new Vector[]
                {
                    new Vector(-1.5, -1.5), //12
                    new Vector(-1.5, 1.5), //13
                    new Vector(0.5, -1.5), //14
                    new Vector(0.5, 1.5), //15
                    new Vector(0.5, -0.5), //16,
                    new Vector(0.5, 0.5), //17
                };

                var verts = vertices.Silhouette.VertexList.Concat(expectedStraightSkeleton_AdditionalVerts).ToList();

                var straightSkeleton = StraightSkeleton.BuildStraightSkeleton(vertices);

                var actualFaces = straightSkeleton.Decompose();

                var expectedFaces = new List<SimplePolygon>
                {
                    new SimplePolygon(new Vector[]
                    {
                        verts[0],
                        verts[1],
                        verts[17],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[1],
                        verts[2],
                        verts[15],
                        verts[17],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[2],
                        verts[3],
                        verts[13],
                        verts[15],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[3],
                        verts[4],
                        verts[12],
                        verts[13],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[4],
                        verts[5],
                        verts[14],
                        verts[12],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[5],
                        verts[6],
                        verts[16],
                        verts[14],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[6],
                        verts[7],
                        verts[16],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[7],
                        verts[8],
                        verts[14],
                        verts[16],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[8],
                        verts[9],
                        verts[12],
                        verts[14],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[9],
                        verts[10],
                        verts[13],
                        verts[12],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[10],
                        verts[11],
                        verts[15],
                        verts[13],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[11],
                        verts[0],
                        verts[17],
                        verts[15],
                    }),
                };

                CheckEqual(actualFaces, expectedFaces);
            }

            public void ReverseHammerAndAnvil()
            {
                var vertices = new PerforatedPolygon(new SimplePolygon(new Vector[]
                {
                    new Vector(0, 0),
                    new Vector(0, 1),
                    new Vector(-1, 1),
                    new Vector(-1, -1),
                    new Vector(0, -1),
                    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),
                }));

                var expectedStraightSkeleton_AdditionalVerts = new Vector[]
                {
                    new Vector(-1.5, -1.5), //12
                    new Vector(-1.5, 1.5), //13
                    new Vector(0.5, -1.5), //14
                    new Vector(0.5, 1.5), //15
                    new Vector(0.5, -0.5), //16,
                    new Vector(0.5, 0.5), //17
                };

                var verts = vertices.Silhouette.VertexList.Concat(expectedStraightSkeleton_AdditionalVerts).ToList();

                var straightSkeleton = StraightSkeleton.BuildStraightSkeleton(vertices);

                var actualFaces = straightSkeleton.Decompose();

                var expectedFaces = new List<SimplePolygon>
                {
                    new SimplePolygon(new Vector[]
                    {
                        verts[0],
                        verts[1],
                        verts[15],
                        verts[17],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[1],
                        verts[2],
                        verts[13],
                        verts[15],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[2],
                        verts[3],
                        verts[12],
                        verts[13],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[3],
                        verts[4],
                        verts[14],
                        verts[12],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[4],
                        verts[5],
                        verts[16],
                        verts[14],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[5],
                        verts[6],
                        verts[16],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[6],
                        verts[7],
                        verts[14],
                        verts[16],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[7],
                        verts[8],
                        verts[12],
                        verts[14],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[8],
                        verts[9],
                        verts[13],
                        verts[12],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[9],
                        verts[10],
                        verts[15],
                        verts[13],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[10],
                        verts[11],
                        verts[17],
                        verts[15],
                    }),

                    new SimplePolygon(new Vector[]
                    {
                        verts[11],
                        verts[0],
                        verts[17],
                    }),
                };

                CheckEqual(actualFaces, expectedFaces);
            }
        }
    }
}