/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include <math.h>
#include "easing/easing.h"

#define HALF_PI 1.57079632679f   /* PI/2 */
#define ONE_DIV_E 0.36787944117f /* 1/e */
#define PI_TIMES2 6.28318530718f  /* 2PI */

/* Custom */
static inline float exponential_custom_io(float step, float max_steps, float max_val)
{
    float R = max_steps * log10(2) / log10(max_val);
    return pow(2, (step / R)) - 1;
}

static inline float exp_sin_custom_io(float step, float max_steps, float max_val)
{
    float mplier = max_val / 2.35040238729f;
    float pi_d_maxs = M_PI / max_steps;
    step += max_steps;
    return ( exp( sin((step * pi_d_maxs) + M_PI_2)) - ONE_DIV_E ) * mplier;
}

static inline float sine_custom_io(float step, float max_steps, float max_val)
{
    return max_val * cos((PI_TIMES2 * step/max_steps) + M_PI) + max_val;
}

/* Linear */
static inline float linear_io(float step, float max_steps, float max_val)
{
	return step * max_val / max_steps;
}

/* Exponential */
static inline float exponential_in(float step, float max_steps, float max_val)
{
    return (step == 0) ?
        0 :
        pow(max_val, (float)step/max_steps);
}

static inline float exponential_out(float step, float max_steps, float max_val)
{
	return (step == max_steps) ?
        max_val :
        max_val - pow(max_val, 1.0 - (float)step/max_steps);
}

static inline float exponential_io(float step, float max_steps, float max_val)
{
	float ratio = ( (float)step / (max_steps / 2.0) );

	if (step == 0)
		return 0;

	if (step == max_steps)
		return max_val;

	if (ratio < 1)
        return powf((float)max_val/2.0, (float)step/(max_steps/2.0));

	return max_val/2.0 + max_val/2.0 -
        pow(max_val/2.0, 1.0 - ((float)step - (max_steps / 2)) /
            (max_steps / 2) );
}

/* Quadratic */
static inline float quadratic_in(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	return max_val * pow(ratio, 2);
}

static inline float quadratic_out(float step, float max_steps, float max_val)
{
    float ratio = step / max_steps;

	return -max_val * ratio * (ratio - 2.0);
}

static inline float quadratic_io(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps / 2.0);

	if (ratio < 1)
		return max_val / 2.0 * pow(ratio, 2);

    ratio = (step - (max_steps/2.0)) / (max_steps/2.0);
    return (max_val / 2.0) - (max_val / 2.0) * ratio * (ratio - 2.0);
}

/* Cubic */
static inline float cubic_in(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	return max_val * pow(ratio, 3);
}

static inline float cubic_out(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps - 1.0);

	return max_val * (pow(ratio, 3) + 1);
}

static inline float cubic_io(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps / 2.0);

	if (ratio < 1)
		return max_val / 2 * pow(ratio, 3);

	return max_val / 2 * (pow(ratio - 2, 3) + 2);
}

/* Quartic */
static inline float quartic_in(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	return max_val * pow(ratio, 4);
}

static inline float quartic_out(float step, float max_steps, float max_val)
{
	float ratio = (step / max_steps) - 1.0;

	return max_val + max_val * pow(ratio, 5);
}

static inline float quartic_io(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps / 2.0);

	if (ratio < 1)
		return max_val / 2 * pow(ratio, 4);

	return max_val + max_val / 2 * pow(ratio -2, 5);
}

/* Quintic */
static inline float quintic_in(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	return max_val * pow(ratio, 5);
}

static inline float quintic_out(float step, float max_steps, float max_val)
{
	float ratio = (step / max_steps) - 1.0;

	return max_val + max_val * pow(ratio, 5);
}

static inline float quintic_io(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps / 2.0);

	if (ratio < 1)
		return max_val / 2 * pow(ratio, 5);

    ratio -= 2;
	return max_val + max_val / 2 * pow(ratio, 5);
}

/* Circular */
static inline float circular_in(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	return - max_val * (sqrt(1 - pow(ratio, 2) ) - 1);
}

static inline float circular_out(float step, float max_steps, float max_val)
{
	float ratio = (step - max_steps) / (max_steps - 1.0);
	return max_val * sqrt(1 - pow(ratio, 2));
}

static inline float circular_io(float step, float max_steps, float max_val)
{
	float ratio = step / (max_steps / 2.0);

	if (ratio < 1)
		return - max_val / 2 * (sqrt(1 - pow(ratio, 2)) - 1);

	return max_val / 2 * (sqrt(1 - pow(ratio - 2, 2)) + 1);
}

/* Sine */
static inline float sine_in(float step, float max_steps, float max_val)
{
	return -max_val * cos((float)step / max_steps * M_PI_2) + max_val;
}

static inline float sine_out(float step, float max_steps, float max_val)
{
	return max_val * sin((((float)step / max_steps)) * M_PI_2);
}

static inline float sine_io(float step, float max_steps, float max_val)
{
	return -max_val / 2 * (cos(M_PI * step / max_steps) - 1);
}

