//
// Copyright 2014 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
//

part of charted.core.interpolators;

const String EASE_TYPE_LINEAR = 'linear';
const String EASE_TYPE_POLY = 'poly';
const String EASE_TYPE_QUAD = 'quad';
const String EASE_TYPE_CUBIC = 'cubic';
const String EASE_TYPE_SIN = 'sin';
const String EASE_TYPE_EXP = 'exp';
const String EASE_TYPE_CIRCLE = 'circle';
const String EASE_TYPE_ELASTIC = 'elastic';
const String EASE_TYPE_BACK = 'back';
const String EASE_TYPE_BOUNCE = 'bounce';

const String EASE_MODE_IN = 'in';
const String EASE_MODE_OUT = 'out';
const String EASE_MODE_IN_OUT = 'in-out';
const String EASE_MODE_OUT_IN = 'out-in';

/// [EasingFunction] manipulates progression of an animation.  The returned
/// value is passed to an [Interpolator] to generate intermediate state.
typedef num EasingFunction(num t);

/// Alters behavior of the [EasingFunction].  Takes [fn] and returns an
/// altered [EasingFunction].
typedef EasingFunction EasingModeFunction(EasingFunction fn);

/// Clamps transition progress to stay between 0.0 and 1.0
EasingFunction clampEasingFn(EasingFunction f) =>
    (t) => t <= 0 ? 0 : t >= 1 ? 1 : f(t);

//
// Implementation of easing modes.
//

EasingFunction reverseEasingFn(EasingFunction f) => (t) => 1 - f(1 - t);

EasingFunction reflectEasingFn(EasingFunction f) =>
    (t) => .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));

EasingFunction reflectReverseEasingFn(EasingFunction f) =>
    reflectEasingFn(reverseEasingFn(f));

//
// Implementation of easing function generators.
//

EasingFunction easePoly([num e = 1]) => (t) => math.pow(t, e);

EasingFunction easeElastic([num a = 1, num p = 0.45]) {
  num s = p / 2 * math.pi * math.asin(1 / a);
  return (t) =>
      1 + a * math.pow(2, -10 * t) * math.sin((t - s) * 2 * math.pi / p);
}

EasingFunction easeBack([num s = 1.70158]) =>
    (num t) => t * t * ((s + 1) * t - s);

EasingFunction easeQuad() => (num t) => t * t;

EasingFunction easeCubic() => (num t) => t * t * t;

EasingFunction easeCubicInOut() => (num t) {
      if (t <= 0) return 0;
      if (t >= 1) return 1;
      var t2 = t * t, t3 = t2 * t;
      return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
    };

EasingFunction easeSin() => (num t) => 1 - math.cos(t * math.pi / 2);

EasingFunction easeExp() => (num t) => math.pow(2, 10 * (t - 1));

EasingFunction easeCircle() => (num t) => 1 - math.sqrt(1 - t * t);

EasingFunction easeBounce() => (num t) => t < 1 / 2.75
    ? 7.5625 * t * t
    : t < 2 / 2.75
        ? 7.5625 * (t -= 1.5 / 2.75) * t + .75
        : t < 2.5 / 2.75
            ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375
            : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;