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

namespace Annulus.UnitTests.CSG.StraightSkeletonUtilities
{
    public class VertexVertexEventTests : TestFixture
    {
        public enum LoopingEnum
        {
            DO_NOT_LOOP,

            LOOP,
        }

        [IgnoreTest]
        public static List<Vertex> BuildVertices(IEnumerable<Vector> vertices, Scalar winding, LoopingEnum loop)
        {
            var returnMe = vertices.Select(x => new Vertex
            {
                TOI = 0,
                Position = x,
            }).ToList();

            for (int i = 1; i < returnMe.Count - 1; ++i)
            {
                returnMe[i].NextVertex = returnMe[i + 1];
                returnMe[i].PrevVertex = returnMe[i - 1];

                returnMe[i].NextVertex.PrevVertex = returnMe[i];
                returnMe[i].PrevVertex.NextVertex = returnMe[i];

                Vertex.FindBisector(returnMe[i], returnMe[i - 1], returnMe[i + 1], 0, winding);
            }

            if (loop == LoopingEnum.LOOP)
            {                
                returnMe[0].NextVertex = returnMe[1];
                returnMe[0].PrevVertex = returnMe[returnMe.Count - 1];

                returnMe[0].NextVertex.PrevVertex = returnMe[0];
                returnMe[0].PrevVertex.NextVertex = returnMe[0];
                Vertex.FindBisector(returnMe[0], returnMe[returnMe.Count - 1], returnMe[1], 0, winding);

                int i = returnMe.Count - 1;
                returnMe[i].NextVertex = returnMe[0];
                returnMe[i].PrevVertex = returnMe[i - 1];

                returnMe[i].NextVertex.PrevVertex = returnMe[i];
                returnMe[i].PrevVertex.NextVertex = returnMe[i];

                Vertex.FindBisector(returnMe[i], returnMe[i - 1], returnMe[0], 0, winding);
            }

            return returnMe;
        }

        public void BuildVertices_TriangleLoop()
        {
            var vertices = BuildVertices(new Vector[] 
            {
                new Vector(0, 0),                    
                new Vector(0, 1),
                new Vector(1, 0),
            }, 1, LoopingEnum.LOOP);

            Check(vertices[0].BisectorDirection.X > 0);
            Check(vertices[0].BisectorDirection.Y > 0);

            Check(vertices[1].BisectorDirection.X > 0);
            Check(vertices[1].BisectorDirection.Y < 0);

            Check(vertices[2].BisectorDirection.X < 0);
            Check(vertices[2].BisectorDirection.Y > 0);
        }

        public class Finder : TestFixture
        {
            public void BasicCollapseEvent()
            {
                var vertices = BuildVertices(new Vector[]
                {
                    new Vector(-2, 10),
                    new Vector(-2, 0),
                    new Vector(2, 0),
                    new Vector(2, 10),
                }, -1, LoopingEnum.DO_NOT_LOOP);

                var evt = VertexVertexEvent.FindVertexVertexEvent(vertices[1], vertices[2], 0);

                CheckNotNull(evt);
                if (evt != null)
                {
                    CheckEqual(new Vector(0, 2), evt.HitPoint);
                    CheckEqual(2, evt.TOI);
                    CheckEqual(vertices[1], evt.v1);
                    CheckEqual(vertices[2], evt.v2);
                }
            }

            public void BasicCollapseEvent_ReverseWinding()
            {
                var vertices = BuildVertices(new Vector[]
                {
                    new Vector(2, 10),
                    new Vector(2, 0),
                    new Vector(-2, 0),
                    new Vector(-2, 10),
                }, -1, LoopingEnum.DO_NOT_LOOP);

                var evt = VertexVertexEvent.FindVertexVertexEvent(vertices[1], vertices[2], 0);

                CheckNull(evt);
            }
        }

        public class SpliceVertices : TestFixture
        {
            public void Triangle()
            {
                var vertices = BuildVertices(new Vector[] 
                {
                    new Vector(0, 0),                    
                    new Vector(0, 1),
                    new Vector(1, 0),
                }, 1, LoopingEnum.LOOP);

                var newVertices = VertexVertexEvent.SpliceVertices(vertices, 1, 1.0/3.0);

                CheckEqual(1, newVertices.Count);
                if (newVertices.Count == 1)
                {
                    CheckEqual(new Vector(1.0 / 3.0, 1.0 / 3.0), newVertices[0].Position);
                    CheckEqual(1.0 / 3.0, newVertices[0].TOI);
                    CheckEqual(newVertices[0], newVertices[0].NextVertex);
                    CheckEqual(newVertices[0], newVertices[0].PrevVertex);
                    CheckEqual(Vector.Zero, newVertices[0].BisectorDirection);
                    CheckEqual(Vertex.BisectorNatureEnum.DEGENERATE, newVertices[0].BisectorNature);

                    CheckEqual(newVertices[0], vertices[0].NextVertex);
                    CheckEqual(newVertices[0], vertices[0].PrevVertex);

                    CheckEqual(newVertices[0], vertices[1].NextVertex);
                    CheckEqual(newVertices[0], vertices[1].PrevVertex);

                    CheckEqual(newVertices[0], vertices[2].NextVertex);
                    CheckEqual(newVertices[0], vertices[2].PrevVertex);
                }
            }

            public void Triangle_ReverseWinding()
            {
                var vertices = BuildVertices(new Vector[] 
                {
                    new Vector(0, 0),                    
                    new Vector(1, 0),
                    new Vector(0, 1),                    
                }, -1, LoopingEnum.LOOP);

                var newVertices = VertexVertexEvent.SpliceVertices(vertices, 1, 1.0 / 3.0);

                CheckEqual(1, newVertices.Count);
                if (newVertices.Count == 1)
                {
                    CheckEqual(new Vector(1.0 / 3.0, 1.0 / 3.0), newVertices[0].Position);
                    CheckEqual(1.0 / 3.0, newVertices[0].TOI);
                    CheckEqual(newVertices[0], newVertices[0].NextVertex);
                    CheckEqual(newVertices[0], newVertices[0].PrevVertex);
                    CheckEqual(Vector.Zero, newVertices[0].BisectorDirection);
                    CheckEqual(Vertex.BisectorNatureEnum.DEGENERATE, newVertices[0].BisectorNature);

                    CheckEqual(newVertices[0], vertices[0].NextVertex);
                    CheckEqual(newVertices[0], vertices[0].PrevVertex);

                    CheckEqual(newVertices[0], vertices[1].NextVertex);
                    CheckEqual(newVertices[0], vertices[1].PrevVertex);

                    CheckEqual(newVertices[0], vertices[2].NextVertex);
                    CheckEqual(newVertices[0], vertices[2].PrevVertex);
                }
            }
        }
    }
}