using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnitTestSharp;
using Annulus;
using UnitTestSharp.DataDriven;
using Azimuth;

namespace Annulus.UnitTests
{
    /*
    [IgnoreFixture]
    [DataDriven("Polygons.xls", "Main")]
    class PolygonTests_DataDriven : TestFixture
    {
        Scalar expectedArea;
        Scalar expectedPerimeter;
        List<Vector> vertices;
        bool expectedClockwise;
        Polygon polygon;
        Polygon antiPolygon;

        public override void DataRowSetup()
        {
            var table = DataSourceManager.Singleton["Polygons.xls", DataRow["Sheet"]];
            vertices = new List<Vector>(table.RowCount);

            var iterator = table.GetEnumerator();
            iterator.MoveNext();
            expectedArea = Scalar.Parse(iterator.Current["Area"]);
            expectedPerimeter = Scalar.Parse(iterator.Current["Perimeter"]);
            //expectedCentroid = Vector.
            expectedClockwise = bool.Parse(iterator.Current["IsClockwise"]);

            do
            {
                vertices.Add(new Vector(float.Parse(iterator.Current["X"]), float.Parse(iterator.Current["Y"])));
            } while (iterator.MoveNext());

            polygon = new Polygon(vertices);
            vertices.Reverse();
            antiPolygon = new Polygon(vertices);
        }

        public void CheckArea()
        {
            CheckEqual(expectedArea, polygon.Area);
        }

        public void CheckPerimeter()
        {
            CheckEqual(expectedPerimeter, polygon.Perimeter);
        }

        public void CheckIsClockwise()
        {
            CheckEqual(expectedClockwise, polygon.IsClockwise);
        }

        public void CheckArea_Anti()
        {
            CheckEqual(expectedArea, polygon.Area);
        }

        public void CheckPerimeter_Anti()
        {
            CheckEqual(expectedPerimeter, polygon.Perimeter);
        }

        public void CheckIsClockwise_Anti()
        {
            CheckEqual(!expectedClockwise, polygon.IsClockwise);
        }
    }




    class PolygonTests : TestFixture
    {
        Vector[] octohedron_CW = {
                new Vector(0, 0),
                new Vector(0, 1),
                new Vector(1, 2),
                new Vector(2, 2),
                new Vector(3, 1),
                new Vector(3, 0),
                new Vector(2,-1),
                new Vector(1,-1)
        };

        public void Polygon_Works()
        {
            Vector[] tris = {
                new Vector(-1, 0),
                new Vector(0, 1),
                new Vector(1, 0)
            };

            new Polygon(tris);
        }

        public void TestNotEnoughVerticesFails_1()
        {
            Vector[] points = {
                Vector.Zero
            };

            CheckThrow(typeof(System.Exception));
            new Polygon(points);
        }

        public void TestNotEnoughVerticesFails_2()
        {
            Vector[] points = {
                Vector.Zero,
                Vector.Zero
            };

            CheckThrow(typeof(System.Exception));
            new Polygon(points);
        }

        public void TestColinearFails()
        {
            Vector[] points = {
                new Vector(0, 0),
                new Vector(1, 0),
                new Vector(4, 0)
            };

            CheckThrow(typeof(System.Exception));
            new Polygon(points);
        }

        public void TestColinearFails_DegenerateTriangle()
        {
            Vector[] points = {
                new Vector(0, 0),
                new Vector(4, 0),
                new Vector(1, 0)
            };

            CheckThrow(typeof(System.Exception));
            new Polygon(points);
        }

        public void TestConcaveFails()
        {
            var points = new Vector[10];
            points[0] = new Vector(0, -10);
            points[1] = new Vector(2, -8);
            points[2] = new Vector(4, -7);
            points[3] = new Vector(3, -5);
            points[4] = new Vector(5, -3);
            points[5] = new Vector(3, -1);
            points[6] = new Vector(1, -5);
            points[7] = new Vector(2, -6);
            points[8] = new Vector(1, -8);
            points[9] = new Vector(0, -9);

            CheckThrow(typeof(Exception));
            new Polygon(points);
        }

        public void TestComplexFails()
        {
            var points = new Vector[10];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(2, 0);
            points[2] = new Vector(2, 1);
            points[3] = new Vector(1, 1);
            points[4] = new Vector(1, -2);
            points[5] = new Vector(2, -2);
            points[6] = new Vector(2, -1);
            points[7] = new Vector(-2, -1);
            points[8] = new Vector(-2, -2);
            points[9] = new Vector(1, 0);

            CheckThrow(typeof(Exception));
            new Polygon(points);
        }

        
        public void TestConvexPasses_OctohedronClockwise()
        {
            new Polygon(octohedron_CW);
        }
        
        public void TestDirectionCorrect_OctohedronClockwise()
        {
            var polygon = new Polygon(octohedron_CW);

            CheckTrue(polygon.IsClockwise);
        }

        
        public void TestProjectToNormal_X()
        {
            var points = new Vector[8];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 2);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(3, 1);
            points[5] = new Vector(3, 0);
            points[6] = new Vector(2, -1);
            points[7] = new Vector(1, -1);

            var polygon = new Polygon(points);

            Interval expected = new Interval(-1.5, 1.5);
            Vector vector = new Vector(1, 0);

            CheckEqual(expected, polygon.ProjectToNormal(vector));
        }

        public void TestProjectToNormal_Y()
        {
            var points = new Vector[8];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 2);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(3, 1);
            points[5] = new Vector(3, 0);
            points[6] = new Vector(2, -1);
            points[7] = new Vector(1, -1);

            var polygon = new Polygon(points);

            Interval expected = new Interval(-1.5, 1.5);
            Vector vector = new Vector(0, 1);

            CheckEqual(expected, polygon.ProjectToNormal(vector));
        }

        public void TestProjectToNormal_WeirdVector()
        {
            var points = new Vector[8];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 2);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(3, 1);
            points[5] = new Vector(3, 0);
            points[6] = new Vector(2, -1);
            points[7] = new Vector(1, -1);

            var polygon = new Polygon(points);

            Interval expected = new Interval(-14, 14);
            Vector vector = new Vector(4, -8);

            CheckEqual(expected, polygon.ProjectToNormal(vector));
        }
        
        public void TestCenterOfMass_Clockwise()
        {
            var points = new Vector[4];
            points[0] = new Vector(-1, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 0);
            points[3] = new Vector(0, -1);

            var polygon = new Polygon(points);

            CheckEqual(Vector.Zero, polygon.Centroid);
        }

        public void TestCenterOfMass_CCW()
        {
            Vector[] points = {
                new Vector(1, 0),
                new Vector(0, 1),
                new Vector(-1, 0),
                new Vector(0, -1)
            };

            var polygon = new Polygon(points);

            CheckEqual(Vector.Zero, polygon.Centroid);
        }
        
        public void TestArea_Clockwise()
        {
            var points = new Vector[4];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 1);
            points[3] = new Vector(1, 0);

            var polygon = new Polygon(points);

            Scalar expected = 1;

            CheckEqual(expected, polygon.Area);
        }

        public void TestArea_CCW()
        {
            var points = new Vector[4];
            points[3] = new Vector(0, 0);
            points[2] = new Vector(0, 1);
            points[1] = new Vector(1, 1);
            points[0] = new Vector(1, 0);

            var polygon = new Polygon(points);

            Scalar expected = 1;

            CheckEqual(expected, polygon.Area);
        }

        public void TestArea()
        {
            var points = new Vector[6];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(1, 0);
            points[2] = new Vector(2, 1);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(1, 3);
            points[5] = new Vector(0, 3);

            var polygon = new Polygon(points);

            CheckEqual((Scalar)5, polygon.Area);
        }
        
        public void TestPerimeter()
        {
            var points = new Vector[4];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 1);
            points[3] = new Vector(1, 0);

            var polygon = new Polygon(points);

            Scalar expected = 4;

            CheckEqual(expected, polygon.Perimeter);
        }

        public void TestClone()
        {
            var points = new Vector[8];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(0, 1);
            points[2] = new Vector(1, 2);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(3, 1);
            points[5] = new Vector(3, 0);
            points[6] = new Vector(2, -1);
            points[7] = new Vector(1, -1);
            var polygon = new Polygon(points);
            var clone = polygon.Clone();

            CheckEqual(polygon.IsClockwise, clone.IsClockwise);
            CheckEqual(polygon.Perimeter, clone.Perimeter);
            CheckEqual(polygon.Area, clone.Area);
        }

        public void TestClone2()
        {
            var points = new Vector[6];
            points[0] = new Vector(0, 0);
            points[1] = new Vector(1, 0);
            points[2] = new Vector(2, 1);
            points[3] = new Vector(2, 2);
            points[4] = new Vector(1, 3);
            points[5] = new Vector(0, 3);

            var polygon = new Polygon(points);

            Scalar expected = 5;
            var clone = polygon.Clone();

            CheckEqual(expected, polygon.Area);
            //Here
            CheckEqual(expected, polygon.Clone().Area);
            //And here
            Check(Scalar.FuzzyEquality(expected, polygon.Clone().Area));
        }

        public void TestCache()
        {
            TODO("Polygon.TestCache");

            //Run and time a bunch of non-common normals

            //Run and time an equal number of common normals

            //Check that the common normals evaluated faster
        }

        public void TestBoundingCircle()
        {
            var points = new Vector[4];
            points[0] = new Vector(1, 1);
            points[1] = new Vector(-1, 1);
            points[2] = new Vector(-1, -1);
            points[3] = new Vector(1, -1);

            var polygon = new Polygon(points);

            CheckEqual(Math.Truncate(100*(2*Math.Sqrt(.5))), Math.Truncate(100*(polygon.BoundingCircle.Radius)));
        }

		public void FindMostExtremePointAlongNormal()
		{
			var points = new Vector[4];
			points[0] = new Vector(1, 1);
			points[1] = new Vector(-1, 1);
			points[2] = new Vector(-1, -1);
			points[3] = new Vector(1, -1);

			var polygon = new Polygon(points);
            Scalar extremeness;

			Vector actual;
			polygon.FindMostExtremePointAlongNormal(new Vector(1, 1), out extremeness, out actual);

			CheckEqual(points[0], actual);
		}
    }
     */
}