//
// Copyright (c) 2008 Paul Duncan (paul@pablotron.org)
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

/**
 * Easer: namespace for Easier class and methods.
 * @namespace
 */
Easing = (function () {
  // return namespace
  var E = {};

  // import math functions to speed up ease callbacks
  var abs     = Math.abs,
      asin    = Math.asin,
      cos     = Math.cos, 
      pow     = Math.pow,
      sin     = Math.sin, 
      sqrt    = Math.sqrt,
      PI      = Math.PI,
      HALF_PI = Math.PI / 2;

  E = {
    /**
     * Version of Easing library.
     * @static
     */
    VERSION: '0.1.0',

    /**
     * Default options for Easer.
     * @static
     */
    DEFAULTS: {
      type: 'linear',
      side: 'none'
    },

    /**
     * Hash of valid types and sides.
     * @static
     */
    VALID: {
      type: { 
        linear:     true, 
        bounce:     true,
        circular:   true,
        cubic:      true,
        elastic:    true,
        exp:        true,
        quadratic:  true,
        quartic:    true,
        quintic:    true,
        sine:       true 
      },

      side: { 
        none: true, 
        'in': true, 
        out:  true, 
        both: true 
      }
    } 
  };

  /**
   * Easing.Easer: Easing class.
   * @class Easing.Easer.
   * @constructor
   * 
   * @param {Hash}  o   Hash of options.  Valid keys are "type" and "side".
   * 
   * Example:
   * 
   *   // create a new quadratic easer
   *   e = new Easing.Easer({
   *     type: 'quadratic',
   *     side: 'both'
   *   });
   * 
   */
  E.Easer = function(o) {
    var key;

    // set defaults
    for (key in E.DEFAULTS)
      this[key] = E.DEFAULTS[key];

    this.reset(o);
  };

  /**
   * Reset an Easer with new values.
   * 
   * @param {Hash}  o   Hash of options.  Valid keys are "type" and "side".
   * 
   * Example:
   * 
   *   // reset easer to quintic easing
   *   e = e.reset({
   *     type: 'quintic',
   *     side: 'end'
   *   });
   * 
   */
  E.Easer.prototype.reset = function(o) {
    var key, name, type, side, err;
    for (key in o)
      this[key] = o[key];

    // get/check type
    type = (this.side != 'none') ? this.type : 'linear';
    if (!E.VALID.type[type])
      throw new Error("unknown type: " + this.type);

    // get/check side
    side = (type != 'linear') ? this.side : 'none';
    if (!E.VALID.side[side])
      throw new Error("unknown side: " + this.side);

    // build callback name
    name = ['ease', side].join('_');
    this.fn = E[type] && E[type][name];

    // make sure callback exists
    if (!this.fn) {
      err = "type = " + this.type + ", side = " + this.side;
      throw new Error("unknown ease: " + err);
    }
  };

  /**
   * Get the ease for a particular time offset.
   * 
   * @param {Number}    time_now     Current time offset (in the range of 0-time_dur).
   * @param {Number}    begin_val    Beginning value.
   * @param {Number}    change_val   End offset value.
   * @param {Number}    time_dur     Duration of time.
   * 
   * @returns Eased value.
   * @type Number
   * 
   * Example:
   * 
   *   // calculate ease at 50 time units for transition from 10 to 300
   *   var x = e.ease(50, 10, 290, 100);
   * 
   */
  E.Easer.prototype.ease = function(time_now, begin_val, change_val, time_dur) {
    return this.fn.apply(this, arguments);
  };

  /**
   * linear easing
   * @namespace
   */
  E.linear = {};

  E.linear.ease_none = function(t, b, c, d) {
    return c * t / d + b;
  };

  /**
   * back easing
   * @namespace
   */
  E.back = {};

  var BACK_DEFAULT_S = 1.70158;

  E.back.ease_in = function(t, b, c, d, s) {
    if (s == undefined) s = BACK_DEFAULT_S;
    return c*(t/=d)*t*((s+1)*t - s) + b;
  };

  E.back.ease_out = function(t, b, c, d, s) {
		if (s == undefined) s = BACK_DEFAULT_S;
		return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
	};

  E.back.ease_both = function(t, b, c, d, s) {
		if (s == undefined) s = BACK_DEFAULT_S; 
		if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
		return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
	};

  /**
   * bounce easing
   * @namespace
   */
  E.bounce = {};

  var bounce_ratios = [
    1 / 2.75,
    2 / 2.75,
    2.5 / 2.75
  ];

  var bounce_factors = [
    null,
    1.5 / 2.75,
    2.25 / 2.75,
    2.625 / 2.75
  ];

  E.bounce.ease_out = function(t, b, c, d) {
    if ((t/=d) < (bounce_ratios[0])) {
      return c*(7.5625*t*t) + b;
    } else if (t < (bounce_ratios[1])) {
      return c*(7.5625*(t-=(bounce_factors[1]))*t + .75) + b;
    } else if (t < (bounce_ratios[2])) {
      return c*(7.5625*(t-=(bounce_factors[2]))*t + .9375) + b;
    } else {
      return c*(7.5625*(t-=(bounce_factors[3]))*t + .984375) + b;
    }
  };

  E.bounce.ease_in = function(t, b, c, d) {
    return c - E.bounce.ease_out(d-t, 0, c, d) + b;
  };

  E.bounce.ease_both = function(t, b, c, d) {
    if (t < d/2) return E.bounce.ease_in(t*2, 0, c, d) * .5 + b;
    else return E.bounce.ease_out(t*2-d, 0, c, d) * .5 + c*.5 + b;
  };

  /**
   * circular easing
   * @namespace
   */
  E.circular = {};

  E.circular.ease_in = function(t, b, c, d) {
    return -c * (sqrt(1 - (t/=d)*t) - 1) + b;
  };

  E.circular.ease_out = function(t, b, c, d) {
    return c * sqrt(1 - (t=t/d-1)*t) + b;
  };

  E.circular.ease_both = function(t, b, c, d) {
    if ((t/=d/2) < 1) return -c/2 * (sqrt(1 - t*t) - 1) + b;
    return c/2 * (sqrt(1 - (t-=2)*t) + 1) + b;
  };

  /**
   * cubic easing
   * @namespace
   */
  E.cubic = {};

  E.cubic.ease_in = function(t, b, c, d) {
    return c*(t/=d)*t*t + b;
  };

  E.cubic.ease_out = function(t, b, c, d) {
    return c*((t=t/d-1)*t*t + 1) + b;
  };

  E.cubic.ease_both = function(t, b, c, d) {
    if ((t/=d/2) < 1) return c/2*t*t*t + b;
    return c/2*((t-=2)*t*t + 2) + b;
  };

  /**
   * elastic easing
   * @namespace
   */
  E.elastic = {};

  E.elastic.ease_in = function(t, b, c, d, a, p) {
    if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
    if (!a || a < abs(c)) { a=c; var s=p/4; }
    else var s = p/(2*PI) * asin(c/a);
    return -(a*pow(2,10*(t-=1)) * sin( (t*d-s)*(2*PI)/p )) + b;
  };

  E.elastic.ease_out = function(t, b, c, d, a, p) {
    if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
    if (!a || a < abs(c)) { a=c; var s=p/4; }
    else var s = p/(2*PI) * asin(c/a);
    return (a*pow(2,-10*t) * sin( (t*d-s)*(2*PI)/p ) + c + b);
  };

  E.elastic.ease_both = function(t, b, c, d, a, p) {
    if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
    if (!a || a < abs(c)) { a=c; var s=p/4; }
    else var s = p/(2*PI) * asin (c/a);
    if (t < 1) return -.5*(a*pow(2,10*(t-=1)) * sin( (t*d-s)*(2*PI)/p )) + b;
    return a*pow(2,-10*(t-=1)) * sin( (t*d-s)*(2*PI)/p )*.5 + c + b;
  };

  /**
   * exponential easing
   * @namespace
   */
  E.exp = {};

  E.exp.ease_in = function(t, b, c, d) {
    return (t==0) ? b : c * pow(2, 10 * (t/d - 1)) + b;
  };

  E.exp.ease_out = function(t, b, c, d) {
    return (t==d) ? b+c : c * (-pow(2, -10 * t/d) + 1) + b;
  };

  E.exp.ease_both = function(t, b, c, d) {
    if (t==0) return b;
    if (t==d) return b+c;
    if ((t/=d/2) < 1) return c/2 * pow(2, 10 * (t - 1)) + b;
    return c/2 * (-pow(2, -10 * --t) + 2) + b;
  };

  /**
   * quadratic easing
   */
  E.quadratic = {};

  E.quadratic.ease_in = function(t, b, c, d) {
    return c*(t/=d)*t + b;
  };

  E.quadratic.ease_out = function(t, b, c, d) {
    return -c *(t/=d)*(t-2) + b;
  };

  E.quadratic.ease_both = function(t, b, c, d) {
    if ((t/=d/2) < 1) return c/2*t*t + b;
    return -c/2 * ((--t)*(t-2) - 1) + b;
  };

  /**
   * quartic easing
   * @namespace
   */
  E.quartic = {};

  E.quartic.ease_in = function(t, b, c, d) {
    return c*(t/=d)*t*t*t + b;
  };

  E.quartic.ease_out = function(t, b, c, d) {
    return -c * ((t=t/d-1)*t*t*t - 1) + b;
  };

  E.quartic.ease_both = function(t, b, c, d) {
    if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
    return -c/2 * ((t-=2)*t*t*t - 2) + b;
  };

  /**
   * quintic easing
   * @namespace
   */
  E.quintic = {};

  E.quintic.ease_in = function(t, b, c, d) {
    return c*(t/=d)*t*t*t*t + b;
  };

  E.quintic.ease_out = function(t, b, c, d) {
    return c*((t=t/d-1)*t*t*t*t + 1) + b;
  };

  E.quintic.ease_both = function(t, b, c, d) {
    if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
    return c/2*((t-=2)*t*t*t*t + 2) + b;
  };

  /**
   * sinusoidal easing
   * @namespace
   */
  E.sine = {};

  E.sine.ease_in = function(t, b, c, d) {
    return -c * cos(t/d * (HALF_PI)) + c + b;
  };

  E.sine.ease_out = function(t, b, c, d) {
    return c * sin(t/d * (HALF_PI)) + b;
  };

  E.sine.ease_both = function(t, b, c, d) {
    return -c/2 * (cos(PI*t/d) - 1) + b;
  };

  // return scope
  return E;
})();