using System;

namespace MoonTools
{
    public static class Easing
    {
        // argument checker

        private static void CheckTime(float time, float duration)
        {
            if (time > duration) { throw new ArgumentException($"{time} is invalid. Must be less than {duration}."); }
        }

        private static void CheckTime(double time, double duration)
        {
            if (time > duration) { throw new ArgumentException($"{time} is invalid. Must be less than {duration}."); }
        }

        // function transformations
        private static float NormalizedTime(Func<float, float, float, float, float> easingFunction, float t) => easingFunction(t, 0, 1, 1);
        private static float TimeRange(Func<float, float> easingFunction, float time, float start, float end) => start + ((end - start) * easingFunction((time - start) / (end - start)));

        private static float OutIn(Func<float, float, float, float, float> outFunc,
                            Func<float, float, float, float, float> inFunc,
                            float t,
                            float b,
                            float c,
                            float d)
        {
            if (t < d / 2)
            {
                return outFunc(t * 2, b, c / 2, d);
            }
            else
            {
                return inFunc((t * 2) - d, b + (c / 2), c / 2, d);
            }
        }

        private static double NormalizedTime(Func<double, double, double, double, double> easingFunction, double t) => easingFunction(t, 0, 1, 1);
        private static double TimeRange(Func<double, double> easingFunction, double time, double start, double end) => start + ((end - start) * easingFunction((time - start) / (end - start)));

        private static double OutIn(Func<double, double, double, double, double> outFunc,
                                    Func<double, double, double, double, double> inFunc,
                                    double t,
                                    double b,
                                    double c,
                                    double d)
        {
            if (t < d / 2)
            {
                return outFunc(t * 2, b, c / 2, d);
            }
            else
            {
                return inFunc((t * 2) - d, b + (c / 2), c / 2, d);
            }
        }

        /********* EASING FUNCTIONS ********/

        // LINEAR

        public static float Linear(float t) => NormalizedTime(Linear, t);
        public static float Linear(float time, float start, float end) => TimeRange(Linear, time, start, end);

        public static float Linear(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            return (c * t / d) + b;
        }

        public static double Linear(double t) => NormalizedTime(Linear, t);
        public static double Linear(double time, double start, double end) => TimeRange(Linear, time, start, end);

        public static double Linear(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            return (c * t / d) + b;
        }

        // IN QUAD

        public static float InQuad(float t) => NormalizedTime(InQuad, t);
        public static float InQuad(float time, float start, float end) => TimeRange(InQuad, time, start, end);

