using System;

namespace Chernobyl.Measures
{
    /// <summary>
    /// A rotation in Radians. Used when a degree value is required. 
    /// Often times, a person can mistake degrees for radians or vice 
    /// versa and this can cause hard to detect bugs. This struct helps 
    /// alleviate that problem. This struct can automatically convert to
    /// Degrees.
    /// </summary>
    [Serializable]
    public struct Radian : IEquatable<Radian>, IComparable<Radian>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="value">The amount in radians.</param>
        public Radian(float value) : this()
        {
            Value = value;
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="value">The amount in degrees.</param>
        public Radian(Degree value) : this()
        {
            const float degreeToRadian = (float)Math.PI / 180.0f;
            Value = value * degreeToRadian;
        }

        /// <summary>
        /// Converts from Degrees to Radians.
        /// </summary>
        /// <param name="number">The Degree to convert to Radians.</param>
        /// <returns>The representative Radian.</returns>
        public static implicit operator Radian(Degree number)
        {
            return new Radian(number);
        }

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

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

        /// <summary>
        /// Adds two Radians.
        /// </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 Radian operator +(Radian left, Radian right)
        {
            return new Radian(left.Value + right.Value);
        }

        /// <summary>
        /// Subtracts two Radians.
        /// </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 Radian operator -(Radian left, Radian right)
        {
            return new Radian(left.Value - right.Value);
        }

        /// <summary>
        /// Multiplies two Radians.
        /// </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 Radian operator *(Radian left, Radian right)
        {
            return new Radian(left.Value * right.Value);
        }

        /// <summary>
        /// Divides two Radians.
        /// </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 Radian operator /(Radian left, Radian right)
        {
            return new Radian(left.Value / right.Value);
        }

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

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

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

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

        /// <summary>
        /// Checks this Radian 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 Radian, false
        /// if otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is Radian && Equals((Radian)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:
        /// Value Less than zero - this object is less than the 
        /// <paramref name="other"/> parameter.
        /// Zero - this object is equal to <paramref name="other"/>.
        /// Greater than zero - this object is greater than 
        /// <paramref name="other"/>.
        /// </returns>
        public int CompareTo(Radian other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// The value of this Radian in radians.
        /// </summary>
        public float Value { get; private set; }
    }
}