using System;

namespace Chernobyl.Measures.Time
{
    /// <summary>
    /// The base unit of time in the International System of Units (SI).
    /// </summary>
    public struct Seconds : ITime, IEquatable<Seconds>, IComparable<Seconds>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Seconds"/> struct.
        /// </summary>
        /// <param name="value">The raw value of the measurement as a
        /// <see cref="Double"/>.</param>
        public Seconds(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>
        /// Converts from <see cref="Seconds"/> to a floating point 
        /// representation of seconds.
        /// </summary>
        /// <param name="seconds">The Seconds to convert to float</param>
        /// <returns>The representative float.</returns>
        public static implicit operator double(Seconds seconds)
        {
            return seconds.Value;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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