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

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

        [Test, Description("A test that ensures the Metres<TTime>(Metres, TTime) " +
            "constructor sets the proper values.")]
        public void ConstructorMetresTTimeTest()
        {
            Metres<Seconds> metresPerSeconds = new Metres<Seconds>(new Metres(32.1), new Seconds(5));
            Assert.AreEqual(32.1 / 5, metresPerSeconds.Value, 0.0,
                "The value returned by Metres<Seconds>.Value is not the expected value.");
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            protected override Metres<Seconds> OppositeExpectedDivisionResult
            {
                get { return new Metres<Seconds>(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<TTime> type's equality " +
            "operator overloads.")]
        public class EqualityOperatorTests : EqualityOperatorTests<Metres<Seconds>>
        {
            protected override Metres<Seconds> CreateX()
            {
                return new Metres<Seconds>(32.1);
            }

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

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

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

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

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

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