#include "rive/animation/elastic_ease.hpp"
#include "rive/math/math_types.hpp"
#include "math.h"

using namespace rive;

ElasticEase::ElasticEase(float amplitude, float period)
    : m_amplitude(amplitude)
    , m_period(period)
    , m_s(amplitude < 1.0f
              ? period / 4.0f
              : period / (2.0f * math::PI) * asinf(1.0f / amplitude))
{}

float ElasticEase::computeActualAmplitude(float time) const
{
  if (m_amplitude < 1.0f)
  {
    /// We use this when the amplitude is less than 1.0 (amplitude is
    /// described as factor of change in value). We also precompute s which
    /// is the effective starting period we use to align the decaying sin
    /// with our keyframe.
    float t = abs(m_s);
    float absTime = abs(time);
    if (absTime < t)
    {
      float l = absTime / t;
      return (m_amplitude * l) + (1.0f - l);
    }
  }

  return m_amplitude;
}

float ElasticEase::easeOut(float factor) const
{
  float time = factor;
  float actualAmplitude = computeActualAmplitude(time);

  return (actualAmplitude * pow(2.0f, 10.0f * -time) *
          sinf((time - m_s) * (2.0f * math::PI) / m_period)) +
         1.0f;
}

float ElasticEase::easeIn(float factor) const
{
  float time = factor - 1.0f;

  float actualAmplitude = computeActualAmplitude(time);

  return -(
      actualAmplitude * pow(2.0f, 10.0f * time) *
      sinf((-time - m_s) * (2.0f * math::PI) / m_period));
}

float ElasticEase::easeInOut(float factor) const
{
  float time = factor * 2.0f - 1.0f;
  float actualAmplitude = computeActualAmplitude(time);
  if (time < 0.0f)
  {
    return -0.5f * actualAmplitude * pow(2.0f, 10.0f * time) *
           sinf((-time - m_s) * (2.0f * math::PI) / m_period);
  }
  else
  {
    return 0.5f * (actualAmplitude * pow(2.0f, 10.0f * -time) *
                   sinf((time - m_s) * (2.0f * math::PI) / m_period)) +
           1.0f;
  }
}