using System;
using UnitTestSharp;

namespace Azimuth.UnitTests
{
    public class PiecewiseLinearTests : TestFixture
    {
        public class CtorTests : TestFixture
        {
            public void NullKnots_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new PiecewiseLinear(null);
            }

            public void NoKnots_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new PiecewiseLinear();
            }

            public void KnotsRunningBackwardInX_Throw()
            {
                CheckThrow(typeof(ArgumentException));
                new PiecewiseLinear((0, 0), (2, 1), (1, 1));
            }

            public void KnotsJustRunningBackwardInX_Throw()
            {
                CheckThrow(typeof(ArgumentException));
                new PiecewiseLinear((1.0, 0), (1.0 - 1e-12, 1));
            }

            public void KnotsSharingAnX_AreAllowed()
            {
                CheckEqual(1.0, new PiecewiseLinear((0, 0), (1, 0), (1, 1)).MaxY.Value);
            }

            public void ANotANumberX_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((double.NaN, 0));
            }

            public void AnInfiniteX_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((double.PositiveInfinity, 0));
            }

            public void ANotANumberY_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((0, double.NaN));
            }

            public void AnInfiniteY_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((0, double.NegativeInfinity));
            }
        }

        public class MinYAndMaxYTests : TestFixture
        {
            public void AreTheLowestAndHighestKnotY()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 2), (1, -3), (2, 5), (3, 1));

                CheckEqual(-3.0, function.MinY.Value);
                CheckEqual(5.0, function.MaxY.Value);
            }

            public void OfOneKnot_AreItsY()
            {
                PiecewiseLinear function = new PiecewiseLinear((4, 7));

                CheckEqual(7.0, function.MinY.Value);
                CheckEqual(7.0, function.MaxY.Value);
            }
        }

        public class EvaluateTests : TestFixture
        {
            public void OneKnot_IsConstant()
            {
                PiecewiseLinear function = new PiecewiseLinear((3, 9));

                CheckEqual(9.0, function.Evaluate(-100).Value);
                CheckEqual(9.0, function.Evaluate(3).Value);
                CheckEqual(9.0, function.Evaluate(100).Value);
            }

            public void AtAKnot_ReturnsItsY()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 1), (2, 5), (4, 3));

                CheckEqual(1.0, function.Evaluate(0).Value);
                CheckEqual(5.0, function.Evaluate(2).Value);
                CheckEqual(3.0, function.Evaluate(4).Value);
            }

            public void BetweenKnots_RunsStraightLine()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 1), (2, 5), (4, 3));

                CheckEqual(2.0, function.Evaluate(0.5).Value);
                CheckEqual(4.0, function.Evaluate(3).Value);
            }

            public void BelowTheFirstKnot_HoldsItsY()
            {
                CheckEqual(1.0, new PiecewiseLinear((0, 1), (2, 5)).Evaluate(-10).Value);
            }

            public void BeyondTheLastKnot_HoldsItsY()
            {
                CheckEqual(5.0, new PiecewiseLinear((0, 1), (2, 5)).Evaluate(10).Value);
            }

            public void AtAJump_TakesTheLaterY()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 0), (1, 0), (1, 4), (2, 4));

                CheckEqual(0.0, function.Evaluate(0.999).Value);
                CheckEqual(4.0, function.Evaluate(1).Value);
            }

            public void BetweenAJumpAndTheNextKnot_RunsFromTheLaterY()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 0), (1, 2), (1, 4), (3, 0));

                CheckEqual(2.0, function.Evaluate(2).Value);
            }

            public void ATripleJump_TakesTheLastY()
            {
                CheckEqual(3.0, new PiecewiseLinear((0, 0), (1, 1), (1, 2), (1, 3)).Evaluate(1).Value);
            }

            public void AJumpAtTheLastKnot_HoldsTheLaterY()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 0), (1, 1), (1, 6));

                CheckEqual(1.0 / 2.0, function.Evaluate(0.5).Value);
                CheckEqual(6.0, function.Evaluate(1).Value);
                CheckEqual(6.0, function.Evaluate(2).Value);
            }

            public void AJumpAtTheFirstKnot_HoldsTheLaterYAfterIt()
            {
                PiecewiseLinear function = new PiecewiseLinear((0, 1), (0, 5), (2, 7));

                CheckEqual(1.0, function.Evaluate(-1).Value);
                CheckEqual(5.0, function.Evaluate(0).Value);
                CheckEqual(6.0, function.Evaluate(1).Value);
            }

            public void ANotANumberX_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((0, 0)).Evaluate(double.NaN);
            }

            public void AnInfiniteX_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new PiecewiseLinear((0, 0)).Evaluate(double.PositiveInfinity);
            }

            public void AMethodGroup_EvaluatesTheFunction()
            {
                Func<Scalar, Scalar> shape = new PiecewiseLinear((0, 0), (1, 10)).Evaluate;

                CheckEqual(2.5, shape(0.25).Value);
            }
        }
    }
}