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

namespace Chernobyl.Measures.Speed
{
    /// <summary>
    /// A measurement for speed defined as metres per <typeparamref name="TTime"/>
    /// where <typeparamref name="TTime"/> is the type of time being used.
    /// </summary>
    /// <typeparam name="TTime">The type to use for measuring time.</typeparam>
    public struct Metres<TTime>
        : IMeasurement<Double>, IEquatable<Metres<TTime>>, IComparable<Metres<TTime>>
        where TTime : ITime
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Metres{TTime}"/> struct.
        /// </summary>
        /// <param name="length">The distance that was traveled in the specified
        /// amount of <paramref name="time"/>.</param>
        /// <param name="time">The amount of time it took to travel the distance
        /// specified by <paramref name="length"/>.</param>
        public Metres(Metres length, TTime time)
            : this(length / time.Value)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="Metres{TTime}"/> struct.
        /// </summary>
        /// <param name="value">The raw value as metres per second in the form 
        /// of a <see cref="Double"/>.</param>
        public Metres(double value) : this()
        {
            Value = value;
        }

        /// <summary>
        /// Performs an explicit conversion from <see cref="Double"/> to 
        /// <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="value">The raw value as metres per second in the form 
        /// of a <see cref="Double"/>.</param>
        /// <returns>The result of the conversion.</returns>
        public static explicit operator Metres<TTime>(double value)
        {
            return new Metres<TTime>(value);
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Metres{TTime}"/> to 
        /// <see cref="Double"/>.
        /// </summary>
        /// <param name="value">The value as metres per 
        /// <typeparamref name="TTime"/> in the form of a 
        /// <see cref="Double"/>.</param>
        /// <returns>The result of the conversion.</returns>
        public static implicit operator double(Metres<TTime> value)
        {
            return value.Value;
        }

        /// <summary>
        /// Adds two <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator +(Metres<TTime> left, Metres<TTime> right)
        {
            return new Metres<TTime>(left.Value + right.Value);
        }

        /// <summary>
        /// Subtracts two <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator -(Metres<TTime> left, Metres<TTime> right)
        {
            return new Metres<TTime>(left.Value - right.Value);
        }

        /// <summary>
        /// Multiplies two <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator *(Metres<TTime> left, Metres<TTime> right)
        {
            return new Metres<TTime>(left.Value * right.Value);
        }

        /// <summary>
        /// Divides two <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator /(Metres<TTime> left, Metres<TTime> right)
        {
            return new Metres<TTime>(left.Value / right.Value);
        }

        /// <summary>
        /// Negates a <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="item">The item to negate.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator -(Metres<TTime> item)
        {
            return new Metres<TTime>(-item.Value);
        }

        /// <summary>
        /// Pluses a <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <param name="item">The item to plus.</param>
        /// <returns>The result of the operation.</returns>
        public static Metres<TTime> operator +(Metres<TTime> item)
        {
            return new Metres<TTime>(+item.Value);
        }

        /// <summary>
        /// Checks if two <see cref="Metres{TTime}"/> are equal to each other.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the two are equal, false if otherwise.</returns>
        public static bool operator ==(Metres<TTime> left, Metres<TTime> right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Checks if two <see cref="Metres{TTime}"/> are equal to each other.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the two are different, false if otherwise.</returns>
        public static bool operator !=(Metres<TTime> left, Metres<TTime> right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Checks if one <see cref="Metres{TTime}"/> is less than another.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the first operand is less than the second, false if
        /// otherwise.</returns>
        public static bool operator <(Metres<TTime> left, Metres<TTime> right)
        {
            return left.Value < right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Metres{TTime}"/> is more than another.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the first operand is more than the second, false if
        /// otherwise.</returns>
        public static bool operator >(Metres<TTime> left, Metres<TTime> right)
        {
            return left.Value > right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Metres{TTime}"/> is less than or equal to
        /// another.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the first operand is less than or equal to the
        /// second, false if otherwise.</returns>
        public static bool operator <=(Metres<TTime> left, Metres<TTime> right)
        {
            return left.Value <= right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Metres{TTime}"/> is more than or equal to 
        /// another.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the first operand is more than or equal to the
        /// second, false if otherwise.</returns>
        public static bool operator >=(Metres<TTime> left, Metres<TTime> right)
        {
            return left.Value >= right.Value;
        }

        /// <summary>
        /// Gets the hash code of the <see cref="Metres{TTime}"/>.
        /// </summary>
        /// <returns>The hash code of the number.</returns>
        public override int GetHashCode()
        {
            return Value.GetHashCode();
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of 
        /// the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>True if the current object is equal to the
        /// <paramref name="other"/> parameter; otherwise, false.</returns>
        public bool Equals(Metres<TTime> other)
        {
            return Value == other.Value;
        }

        /// <summary>
        /// Checks this <see cref="Metres{TTime}"/> for equality with object passed in.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns>True if the object is equal to this <see cref="Metres{TTime}"/>,
        /// false if otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is Metres<TTime> && Equals((Metres<TTime>)obj));
        }

        /// <summary>
        /// Compares the current object with another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>A 32-bit signed integer that indicates the relative order 
        /// of the objects being compared. The return value has the following 
        /// meanings: if the value is less than zero then this object is less 
        /// than the <paramref name="other"/> parameter. If it is zero then
        /// this object is equal to <paramref name="other"/>. If it is greater 
        /// than zero then this object is greater than <paramref name="other"/>.
        /// </returns>
        public int CompareTo(Metres<TTime> other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Returns a <see cref="String"/> that represents this instance. For
        /// example, 32.0 metres per second will be returned as "32.0 m/s".
        /// </summary>
        /// <returns>A <see cref="String"/> that represents this instance.</returns>
        public override string ToString()
        {
            return Value + " m/s";
        }

        /// <summary>
        /// The raw value as metres per second in the form of a 
        /// <see cref="Double"/>.
        /// </summary>
        public double Value { get; private set; }
    }

    /// <summary>
    /// A class that holds conversion methods for the <see cref="Metres{TTime}"/>
    /// type.
    /// </summary>
    public static class Conversions
    {
        /// <summary>
        /// Converts meters per second to metres per milliseconds.
        /// </summary>
        /// <param name="speed">The speed in metres per second.</param>
        /// <returns>The speed in the form of metres per millisecond.</returns>
        public static Metres<Milliseconds> ToMetersPerMillisecond(this Metres<Seconds> speed)
        {
            return new Metres<Milliseconds>((Metres)1, (Seconds)speed.Value);
        }
    }
}