using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public enum EASING_METHOD
{
  EASE_IN_SINE,
  EASE_OUT_SINE,
  EASE_OUT_BOUNCE,
  EASE_IN_BOUNCE,
  EASE_INOUT_BOUNCE,
  EASE_OUT_CIRCLE,
  EASE_OUT_BACK,
  LINEAR
}

public static class EasingHelper
{

  public static float EaseHelp(float value, EASING_METHOD method)
  {
    switch (method)
    {
      case EASING_METHOD.EASE_IN_SINE:
        {
          return EaseInSine(value);
        }

      case EASING_METHOD.EASE_OUT_SINE:
        {
          return EaseOutSine(value);
        }

      case EASING_METHOD.EASE_OUT_BOUNCE:
        {
          return EaseOutBounce(value);
        }

      case EASING_METHOD.EASE_IN_BOUNCE:
        {
          return EaseInBounce(value);
        }

      case EASING_METHOD.EASE_INOUT_BOUNCE:
        {
          return EaseInOutBounce(value);
        }

      case EASING_METHOD.LINEAR:
        {
          return value;
        }
      case EASING_METHOD.EASE_OUT_CIRCLE:
        {
          return EaseOutCircle(value);
        }
      case EASING_METHOD.EASE_OUT_BACK:
        {
          return EaseOutBack(value);
        }

      default:
        return 0.0f;
    }
  }

  private static float EaseInSine(float value)
  {

    return (float)(1.0f - Math.Cos((value * Math.PI / 2.0f)));

  }

  private static float EaseOutSine(float value)
  {
    return (float)(Math.Sin(value * Math.PI / 2.0f));

  }


  private static float EaseOutBounce(float value)
  {
    const float n1 = 7.5625f;
    const float d1 = 2.75f;
    if (value < 1.0f / d1)
    {
      return n1 * value * value;
    }
    else if (value < 2.0f / d1)
    {
      return n1 * (value -= 2.25f / d1) * value + 0.9375f;
    }
    else
    {
      return n1 * (value -= 2.625f / d1) * value + 0.984375f;

    }
  }

  private static float EaseInBounce(float value)
  {
    return 1 - EaseOutBounce(1 - value);
  }


  private static float EaseInOutBounce(float value)
  {
    return (value < 0.5f)
        ? (1.0f - EaseOutBounce(1.0f - 2.0f * value)) / 2.0f
        : (1.0f + EaseOutBounce(2.0f * value - 1.0f)) / 2.0f;
  }


  private static float EaseOutCircle(float value)
  {
    return (float)Math.Sqrt(1.0f - (float)Math.Pow(value - 1.0f, 2.0f));
  }

  private static float EaseOutBack(float value)
  {
    const float c1 = 1.70158f;
    const float c3 = c1 + 1.0f;
    return 1.0f + c3 * (float)Math.Pow(value - 1.0f, 3.0f) + c1 * (float)Math.Pow(value - 1.0f, 2.0f);
  }

}