using System;

namespace Chernobyl.Measures
{
    /// <summary>
    /// A rotation in degrees. 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
    /// Radians.
    /// </summary>
    [Serializable]
    public struct Degree : IEquatable<Degree>, IComparable<Degree>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="value">The amount in degrees.</param>
        public Degree(float value) : this()
        {
            Value = value;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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