using System;

namespace Chernobyl.Measures.Time
{
    /// <summary>
    /// A unit of time in the International System of Units (SI).
    /// </summary>
    public struct Milliseconds : ITime, IEquatable<Milliseconds>, IComparable<Milliseconds>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Milliseconds"/> struct.
        /// </summary>
        /// <param name="value">The raw value of the measurement as a
        /// <see cref="Double"/>.</param>
        public Milliseconds(double value) : this()
        {
            Value = value;
        }

        /// <summary>
        /// Converts this unit of time to <see cref="Seconds"/>.
        /// </summary>
        /// <returns>This unit of measurement in <see cref="Seconds"/>.</returns>
        public Seconds ToSeconds()
        {
            return this;
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Seconds"/> to 
        /// <see cref="Milliseconds"/>.
        /// </summary>
        /// <param name="seconds">The amount of time in <see cref="Seconds"/>.</param>
        /// <returns>The result of the conversion.</returns>
        public static implicit operator Milliseconds(Seconds seconds)
        {
            return new Milliseconds(seconds.Value * 1000);
        }

        /// <summary>
        /// Performs an implicit conversion from <see cref="Milliseconds"/> to 
        /// <see cref="Seconds"/>.
        /// </summary>
        /// <param name="seconds">The amount of time in <see cref="Milliseconds"/>.</param>
        /// <returns>The result of the conversion.</returns>
        public static implicit operator Seconds(Milliseconds seconds)
        {
            return new Seconds(seconds.Value * .001);
        }

        /// <summary>
        /// Converts from <see cref="Milliseconds"/> to a floating point 
        /// representation of milliseconds.
        /// </summary>
        /// <param name="milliseconds">The Milliseconds to convert to float</param>
        /// <returns>The representative float.</returns>
        public static implicit operator double(Milliseconds milliseconds)
        {
            return milliseconds.Value;
        }

        /// <summary>
        /// Allows for a double to be explicitly casted to a <see cref="Milliseconds"/>.
        /// </summary>
        /// <param name="value">The value to be casted.</param>
        /// <returns>The casted object.</returns>
        public static explicit operator Milliseconds(double value)
        {
            return new Milliseconds(value);
        }

        /// <summary>
        /// Adds two <see cref="Milliseconds"/>.
        /// </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 Milliseconds operator +(Milliseconds left, Milliseconds right)
        {
            return new Milliseconds(left.Value + right.Value);
        }

        /// <summary>
        /// Subtracts two <see cref="Milliseconds"/>.
        /// </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 Milliseconds operator -(Milliseconds left, Milliseconds right)
        {
            return new Milliseconds(left.Value - right.Value);
        }

        /// <summary>
        /// Multiplies two <see cref="Milliseconds"/>.
        /// </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 Milliseconds operator *(Milliseconds left, Milliseconds right)
        {
            return new Milliseconds(left.Value * right.Value);
        }

        /// <summary>
        /// Divides two <see cref="Milliseconds"/>.
        /// </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 Milliseconds operator /(Milliseconds left, Milliseconds right)
        {
            return new Milliseconds(left.Value / right.Value);
        }

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

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

        /// <summary>
        /// Checks if two <see cref="Milliseconds"/> 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 ==(Milliseconds left, Milliseconds right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Checks if two <see cref="Milliseconds"/> 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 !=(Milliseconds left, Milliseconds right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Checks if one <see cref="Milliseconds"/> 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 millisecond, false if
        /// otherwise.</returns>
        public static bool operator <(Milliseconds left, Milliseconds right)
        {
            return left.Value < right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Milliseconds"/> 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 millisecond, false if
        /// otherwise.</returns>
        public static bool operator >(Milliseconds left, Milliseconds right)
        {
            return left.Value > right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Milliseconds"/> 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
        /// millisecond, false if otherwise.</returns>
        public static bool operator <=(Milliseconds left, Milliseconds right)
        {
            return left.Value <= right.Value;
        }

        /// <summary>
        /// Checks if one <see cref="Milliseconds"/> 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
        /// millisecond, false if otherwise.</returns>
        public static bool operator >=(Milliseconds left, Milliseconds right)
        {
            return left.Value >= right.Value;
        }

        /// <summary>
        /// Gets the hash code of the <see cref="Milliseconds"/>.
        /// </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(Milliseconds other)
        {
            return Value == other.Value;
        }

        /// <summary>
        /// Checks this <see cref="Milliseconds"/> 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="Milliseconds"/>,
        /// false if otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is Milliseconds && Equals((Milliseconds)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(Milliseconds other)
        {
            return Value.CompareTo(other.Value);
        }

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

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