        public static float InQuad(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t)) + b;
        }

        public static double InQuad(double t) => NormalizedTime(InQuad, t);
        public static double InQuad(double time, double start, double end) => TimeRange(InQuad, time, start, end);

        public static double InQuad(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t)) + b;
        }

        // OUT QUAD

        public static float OutQuad(float t) => NormalizedTime(OutQuad, t);
        public static float OutQuad(float time, float start, float end) => TimeRange(OutQuad, time, start, end);

        public static float OutQuad(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t /= d;
            return (-c * t * (t - 2)) + b;
        }

        public static double OutQuad(double t) => NormalizedTime(OutQuad, t);
        public static double OutQuad(double time, double start, double end) => TimeRange(OutQuad, time, start, end);

        public static double OutQuad(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (-c * t * (t - 2)) + b;
        }

        // IN OUT QUAD

        public static float InOutQuad(float t) => NormalizedTime(InOutQuad, t);
        public static float InOutQuad(float time, float start, float end) => TimeRange(InOutQuad, time, start, end);

        public static float InOutQuad(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t)) + b;
            }
            else
            {
                return (-c / 2 * (((t - 1) * (t - 3)) - 1)) + b;
            }
        }

        public static double InOutQuad(double t) => NormalizedTime(InOutQuad, t);
        public static double InOutQuad(double time, double start, double end) => TimeRange(InOutQuad, time, start, end);

        public static double InOutQuad(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t)) + b;
            }
            else
            {
                return (-c / 2 * (((t - 1) * (t - 3)) - 1)) + b;
            }
        }

        // OUT IN QUAD

        public static float OutInQuad(float t) => NormalizedTime(OutInQuad, t);
        public static float OutInQuad(float time, float start, float end) => TimeRange(OutInQuad, time, start, end);
        public static float OutInQuad(float t, float b, float c, float d) => OutIn(OutQuad, InQuad, t, b, c, d);

        public static double OutInQuad(double t) => NormalizedTime(OutInQuad, t);
        public static double OutInQuad(double time, double start, double end) => TimeRange(OutInQuad, time, start, end);
        public static double OutInQuad(double t, double b, double c, double d) => OutIn(OutQuad, InQuad, t, b, c, d);

        // IN CUBIC

        public static float InCubic(float t) => NormalizedTime(InCubic, t);
        public static float InCubic(float time, float start, float end) => TimeRange(InCubic, time, start, end);

        public static float InCubic(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t)) + b;
        }

        public static double InCubic(double t) => NormalizedTime(InCubic, t);
        public static double InCubic(double time, double start, double end) => TimeRange(InCubic, time, start, end);

        public static double InCubic(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t)) + b;
        }

        // OUT CUBIC

        public static float OutCubic(float t) => NormalizedTime(OutCubic, t);
        public static float OutCubic(float time, float start, float end) => TimeRange(OutCubic, time, start, end);

        public static float OutCubic(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * ((t * t * t) + 1)) + b;
        }

        public static double OutCubic(double t) => NormalizedTime(OutCubic, t);
        public static double OutCubic(double time, double start, double end) => TimeRange(OutCubic, time, start, end);

        public static double OutCubic(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * ((t * t * t) + 1)) + b;
        }

        // IN OUT CUBIC

        public static float InOutCubic(float t) => NormalizedTime(InOutCubic, t);
        public static float InOutCubic(float time, float start, float end) => TimeRange(InOutCubic, time, start, end);

        public static float InOutCubic(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * t * t * t) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * ((t * t * t) + 2)) + b;
            }
        }

        // IN OUT CUBIC

        public static double InOutCubic(double t) => NormalizedTime(InOutCubic, t);
        public static double InOutCubic(double time, double start, double end) => TimeRange(InOutCubic, time, start, end);

        public static double InOutCubic(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * t * t * t) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * ((t * t * t) + 2)) + b;
            }
        }

        // OUT IN CUBIC

        public static float OutInCubic(float t) => NormalizedTime(OutInCubic, t);
        public static float OutInCubic(float time, float start, float end) => TimeRange(OutInCubic, time, start, end);
        public static float OutInCubic(float t, float b, float c, float d) => OutIn(OutCubic, InCubic, t, b, c, d);

        public static double OutInCubic(double t) => NormalizedTime(OutInCubic, t);
        public static double OutInCubic(double time, double start, double end) => TimeRange(OutInCubic, time, start, end);
        public static double OutInCubic(double t, double b, double c, double d) => OutIn(OutCubic, InCubic, t, b, c, d);

        // IN QUARTIC

        public static float InQuart(float t) => NormalizedTime(InQuart, t);
        public static float InQuart(float time, float start, float end) => TimeRange(InQuart, time, start, end);

        public static float InQuart(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t * t)) + b;
        }

        public static double InQuart(double t) => NormalizedTime(InQuart, t);
        public static double InQuart(double time, double start, double end) => TimeRange(InQuart, time, start, end);

        public static double InQuart(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t * t)) + b;
        }

        // OUT QUARTIC

        public static float OutQuart(float t) => NormalizedTime(OutQuart, t);
        public static float OutQuart(float time, float start, float end) => TimeRange(OutQuart, time, start, end);

        public static float OutQuart(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (-c * ((t * t * t * t) - 1)) + b;
        }

        public static double OutQuart(double t) => NormalizedTime(OutQuart, t);
        public static double OutQuart(double time, double start, double end) => TimeRange(OutQuart, time, start, end);

        public static double OutQuart(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (-c * ((t * t * t * t) - 1)) + b;
        }

        // IN OUT QUARTIC

        public static float InOutQuart(float t) => NormalizedTime(InOutQuart, t);
        public static float InOutQuart(float time, float start, float end) => TimeRange(InOutQuart, time, start, end);

        public static float InOutQuart(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t * t * t)) + b;
            }
            else
            {
                t -= 2;
                return (-c / 2 * ((t * t * t * t) - 2)) + b;
            }
        }

        public static double InOutQuart(double t) => NormalizedTime(InOutQuart, t);
        public static double InOutQuart(double time, double start, double end) => TimeRange(InOutQuart, time, start, end);

        public static double InOutQuart(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t * t * t)) + b;
            }
            else
            {
                t -= 2;
                return (-c / 2 * ((t * t * t * t) - 2)) + b;
            }
        }

        // OUT IN QUARTIC

        public static float OutInQuart(float t) => NormalizedTime(OutInQuart, t);
        public static float OutInQuart(float time, float start, float end) => TimeRange(OutInQuart, time, start, end);
        public static float OutInQuart(float t, float b, float c, float d) => OutIn(OutQuart, InQuart, t, b, c, d);

        public static double OutInQuart(double t) => NormalizedTime(OutInQuart, t);
        public static double OutInQuart(double time, double start, double end) => TimeRange(OutInQuart, time, start, end);
        public static double OutInQuart(double t, double b, double c, double d) => OutIn(OutQuart, InQuart, t, b, c, d);

        // IN QUINTIC

        public static float InQuint(float t) => NormalizedTime(InQuint, t);
        public static float InQuint(float time, float start, float end) => TimeRange(InQuint, time, start, end);

        public static float InQuint(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t * t * t)) + b;
        }

        public static double InQuint(double t) => NormalizedTime(InQuint, t);
        public static double InQuint(double time, double start, double end) => TimeRange(InQuint, time, start, end);

        public static double InQuint(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (c * (t * t * t * t * t)) + b;
        }

        // OUT QUINTIC

        public static float OutQuint(float t) => NormalizedTime(OutQuint, t);
        public static float OutQuint(float time, float start, float end) => TimeRange(OutQuint, time, start, end);

        public static float OutQuint(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * ((t * t * t * t * t) + 1)) + b;
        }

        public static double OutQuint(double t) => NormalizedTime(OutQuint, t);
        public static double OutQuint(double time, double start, double end) => TimeRange(OutQuint, time, start, end);

        public static double OutQuint(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * ((t * t * t * t * t) + 1)) + b;
        }

        // IN OUT QUINTIC

        public static float InOutQuint(float t) => NormalizedTime(InOutQuint, t);
        public static float InOutQuint(float time, float start, float end) => TimeRange(InOutQuint, time, start, end);

        public static float InOutQuint(float t, float b, float c, float d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t * t * t * t)) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * ((t * t * t * t * t) + 2)) + b;
            }
        }

        public static double InOutQuint(double t) => NormalizedTime(InOutQuint, t);
        public static double InOutQuint(double time, double start, double end) => TimeRange(InOutQuint, time, start, end);

        public static double InOutQuint(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t * t * t * t)) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * ((t * t * t * t * t) + 2)) + b;
            }
        }

        // OUT IN QUINTIC

        public static float OutInQuint(float t) => NormalizedTime(OutInQuint, t);
        public static float OutInQuint(float time, float start, float end) => TimeRange(OutInQuint, time, start, end);
        public static float OutInQuint(float t, float b, float c, float d) => OutIn(OutQuint, InQuint, t, b, c, d);

        public static double OutInQuint(double t) => NormalizedTime(OutInQuint, t);
        public static double OutInQuint(double time, double start, double end) => TimeRange(OutInQuint, time, start, end);
        public static double OutInQuint(double t, double b, double c, double d) => OutIn(OutQuint, InQuint, t, b, c, d);

        // note: no float implementations because trig functions are double precision

        // IN SINE

        public static double InSine(double t) => NormalizedTime(InSine, t);
        public static double InSine(double time, double start, double end) => TimeRange(InSine, time, start, end);

        public static double InSine(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            return (-c * Math.Cos(t / d * (Math.PI / 2))) + c + b;
        }

        // OUT SINE

        public static double OutSine(double t) => NormalizedTime(OutSine, t);
        public static double OutSine(double time, double start, double end) => TimeRange(OutSine, time, start, end);

        public static double OutSine(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            return (c * Math.Sin(t / d * (Math.PI / 2))) + b;
        }

        // IN OUT SINE

        public static double InOutSine(double t) => NormalizedTime(InOutSine, t);
        public static double InOutSine(double time, double start, double end) => TimeRange(InOutSine, time, start, end);

        public static double InOutSine(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            return (-c / 2 * (Math.Cos(Math.PI * t / d) - 1)) + b;
        }

        // OUT IN SINE

        public static double OutInSine(double t) => NormalizedTime(OutInSine, t);
        public static double OutInSine(double time, double start, double end) => TimeRange(OutInSine, time, start, end);
        public static double OutInSine(double t, double b, double c, double d) => OutIn(OutSine, InSine, t, b, c, d);

        // IN EXPONENTIAL

        public static double InExpo(double t) => NormalizedTime(InExpo, t);
        public static double InExpo(double time, double start, double end) => TimeRange(InExpo, time, start, end);

        public static double InExpo(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            if (t == 0)
            {
                return b;
            }
            else
            {
                return (c * Math.Pow(2, 10 * ((t / d) - 1))) + b - (c * 0.001);
            }
        }

        // OUT EXPONENTIAL

        public static double OutExpo(double t) => NormalizedTime(OutExpo, t);
        public static double OutExpo(double time, double start, double end) => TimeRange(OutExpo, time, start, end);

        public static double OutExpo(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            if (t == d)
            {
                return b + c;
            }
            else
            {
                return (c * 1.001 * (-Math.Pow(2, -10 * t / d) + 1)) + b;
            }
        }

        // IN OUT EXPONENTIAL

        public static double InOutExpo(double t) => NormalizedTime(InOutExpo, t);
        public static double InOutExpo(double time, double start, double end) => TimeRange(InOutExpo, time, start, end);

        public static double InOutExpo(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            if (t == 0) { return b; }
            if (t == d) { return b + c; }
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * Math.Pow(2, 10 * (t - 1))) + b - (c * 0.0005);
            }
            else
            {
                t--;
                return (c / 2 * 1.0005 * (-Math.Pow(2, -10 * t) + 2)) + b;
            }
        }

        // OUT IN EXPONENTIAL

        public static double OutInExpo(double t) => NormalizedTime(OutInExpo, t);
        public static double OutInExpo(double time, double start, double end) => TimeRange(OutInExpo, time, start, end);
        public static double OutInExpo(double t, double b, double c, double d) => OutIn(OutExpo, InExpo, t, b, c, d);

        // IN CIRCULAR

        public static double InCirc(double t) => NormalizedTime(InCirc, t);
        public static double InCirc(double time, double start, double end) => TimeRange(InCirc, time, start, end);

        public static double InCirc(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            return (-c * (Math.Sqrt(1 - (t * t)) - 1)) + b;
        }

        // OUT CIRCULAR

        public static double OutCirc(double t) => NormalizedTime(OutCirc, t);
        public static double OutCirc(double time, double start, double end) => TimeRange(OutCirc, time, start, end);

        public static double OutCirc(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * Math.Sqrt(1 - (t * t))) + b;
        }

        // IN OUT CIRCULAR

        public static double InOutCirc(double t) => NormalizedTime(InOutCirc, t);
        public static double InOutCirc(double time, double start, double end) => TimeRange(InOutCirc, time, start, end);

        public static double InOutCirc(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t = t / d * 2;
            if (t < 1)
            {
                return (-c / 2 * (Math.Sqrt(1 - (t * t)) - 1)) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * (Math.Sqrt(1 - (t * t)) + 1)) + b;
            }
        }

        // OUT IN CIRCULAR

        public static double OutInCirc(double t) => NormalizedTime(OutInCirc, t);
        public static double OutInCirc(double time, double start, double end) => TimeRange(OutInCirc, time, start, end);
        public static double OutInCirc(double t, double b, double c, double d) => OutIn(OutCirc, InCirc, t, b, c, d);

        // ELASTIC functions have two optional extra arguments
        // a: amplitude
        // p: period

        // IN ELASTIC

        public static double InElasticNormalized(double t) => InElastic(t, 0, 1, 1);
        public static double InElasticNormalized(double t, double a) => InElastic(t, 0, 1, 1, a);
        public static double InElasticNormalized(double t, double a, double p) => InElastic(t, 0, 1, 1, a, p);

        public static double InElasticTimeRange(double time, double start, double end) => start + ((end - start) * InElasticNormalized((time - start) / (end - start)));
        public static double InElasticTimeRange(double time, double start, double end, double a) => start + ((end - start) * InElasticNormalized((time - start) / (end - start), a));
        public static double InElasticTimeRange(double time, double start, double end, double a, double p) => start + ((end - start) * InElasticNormalized((time - start) / (end - start), a, p));

        public static double InElastic(double t, double b, double c, double d, double? a = null, double? p = null)
        {
            CheckTime(t, d);

            if (t == 0) { return b; }

            t /= d;

            if (t == 1) { return b + c; }

            if (!p.HasValue) { p = d * 0.3; }

            double s;
            if (!a.HasValue || a.Value < Math.Abs(c))
            {
                a = c;
                s = p.Value / 4;
            }
            else
            {
                s = p.Value / (2 * Math.PI) * Math.Asin(c / a.Value);
            }

            t--;

            return -(a.Value * Math.Pow(2, 10 * t) * Math.Sin(((t * d) - s) * (2 * Math.PI) / p.Value)) + b;
        }

        // OUT ELASTIC

        public static double OutElasticNormalized(double t) => OutElastic(t, 0, 1, 1);
        public static double OutElasticNormalized(double t, double a) => OutElastic(t, 0, 1, 1, a);
        public static double OutElasticNormalized(double t, double a, double p) => OutElastic(t, 0, 1, 1, a, p);

        public static double OutElasticTimeRange(double time, double start, double end) => start + ((end - start) * OutElasticNormalized((time - start) / (end - start)));
        public static double OutElasticTimeRange(double time, double start, double end, double a) => start + ((end - start) * OutElasticNormalized((time - start) / (end - start), a));
        public static double OutElasticTimeRange(double time, double start, double end, double a, double p) => start + ((end - start) * OutElasticNormalized((time - start) / (end - start), a, p));

        public static double OutElastic(double t, double b, double c, double d, double? a = null, double? p = null)
        {
            CheckTime(t, d);

            if (t == 0) { return b; }

            t /= d;

            if (t == 1) { return b + c; }

            if (!p.HasValue) { p = d * 0.3; }

            double s;

            if (!a.HasValue || a.Value < Math.Abs(c))
            {
                a = c;
                s = p.Value / 4;
            }
            else
            {
                s = p.Value / (2 * Math.PI) * Math.Asin(c / a.Value);
            }

            return (a.Value * Math.Pow(2, -10 * t) * Math.Sin(((t * d) - s) * (2 * Math.PI) / p.Value)) + c + b;
        }

        // IN OUT ELASTIC

        public static double InOutElasticNormalized(double t) => InOutElastic(t, 0, 1, 1);
        public static double InOutElasticNormalized(double t, double a) => InOutElastic(t, 0, 1, 1, a);
        public static double InOutElasticNormalized(double t, double a, double p) => InOutElastic(t, 0, 1, 1, a, p);

        public static double InOutElasticTimeRange(double time, double start, double end) => start + ((end - start) * InOutElasticNormalized((time - start) / (end - start)));
        public static double InOutElasticTimeRange(double time, double start, double end, double a) => start + ((end - start) * InOutElasticNormalized((time - start) / (end - start), a));
        public static double InOutElasticTimeRange(double time, double start, double end, double a, double p) => start + ((end - start) * InOutElasticNormalized((time - start) / (end - start), a, p));

        public static double InOutElastic(double t, double b, double c, double d, double? a = null, double? p = null)
        {
            CheckTime(t, d);

            if (t == 0) { return b; }

            t = t / d * 2;

            if (t == 2) { return b + c; }

            if (!p.HasValue) { p = d * (0.3 * 1.5); }
            if (!a.HasValue) { a = 0; }

            double s;

            if (!a.HasValue || a < Math.Abs(c))
            {
                a = c;
                s = p.Value / 4;
            }
            else
            {
                s = p.Value / (2 * Math.PI) * Math.Asin(c / a.Value);
            }

            if (t < 1)
            {
                t--;
                return (-0.5 * (a.Value * Math.Pow(2, 10 * t) * Math.Sin(((t * d) - s) * (2 * Math.PI) / p.Value))) + b;
            }
            else
            {
                t--;
                return (a.Value * Math.Pow(2, -10 * t) * Math.Sin(((t * d) - s) * (2 * Math.PI) / p.Value) * 0.5) + c + b;
            }
        }

        // OUT IN ELASTIC

        public static double OutInElasticNormalized(double t) => OutInElastic(t, 0, 1, 1);
        public static double OutInElasticNormalized(double t, double a) => OutInElastic(t, 0, 1, 1, a);
        public static double OutInElasticNormalized(double t, double a, double p) => OutInElastic(t, 0, 1, 1, a, p);

        public static double OutInElasticTimeRange(double time, double start, double end) => start + ((end - start) * OutInElasticNormalized((time - start) / (end - start)));
        public static double OutInElasticTimeRange(double time, double start, double end, double a) => start + ((end - start) * OutInElasticNormalized((time - start) / (end - start), a));
        public static double OutInElasticTimeRange(double time, double start, double end, double a, double p) => start + ((end - start) * OutInElasticNormalized((time - start) / (end - start), a, p));

        public static double OutInElastic(double t, double b, double c, double d, double? a = null, double? p = null)
        {
            if (t < d / 2)
            {
                return OutElastic(t * 2, b, c / 2, d, a, p);
            }
            else
            {
                return InElastic((t * 2) - d, b + (c / 2), c / 2, d, a, p);
            }
        }

        // back functions take an optional parameter
        // s: size

        // IN BACK

        public static double InBackNormalized(double t) => InBack(t, 0, 1, 1);
        public static double InBackNormalized(double t, double s) => InBack(t, 0, 1, 1, s);
        public static double InBackTimeRange(double time, double start, double end) => start + ((end - start) * InBackNormalized((time - start) / (end - start)));
        public static double InBackTimeRange(double time, double start, double end, double s) => start + ((end - start) * InBackNormalized((time - start) / (end - start), s));

        public static double InBack(double t, double b, double c, double d, double s = 1.70158)
        {
            CheckTime(t, d);
            t /= d;
            return (c * t * t * (((s + 1) * t) - s)) + b;
        }

        // OUT BACK

        public static double OutBackNormalized(double t) => OutBack(t, 0, 1, 1);
        public static double OutBackNormalized(double t, double s) => OutBack(t, 0, 1, 1, s);
        public static double OutBackTimeRange(double time, double start, double end) => start + ((end - start) * OutBackNormalized((time - start) / (end - start)));
        public static double OutBackTimeRange(double time, double start, double end, double s) => start + ((end - start) * OutBackNormalized((time - start) / (end - start), s));

        public static double OutBack(double t, double b, double c, double d, double s = 1.70158)
        {
            CheckTime(t, d);
            t = (t / d) - 1;
            return (c * ((t * t * (((s + 1) * t) + s)) + 1)) + b;
        }

        // IN OUT BACK

        public static double InOutBackNormalized(double t) => InOutBack(t, 0, 1, 1);
        public static double InOutBackNormalized(double t, double s) => InOutBack(t, 0, 1, 1, s);
        public static double InOutBackTimeRange(double time, double start, double end) => start + ((end - start) * InOutBackNormalized((time - start) / (end - start)));
        public static double InOutBackTimeRange(double time, double start, double end, double s) => start + ((end - start) * InOutBackNormalized((time - start) / (end - start), s));

        public static double InOutBack(double t, double b, double c, double d, double s = 1.70158)
        {
            CheckTime(t, d);
            s *= 1.525;
            t = t / d * 2;
            if (t < 1)
            {
                return (c / 2 * (t * t * (((s + 1) * t) - s))) + b;
            }
            else
            {
                t -= 2;
                return (c / 2 * ((t * t * (((s + 1) * t) + s)) + 2)) + b;
            }
        }

        // OUT IN BACK

        public static double OutInBackNormalized(double t) => OutInBack(t, 0, 1, 1);
        public static double OutInBackNormalized(double t, double s) => OutInBack(t, 0, 1, 1, s);
        public static double OutInBackTimeRange(double time, double start, double end) => start + ((end - start) * OutInBackNormalized((time - start) / (end - start)));
        public static double OutInBackTimeRange(double time, double start, double end, double s) => start + ((end - start) * OutInBackNormalized((time - start) / (end - start), s));

        public static double OutInBack(double t, double b, double c, double d, double s = 1.70158)
        {
            if (t < d / 2)
            {
                return OutBack(t * 2, b, c / 2, d, s);
            }
            else
            {
                return InBack((t * 2) - d, b + (c / 2), c / 2, d, s);
            }
        }

        // OUT BOUNCE

        public static double OutBounce(double t) => NormalizedTime(OutBounce, t);
        public static double OutBounce(double time, double start, double end) => TimeRange(OutBounce, time, start, end);

        public static double OutBounce(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            t /= d;
            if (t < 1 / 2.75)
            {
                return (c * (7.5625 * t * t)) + b;
            }
            else if (t < 2 / 2.75)
            {
                t -= (1.5 / 2.75);
                return (c * ((7.5625 * t * t) + 0.75)) + b;
            }
            else if (t < 2.5 / 2.75)
            {
                t -= (2.25 / 2.75);
                return (c * ((7.5625 * t * t) + 0.9375)) + b;
            }
            else
            {
                t -= (2.625 / 2.75);
                return (c * ((7.5625 * t * t) + 0.984375)) + b;
            }
        }

        // IN BOUNCE

        public static double InBounce(double t) => NormalizedTime(InBounce, t);
        public static double InBounce(double time, double start, double end) => TimeRange(InBounce, time, start, end);

        public static double InBounce(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            return c - OutBounce(d - t, 0, c, d) + b;
        }

        // IN OUT BOUNCE

        public static double InOutBounce(double t) => NormalizedTime(InOutBounce, t);
        public static double InOutBounce(double time, double start, double end) => TimeRange(InOutBounce, time, start, end);

        public static double InOutBounce(double t, double b, double c, double d)
        {
            CheckTime(t, d);
            if (t < d / 2)
            {
                return (InBounce(t * 2, 0, c, d) * 0.5) + b;
            }
            else
            {
                return (OutBounce((t * 2) - d, 0, c, d) * 0.5) + (c * 0.5) + b;
            }
        }

        // OUT IN BOUNCE

        public static double OutInBounce(double t) => NormalizedTime(OutInBounce, t);
        public static double OutInBounce(double time, double start, double end) => TimeRange(OutInBounce, time, start, end);
        public static double OutInBounce(double t, double b, double c, double d) => OutIn(OutBounce, InBounce, t, b, c, d);
    }
}