using System;
using Chernobyl.Measures.Speed;
using Chernobyl.Measures.Time;
using NUnit.Framework;

namespace Chernobyl.Measures.Length
{
    [TestFixture, Description("Tests for the Metres type.")]
    public class MetresTests
    {
        [Test, Description("A test that ensures the Metres(double) constructor " +
            "sets the proper value.")]
        public void ConstructorDoubleTest()
        {
            Metres metres = new Metres(32.1);
            Assert.AreEqual(32.1, metres.Value, 0.0,
                "The value returned by Metres.Value is not the expected value.");
        }

        [Test, Description("A test that ensures the Metres.Per<TTime>(TTime) " +
            "method creates the proper Metres<TTime>.")]
        public void PerTest()
        {
            Metres metres = new Metres(32.1);
            Metres<Seconds> metresPerSecond = metres.Per(new Seconds(5));

            Assert.AreEqual(32.1 / 5.0, metresPerSecond.Value, 0.0,
                "The value returned by Metres.Per<TTime>(TTime) is not the expected value.");
        }

        [Test, Description("A test to ensure the implicit Metres to double " + 
            "conversion works as expected.")]
        public void ImplicitDoubleToMetresConversionTest()
        {
            Metres metres = new Metres(32.1);

            double value = metres;
            Assert.AreEqual(metres.Value, value, 0.0,
                "The value returned by the implicit Metres to Double conversion " + 
                "is not the expected value.");
        }

        [Test, Description("A test to ensure the implicit Double to Metres " +
            "conversion works as expected.")]
        public void ExplicitDoubleToMetresConversionTest()
        {
            const double value = 32.1;
            Metres metres = (Metres)value;

            Assert.AreEqual(value, metres.Value, 0.0,
                "The value returned by the explicit Double to Metres conversion " +
                "is not the expected value.");
        }

        [TestFixture, Description("Tests for the IEquatable<T> and Object " + 
            "implementations of the Metres type.")]
        public class EquatableTests : EquatableTests<Metres>
        {
            protected override IEquatable<Metres> CreateEquatable()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateEqualObject()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateNotEqualObject()
            {
                return new Metres(15.5);
            }

            protected override string ExpectedToStringResult
            {
                get { return "32.1 m"; }
            }
        }

        [TestFixture, Description("Tests for the IComparable<T> implementation " +
            "of the Metres type.")]
        public class ComparableTests : ComparableTests<Metres>
        {
            protected override IComparable<Metres> CreateComparable()
            {
                return new Metres(32.0);
            }

            protected override Metres CreateLessThanObject()
            {
                return new Metres(15.0);
            }

            protected override Metres CreateEqualObject()
            {
                return new Metres(32.0);
            }

            protected override Metres CreateGreaterThanObject()
            {
                return new Metres(33.0);
            }
        }

        [TestFixture, Description("Tests for the Metres type's mathematical " + 
            "operator overloads.")]
        public class MathematicalOperatorTests : MathematicalOperatorTests<Metres>
        {

            protected override Metres CreateX()
            {
                return new Metres(X);
            }

            protected override Metres CreateY()
            {
                return new Metres(Y);
            }

            protected override Metres ExpectedBinaryAdditionResult
            {
                get { return new Metres(X + Y); }
            }

            protected override Metres ExpectedBinarySubtractionResult
            {
                get { return new Metres(X - Y); }
            }

            protected override Metres OppositeExpectedBinarySubtractionResult
            {
                get { return new Metres(Y - X); }
            }

            protected override Metres ExpectedNegationResult
            {
                get { return new Metres(-X); }
            }

            protected override Metres ExpectedMultiplicationResult
            {
                get { return new Metres(X * Y); }
            }

            protected override Metres ExpectedDivisionResult
            {
                get { return new Metres(X / Y); }
            }

            protected override Metres OppositeExpectedDivisionResult
            {
                get { return new Metres(Y / X); }
            }

            /// <summary>
            /// The double form of <see cref="CreateX()"/>.
            /// </summary>
            const double X = 32.1;

            /// <summary>
            /// The double form of <see cref="CreateY()"/>.
            /// </summary>
            const double Y = -56.75;
        }

        [TestFixture, Description("Tests for the Metres type's equality " +
            "operator overloads.")]
        public class EqualityOperatorTests : EqualityOperatorTests<Metres>
        {
            protected override Metres CreateX()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateEqual()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateNotEqual()
            {
                return new Metres(-43.6);
            }
        }

        [TestFixture, Description("Tests for the Metres type's relational " +
            "operator overloads.")]
        public class RelationalOperatorTests : RelationalOperatorTests<Metres>
        {
            protected override Metres CreateX()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateLessThan()
            {
                return new Metres(32.0);
            }

            protected override Metres CreateEqual()
            {
                return new Metres(32.1);
            }

            protected override Metres CreateGreaterThan()
            {
                return new Metres(32.2);
            }
        }
    }
}