using System;

namespace Chernobyl.Calculator
{
    /// <summary>
    /// This class is to be used with the ICalculator so that operators can be used with types in
    /// generic programming. This class does not infer any additional overhead versus straight operator
    /// invocation because of inlining methods on constrained parameters (see reference link below).
    /// References: the idea for this class came from: http://www.codeproject.com/KB/cs/genericnumerics.aspx
    /// </summary>
    /// <typeparam name="NumberType">The number type being represented such as float, int, etc.</typeparam>
    /// <typeparam name="CalculatorType">The calculator being used to calculate the represented
    /// data such as FloatCalculator, IntCalculator, etc.</typeparam>
    [Serializable]
    public struct Number<NumberType, CalculatorType>
        where CalculatorType : ICalculator<NumberType>, new()
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="value">The value to set the number to.</param>
        private Number(NumberType value)
        {
            this.value = value;
        }

        /// <summary>
        /// Converts from the number type being represented to a Number.
        /// </summary>
        /// <param name="number">The number to convert to a Number</param>
        /// <returns>The representative Number object.</returns>
        public static implicit operator Number<NumberType, CalculatorType>(NumberType number)
        {
            return new Number<NumberType, CalculatorType>(number);
        }

        /// <summary>
        /// Converts from the Number object to its number type.
        /// </summary>
        /// <param name="number">The number object to convert.</param>
        /// <returns>The value of the number object.</returns>
        public static implicit operator NumberType(Number<NumberType, CalculatorType> number)
        {
            return number.value;
        }

        /// <summary>
        /// Adds two Number objects.
        /// </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 Number<NumberType, CalculatorType> operator +(Number<NumberType, CalculatorType> left, Number<NumberType, CalculatorType> right)
        {
            return calculator.Add(left.value, right.value);
        }

        /// <summary>
        /// Subtracts two Number objects.
        /// </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 Number<NumberType, CalculatorType> operator -(Number<NumberType, CalculatorType> left, Number<NumberType, CalculatorType> right)
        {
            return calculator.Subtract(left.value, right.value);
        }

        /// <summary>
        /// Multiplies two Number objects.
        /// </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 Number<NumberType, CalculatorType> operator *(Number<NumberType, CalculatorType> left, Number<NumberType, CalculatorType> right)
        {
            return calculator.Multiply(left.value, right.value);
        }

        /// <summary>
        /// Divides two Number objects.
        /// </summary>
        /// <param name="dividend">The left side of the operation.</param>
        /// <param name="divisor">The right side of the operation.</param>
        /// <returns>The result of the operation.</returns>
        public static Number<NumberType, CalculatorType> operator /(Number<NumberType, CalculatorType> dividend, Number<NumberType, CalculatorType> divisor)
        {
            return calculator.Divide(dividend.value, divisor.value);
        }

        /// <summary>
        /// Negates a number
        /// </summary>
        /// <param name="item">The item to negate.</param>
        /// <returns>The result of the operation.</returns>
        public static Number<NumberType, CalculatorType> operator -(Number<NumberType, CalculatorType> item)
        {
            return calculator.Negate(item.value);
        }

        /// <summary>
        /// Checks if two numbers 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 ==(Number<NumberType, CalculatorType> left, Number<NumberType, CalculatorType> right)
        {
            return calculator.Compare(left.value, right.value);
        }

        /// <summary>
        /// Checks if two numbers 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 !=(Number<NumberType, CalculatorType> left, Number<NumberType, CalculatorType> right)
        {
            return !calculator.Compare(left.value, right.value);
        }

        /// <summary>
        /// Gets the hash code of the number.
        /// </summary>
        /// <returns>The hash code of the number.</returns>
        public override int GetHashCode()
        {
            return value.GetHashCode();
        }

        /// <summary>
        /// Checks this object for equality with object passed in.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            return value.Equals(obj);
        }

        /// <summary>
        /// The calculator used to calculate the value of number.
        /// </summary>
        static CalculatorType calculator = new CalculatorType();

        /// <summary>
        /// The number that is being represented by this struct.
        /// </summary>
        NumberType value;
    }

    /// <summary>
    /// Extension and utility methods for numbers.
    /// </summary>
    public static class Number
    {
        /// <summary>
        /// Rounds a floating point value to an integer (.5 and above will be rounded up, everything
        /// else will be rounded down).
        /// </summary>
        public static int RoundToInt(this float v) => (int)Math.Round(v, MidpointRounding.AwayFromZero);

        /// <summary>
        /// Rounds a floating point value to an integer (.5 and above will be rounded up, everything
        /// else will be rounded down).
        /// </summary>
        public static int RoundToInt(this double v) => (int)Math.Round(v, MidpointRounding.AwayFromZero);
    }
}