using System;
using Chernobyl.Utility;

namespace Chernobyl.Mathematics
{
    /// <summary>
    /// Mathematics dealing with ranges
    /// </summary>
    public static class Range
    {
        /// <summary>
        /// The range between 0 and 1.
        /// </summary>
        public static readonly Tuple<double, double> Unit = new Tuple<double, double>(0.0, 1.0);

        /// <summary>
        /// Linearly normalizes a value to a new range based on the range it is currently bound to.
        /// </summary>
        /// <param name="value">The current value bounded by <paramref name="oldRange"/>.</param>
        /// <param name="oldRange">The current inclusive min (<see cref="Tuple{T1, T2}.Item1"/>) and
        /// inclusive max (<see cref="Tuple{T1, T2}.Item2"/>) range of <paramref name="value"/>.</param>
        /// <param name="newRange">The inclusive min (<see cref="Tuple{T1, T2}.Item1"/>) and
        /// inclusive max (<see cref="Tuple{T1, T2}.Item2"/>) range of the result.</param>
        /// <returns><paramref name="value"/> modified to be bound to <paramref name="newRange"/>.</returns>
        public static double Normalize(this double value, Tuple<double, double> oldRange, Tuple<double, double> newRange)
        {
            // This implementation was taken from https://stats.stackexchange.com/a/70808 and the
            // answer's comments.

            var oldMin = oldRange.Item1;
            var oldMax = oldRange.Item2;
            value.Throw(nameof(value)).IfLessThan(oldMin, $"{nameof(oldRange)} min").IfGreaterThan(oldMax, $"{nameof(oldRange)} max");
            oldMin.Throw($"{nameof(oldRange)} min").IfGreaterThanOrEqualTo(oldMax, $"{nameof(oldRange)} max");

            var newMin = newRange.Item1;
            var newMax = newRange.Item2;
            newMin.Throw($"{nameof(newRange)} min").IfGreaterThanOrEqualTo(newMax, $"{nameof(newRange)} max");

            var a = (newMax - newMin) / (oldMax - oldMin);
            var b = newMax - a * oldMax;

            // Decimal precision issues can sometimes cause the calculated value to be slightly
            // above or below the new min/max. So we clamp the value to prevent this.
            return (a * value + b).Clamp(newMin, newMax);
        }
    }
}