/* Bounce */
static inline float bounce_out(float step, float max_steps, float max_val)
{
	float ratio = step / max_steps;

	if (ratio < (1 / 2.75)) {
		return max_val * (7.5625 * ratio * ratio);
	}

    if (ratio < (2 / 2.75)) {
        ratio -= 1.5 / 2.75;
		return max_val * (7.5625 * ratio * ratio + .75);
    }

    if (ratio < (2.5 / 2.75)) {
        ratio -= 2.25 / 2.75;
		return max_val * (7.5625 * ratio * ratio + .9375);
	}

    ratio -= 2.625 / 2.75;
    return max_val * (7.5625 * ratio * ratio + .984375);
}

static inline float bounce_in(float step, float max_steps, float max_val)
{
	return max_val - bounce_out(max_steps - step, max_steps, max_val);
}

static inline float bounce_io(float step, float max_steps, float max_val)
{
	if (step < max_steps / 2)
		return bounce_in(step * 2, max_steps, max_val) * 0.5;
	else
		return bounce_out(step * 2 - max_steps, max_steps, max_val) *
            0.5 + max_val * 0.5;
}

/* Back */
static inline float back_in(float step, float max_steps, float max_val)
{
	float s = 1.70158f;
    float ratio = step / max_steps;
	return max_val * ratio * ratio * ((s + 1) * ratio - s);

}

static inline float back_out(float step, float max_steps, float max_val)
{
	float s = 1.70158f;
	float ratio = (step / max_steps) - 1;
	return max_val * (ratio * ratio * ((s + 1) * ratio + s) + 1);
}

static inline float back_io(float step, float max_steps, float max_val)
{
    float s = 1.70158f * 1.525;
    float ratio = step / (max_steps / 2);

	if (ratio < 1)
        return max_val / 2 * (ratio * ratio * ((s + 1) * ratio - s));

	ratio -= 2;
	return max_val / 2 * (ratio * ratio * ((s + 1) * ratio + s) + 2);
}

/* Float Functions */

/* Custom, used for breathing */
float
exponential_custom_f_io(float step, float max_steps, float max_val)
{
    return exponential_custom_io(step, max_steps, max_val);
}
float
exp_sin_custom_f_io(float step, float max_steps, float max_val)
{
    return exp_sin_custom_io(step, max_steps, max_val);
}
float
sine_custom_f_io(float step, float max_steps, float max_val)
{
    return sine_custom_io(step, max_steps, max_val);
}

/* Linear */
float
linear_f_io(float step, float max_steps, float max_val)
{
    return linear_io(step, max_steps, max_val);
}

/* Exponential */
float
exponential_f_in(float step, float max_steps, float max_val)
{
    return exponential_in(step, max_steps, max_val);
}
float
exponential_f_out(float step, float max_steps, float max_val)
{
    return exponential_out(step, max_steps, max_val);
}
float
exponential_f_io(float step, float max_steps, float max_val)
{
    return exponential_io(step, max_steps, max_val);
}

/* Quadratic */
float
quadratic_f_in(float step, float max_steps, float max_val)
{
    return quadratic_in(step, max_steps, max_val);
}
float
quadratic_f_out(float step, float max_steps, float max_val)
{
    return quadratic_out(step, max_steps, max_val);
}
float
quadratic_f_io(float step, float max_steps, float max_val)
{
    return quadratic_io(step, max_steps, max_val);
}

/* Cubic */
float
cubic_f_in(float step, float max_steps, float max_val)
{
    return cubic_in(step, max_steps, max_val);
}
float
cubic_f_out(float step, float max_steps, float max_val)
{
    return cubic_out(step, max_steps, max_val);
}
float
cubic_f_int_io(float step, float max_steps, float max_val)
{
    return cubic_io(step, max_steps, max_val);
}

/* Quartic */
float
quartic_f_in(float step, float max_steps, float max_val)
{
    return quartic_in(step, max_steps, max_val);
}
float
quartic_f_out(float step, float max_steps, float max_val)
{
    return quartic_out(step,
                       max_steps,
                       max_val);
}
float
quartic_f_io(float step, float max_steps, float max_val)
{
    return quartic_io(step, max_steps, max_val);
}

/* Quintic */
float
quintic_f_in(float step, float max_steps, float max_val)
{
    return quintic_in(step, max_steps, max_val);
}
float
quintic_f_out(float step, float max_steps, float max_val)
{
    return quintic_out(step, max_steps, max_val);
}
float
quintic_f_io(float step, float max_steps, float max_val)
{
    return quintic_io(step, max_steps, max_val);
}

/* Circular */
float
circular_f_in(float step, float max_steps, float max_val)
{
    return circular_in(step, max_steps, max_val);
}
float
circular_f_out(float step, float max_steps, float max_val)
{
    return circular_out(step, max_steps, max_val);
}
float
circular_f_io(float step, float max_steps, float max_val)
{
    return circular_io(step, max_steps, max_val);
}

