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 SegmentSegmentTests : 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),
                };

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(Vector.Zero, pointOfIntersection);
                CheckEqual(0.5, t1);
                CheckEqual(0.5, t2);
                CheckEqual(SegmentSegment.Result.Intersecting, result);
            }

            public void Parallel()
            {
                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),
                };

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Parallel, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Parallel, result);
            }

            public void ExactOverlap()
            {
                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),
                };

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Parallel, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Disjoint, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Disjoint, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Degenerate, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Degenerate, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Degenerate, result);
            }

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

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

                Vector pointOfIntersection;
                Scalar t1, t2;
                var result = SegmentSegment.FindIntersection(
                    A, B,
                    out t1, out t2, out pointOfIntersection
                );

                CheckEqual(SegmentSegment.Result.Degenerate, result);
            }
        }

        public class ParallelSegmentParametricIntersection : UnitTestSharp.TestFixture
        {
            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)
                );

                Interval t1, t2;
                var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                CheckEqual(SegmentSegment.Result.Intersecting, result);
                Check(Scalar.IsNaN(t1.Min));
                Check(Scalar.IsNaN(t1.Max));
                Check(Scalar.IsNaN(t2.Min));
                Check(Scalar.IsNaN(t2.Max));
            }

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

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

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Degenerate, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Degenerate, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }
            }

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

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

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Degenerate, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Degenerate, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }
            }

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

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

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }
            }

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

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

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }
            }

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

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

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Disjoint, result);
                    Check(Scalar.IsNaN(t1.Min));
                    Check(Scalar.IsNaN(t1.Max));
                    Check(Scalar.IsNaN(t2.Min));
                    Check(Scalar.IsNaN(t2.Max));
                }
            }

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

                var line2 = new Line(
                    new Vector(0, 2.5),
                    new Vector(0, 0.5)
                );

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line1, line2, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Parallel, result);
                    CheckEqual(new Interval(0, 0.5), t1);
                    CheckEqual(new Interval(0.75, 1), t2);
                }

                {
                    Interval t1, t2;
                    var result = SegmentSegment.ParameterizeOverlappingParallelSegments(line2, line1, out t1, out t2);

                    CheckEqual(SegmentSegment.Result.Parallel, result);
                    CheckEqual(new Interval(0, 0.5), t2);
                    CheckEqual(new Interval(0.75, 1), t1);
                }
            }
        }
    }
}