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

namespace Annulus.UnitTests.DiscreteCollisionDetection
{
    public class LineLineTests : UnitTestSharp.TestFixture
    {
        public class FindIntersectionTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var A = new Line
                {
                    From = new Vector(0, -1),
                    To = new Vector(0, 1),
                };

                var B = new Line
                {
                    From = new Vector(-1, 0),
                    To = new Vector(1, 0),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                CheckEqual(0.5, t1);
                CheckEqual(LineLine.Result.Intersecting, result);
            }

            public void OneDegenerate_First()
            {
                var A = new Line
                {
                    From = new Vector(1, 0),
                    To = new Vector(1, 0),
                };

                var B = new Line
                {
                    From = new Vector(-1, 0),
                    To = new Vector(1, 0),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Degenerate, result);
            }

            public void OneDegenerate_Second()
            {
                var A = new Line
                {
                    From = new Vector(0, -1),
                    To = new Vector(0, 1),
                };

                var B = new Line
                {
                    From = new Vector(0, 0),
                    To = new Vector(0, 0),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Degenerate, result);
            }

            public void Parallel_Identical()
            {
                var A = new Line
                {
                    From = new Vector(0, -1),
                    To = new Vector(0, 1),
                };

                var B = new Line
                {
                    From = new Vector(0, -1),
                    To = new Vector(0, 1),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Parallel, result);
            }

            public void Parallel_NonIdentical()
            {
                var A = new Line
                {
                    From = new Vector(1, -2),
                    To = new Vector(1, 2),
                };

                var B = new Line
                {
                    From = new Vector(0, -1),
                    To = new Vector(0, 1),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Parallel, result);
            }

            public void DoubleDegenerate()
            {
                var A = new Line
                {
                    From = new Vector(1, 1),
                    To = new Vector(1, 1),
                };

                var B = new Line
                {
                    From = new Vector(1, 1),
                    To = new Vector(1, 1),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Degenerate, result);
            }

            public void Infinity_Parallel()
            {
                var A = new Line
                {
                    From = new Vector(1, 0),
                    To = new Vector(1, Scalar.PositiveInfinity),
                };

                var B = new Line
                {
                    From = new Vector(0, 1),
                    To = new Vector(0, Scalar.PositiveInfinity),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Degenerate, result);
            }

            public void Infinity_Intersection()
            {
                var A = new Line
                {
                    From = new Vector(1, 0),
                    To = new Vector(1, Scalar.PositiveInfinity),
                };

                var B = new Line
                {
                    From = new Vector(0, 1),
                    To = new Vector(Scalar.PositiveInfinity, 1),
                };

                Scalar t1;
                var result = LineLine.FindIntersection(A, B, out t1);

                Check(Scalar.IsNaN(t1));
                CheckEqual(LineLine.Result.Degenerate, result);
            }
        }

        public class DistanceBetweenParallelLines : UnitTestSharp.TestFixture
        {
            public void Overlapping()
            {
                var line1 = new Line(
                    new Vector(1, 0),
                    new Vector(0, 0)
                );

                var line2 = new Line(
                    new Vector(-1, 0),
                    new Vector(2, 0)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line1, line2, out dist);

                    CheckEqual(0, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    CheckEqual(0, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }
            }

            public void Distant()
            {
                var line1 = new Line(
                    new Vector(0, 7),
                    new Vector(7, 7)
                );

                var line2 = new Line(
                    new Vector(-1, 0),
                    new Vector(2, 0)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line1, line2, out dist);

                    CheckEqual(7, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    CheckEqual(-7, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }
            }

            public void Distant_Antiparallel()
            {
                var line1 = new Line(
                    new Vector(1, 7),
                    new Vector(0, 7)
                );

                var line2 = new Line(
                    new Vector(-1, 0),
                    new Vector(2, 0)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line1, line2, out dist);

                    CheckEqual(-7, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    CheckEqual(-7, dist);
                    CheckEqual(LineLine.Result.Parallel, result);
                }
            }

            public void Degenerate_A()
            {
                var line1 = new Line(
                    new Vector(0, 7),
                    new Vector(0, 7)
                );

                var line2 = new Line(
                    new Vector(-1, 0),
                    new Vector(2, 0)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    Check(Scalar.IsNaN(dist));
                    CheckEqual(LineLine.Result.Degenerate, result);
                }

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line1, line2, out dist);

                    Check(Scalar.IsNaN(dist));
                    CheckEqual(LineLine.Result.Degenerate, result);
                }
            }

            public void BothDegenerate()
            {
                var line1 = new Line(
                    new Vector(0, 7),
                    new Vector(0, 7)
                );

                var line2 = new Line(
                    new Vector(0, 7),
                    new Vector(0, 7)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    Check(Scalar.IsNaN(dist));
                    CheckEqual(LineLine.Result.Degenerate, result);
                }
            }

            public void NotParallel()
            {
                var line1 = new Line(
                    new Vector(0, 0),
                    new Vector(0, 1)
                );

                var line2 = new Line(
                    new Vector(0, 0),
                    new Vector(1, 0)
                );

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line2, line1, out dist);

                    Check(Scalar.IsNaN(dist));
                    CheckEqual(LineLine.Result.Intersecting, result);
                }

                {
                    Scalar dist;
                    var result = LineLine.DistanceBetweenParallelLines(line1, line2, out dist);

                    Check(Scalar.IsNaN(dist));
                    CheckEqual(LineLine.Result.Intersecting, result);
                }
            }
        }
    }
}