/* Sine */
float
sine_f_in(float step, float max_steps, float max_val)
{
    return sine_in(step, max_steps, max_val);
}
float
sine_f_out(float step, float max_steps, float max_val)
{
    return sine_out(step, max_steps, max_val);
}
float
sine_f_io(float step, float max_steps, float max_val)
{
    return sine_io(step, max_steps, max_val);
}

/* Bounce */
float
bounce_f_in(float step, float max_steps, float max_val)
{
    return bounce_in(step, max_steps, max_val);
}
float
bounce_f_out(float step, float max_steps, float max_val)
{
    return bounce_out(step, max_steps, max_val);
}
float
bounce_f_io(float step, float max_steps, float max_val)
{
    return bounce_io(step, max_steps, max_val);
}

/* Back */
float
back_f_in(float step, float max_steps, float max_val)
{
    return back_in(step, max_steps, max_val);
}
float
back_f_out(float step, float max_steps, float max_val)
{
    return back_out(step, max_steps, max_val);
}
float
back_f_io(float step, float max_steps, float max_val)
{
    return back_io(step, max_steps, max_val);
}

/* Integer Functions */
/* Custom */
int32_t
exponential_custom_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) exponential_custom_io((float) step,
                                           (float) max_steps,
                                           (float) max_val);
}
int32_t
exp_sin_custom_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) exp_sin_custom_io((float) step,
                                       (float) max_steps,
                                       (float) max_val);
}
int32_t
sine_custom_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) sine_custom_io((float) step,
                                    (float) max_steps,
                                    (float) max_val);
}

/* Linear */
int32_t
linear_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) linear_io((float) step,
                               (float) max_steps,
                               (float) max_val);
}

/* Exponential */
int32_t
exponential_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) exponential_in((float) step,
                                    (float) max_steps,
                                    (float) max_val);
}
int32_t
exponential_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) exponential_out((float) step,
                                     (float) max_steps,
                                     (float) max_val);
}
int32_t
exponential_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) exponential_io((float) step,
                                    (float) max_steps,
                                    (float) max_val);
}

/* Quadratic */
int32_t
quadratic_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quadratic_in((float) step,
                                  (float) max_steps,
                                  (float) max_val);
}
int32_t
quadratic_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quadratic_out((float) step,
                                   (float) max_steps,
                                   (float) max_val);
}
int32_t
quadratic_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quadratic_io((float) step,
                                  (float) max_steps,
                                  (float) max_val);
}

/* Cubic */
int32_t
cubic_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) cubic_in((float) step,
                              (float) max_steps,
                              (float) max_val);
}
int32_t
cubic_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) cubic_out((float) step,
                               (float) max_steps,
                               (float) max_val);
}
int32_t
cubic_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) cubic_io((float) step,
                              (float) max_steps,
                              (float) max_val);
}

/* Quartic */
int32_t
quartic_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quartic_in((float) step,
                                (float) max_steps,
                                (float) max_val);
}
int32_t
quartic_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quartic_out((float) step,
                                 (float) max_steps,
                                 (float) max_val);
}
int32_t
quartic_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quartic_io((float) step,
                                (float) max_steps,
                                (float) max_val);
}

/* Quintic */
int32_t
quintic_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quintic_in((float) step,
                                (float) max_steps,
                                (float) max_val);
}
int32_t
quintic_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quintic_out((float) step,
                                 (float) max_steps,
                                 (float) max_val);
}
int32_t
quintic_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) quintic_io((float) step,
                                (float) max_steps,
                                (float) max_val);
}

/* Circular */
int32_t
circular_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) circular_in((float) step,
                                 (float) max_steps,
                                 (float) max_val);
}
int32_t
circular_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) circular_out((float) step,
                                  (float) max_steps,
                                  (float) max_val);
}
int32_t
circular_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) circular_io((float) step,
                                 (float) max_steps,
                                 (float) max_val);
}

/* Sine */
int32_t
sine_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) sine_in((float) step,
                             (float) max_steps,
                             (float) max_val);
}
int32_t
sine_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) sine_out((float) step,
                              (float) max_steps,
                              (float) max_val);
}
int32_t
sine_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) sine_io((float) step,
                             (float) max_steps,
                             (float) max_val);
}

/* Bounce */
int32_t
bounce_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) bounce_in((float) step,
                               (float) max_steps,
                               (float) max_val);
}
int32_t
bounce_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) bounce_out((float) step,
                                (float) max_steps,
                                (float) max_val);
}
int32_t
bounce_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) bounce_io((float) step,
                               (float) max_steps,
                               (float) max_val);
}

/* Back */
int32_t
back_int_in(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) back_in((float) step,
                             (float) max_steps,
                             (float) max_val);
}
int32_t
back_int_out(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) back_out((float) step,
                              (float) max_steps,
                              (float) max_val);
}
int32_t
back_int_io(int32_t step, int32_t max_steps, int32_t max_val)
{
    return (int32_t) back_io((float) step,
                             (float) max_steps,
                             (float) max_val);
}