// smoothscroll v1.2.1
// licensed under the terms of the mit license.

// people involved
//  - balazs galambosi (maintainer)  
//  - patrick brunner  (original idea)
//  - michael herf     (pulse algorithm)
//  - justin force     (resurect)

// scroll variables (tweakable)
var framerate = 350; // [hz]
var animtime  = 800; // [px]
var stepsize  = 80; // [px]

// pulse (less tweakable)
// ratio of "tail" to "acceleration"
var pulsealgorithm = true;
var pulsescale     = 8;
var pulsenormalize = 1;

// acceleration
var acceleration   = true;
var acceldelta     = 10;  // 20
var accelmax       = 1;   // 1

// keyboard settings
var keyboardsupport = true;  // option
var disablekeyboard = false; // other reasons
var arrowscroll     = 50;    // [px]

// excluded pages
var exclude = "";
var disabled = false;

// other variables
var frame = false;
var direction = { x: 0, y: 0 };
var initdone  = false;
var fixedback = true;
var root = document.documentelement;
var activeelement;

var key = { left: 37, up: 38, right: 39, down: 40, spacebar: 32, pageup: 33, pagedown: 34, end: 35, home: 36 };

/**
 * sets up scrolls array, determines if frames are involved.
 */
function init() {

  if (!document.body) return;

  var body = document.body;
  var html = document.documentelement;
  var windowheight = window.innerheight;
  var scrollheight = body.scrollheight;

  // check compat mode for root element
  root = (document.compatmode.indexof('css') >= 0) ? html : body;
  activeelement = body;

  initdone = true;

  // checks if this script is running in a frame
  if (top != self) {
    frame = true;
  }

  /**
   * this fixes a bug where the areas left and right to
   * the content does not trigger the onmousewheel event
   * on some pages. e.g.: html, body { height: 100% }
   */
  else if (scrollheight > windowheight &&
           (body.offsetheight <= windowheight ||
            html.offsetheight <= windowheight)) {

    // domchange (throttle): fix height
    var pending = false;
    var refresh = function() {
      if (!pending && html.scrollheight != document.height) {
        pending = true; // add a new pending action
        settimeout(function(){
          html.style.height = document.height + 'px';
          pending = false;
        }, 500); // act rarely to stay fast
      }
    };
    html.style.height = '';
    settimeout(refresh, 10);
    addevent("domnodeinserted", refresh);
    addevent("domnoderemoved",  refresh);

    // clearfix
    if (root.offsetheight <= windowheight) {
      var underlay = document.createelement("div");
      underlay.style.clear = "both";
      body.appendchild(underlay);
    }
  }

  // gmail performance fix
  if (document.url.indexof("mail.google.com") > -1) {
    var s = document.createelement("style");
    s.innerhtml = ".iu { visibility: hidden }";
    (document.getelementsbytagname("head")[0] || html).appendchild(s);
  }
  // disable fixed background
  if (!fixedback && !disabled) {
    body.style.backgroundattachment = "scroll";
    html.style.backgroundattachment = "scroll";
  }
}


/************************************************
 * scrolling
 ************************************************/

var que = [];
var pending = false;
var lastscroll = +new date;

/**
 * pushes scroll actions to the scrolling queue.
 */
function scrollarray(elem, left, top, delay) {

  delay || (delay = 1000);
  directioncheck(left, top);

  if (acceleration) {
    var now = +new date;
    var elapsed = now - lastscroll;
    if (elapsed < acceldelta) {
      var factor = (1 + (30 / elapsed)) / 2;
      if (factor > 1) {
        factor = math.min(factor, accelmax);
        left *= factor;
        top  *= factor;
      }
    }
    lastscroll = +new date;
  }

  // push a scroll command
  que.push({
    x: left,
    y: top,
    lastx: (left < 0) ? 0.99 : -0.99,
    lasty: (top  < 0) ? 0.99 : -0.99,
    start: +new date
  });

  // don't act if there's a pending queue
  if (pending) {
    return;
  }

  var scrollwindow = (elem === document.body);

  var step = function() {

    var now = +new date;
    var scrollx = 0;
    var scrolly = 0;

    for (var i = 0; i < que.length; i++) {

      var item = que[i];
      var elapsed  = now - item.start;
      var finished = (elapsed >= animtime);

      // scroll position: [0, 1]
      var position = (finished) ? 1 : elapsed / animtime;

      // easing [optional]
      if (pulsealgorithm) {
        position = pulse(position);
      }

      // only need the difference
      var x = (item.x * position - item.lastx) >> 0;
      var y = (item.y * position - item.lasty) >> 0;

      // add this to the total scrolling
      scrollx += x;
      scrolly += y;

      // update last values
      item.lastx += x;
      item.lasty += y;

      // delete and step back if it's over
      if (finished) {
        que.splice(i, 1); i--;
      }
    }

    // scroll left and top
    if (scrollwindow) {
      window.scrollby(scrollx, scrolly)
    }
    else {
      if (scrollx) elem.scrollleft += scrollx;
      if (scrolly) elem.scrolltop  += scrolly;
    }

    // clean up if there's nothing left to do
    if (!left && !top) {
      que = [];
    }

    if (que.length) {
      requestframe(step, elem, (delay / framerate + 1));
    } else {
      pending = false;
    }
  }

  // start a new queue of actions
  requestframe(step, elem, 0);
  pending = true;
}


/***********************************************
 * events
 ***********************************************/

/**
 * mouse wheel handler.
 * @param {object} event
 */
function wheel(event) {

  if (!initdone) {
    init();
  }

  var target = event.target;
  var overflowing = overflowingancestor(target);

  // use default if there's no overflowing
  // element or default action is prevented
  if (!overflowing || event.defaultprevented ||
      isnodename(activeelement, "embed") ||
        (isnodename(target, "embed") && /\.pdf/i.test(target.src))) {
    return true;
  }

  var deltax = event.wheeldeltax || 0;
  var deltay = event.wheeldeltay || 0;

  // use wheeldelta if deltax/y is not available
  if (!deltax && !deltay) {
    deltay = event.wheeldelta || 0;
  }

  // scale by step size
  // delta is 120 most of the time
  // synaptics seems to send 1 sometimes
  if (math.abs(deltax) > 1.2) {
    deltax *= stepsize / 120;
  }
  if (math.abs(deltay) > 1.2) {
    deltay *= stepsize / 120;
  }

  scrollarray(overflowing, -deltax, -deltay);
  event.preventdefault();
}

/**
 * keydown event handler.
 * @param {object} event
 */
function keydown(event) {

  var target   = event.target;
  var modifier = event.ctrlkey || event.altkey || event.metakey ||
    (event.shiftkey && event.keycode !== key.spacebar);

  // do nothing if user is editing text
  // or using a modifier key (except shift)
  // or in a dropdown
  if ( /input|textarea|select|embed/i.test(target.nodename) ||
      target.iscontenteditable ||
        event.defaultprevented   ||
          modifier ) {
    return true;
  }
  // spacebar should trigger button press
  if (isnodename(target, "button") &&
      event.keycode === key.spacebar) {
    return true;
  }

  var shift, x = 0, y = 0;
  var elem = overflowingancestor(activeelement);
  var clientheight = elem.clientheight;

  if (elem == document.body) {
    clientheight = window.innerheight;
  }

  switch (event.keycode) {
    case key.up:
      y = -arrowscroll;
    break;
    case key.down:
      y = arrowscroll;
    break;
    case key.spacebar: // (+ shift)
      shift = event.shiftkey ? 1 : -1;
    y = -shift * clientheight * 0.9;
    break;
    case key.pageup:
      y = -clientheight * 0.9;
    break;
    case key.pagedown:
      y = clientheight * 0.9;
    break;
    case key.home:
      y = -elem.scrolltop;
    break;
    case key.end:
      var damt = elem.scrollheight - elem.scrolltop - clientheight;
    y = (damt > 0) ? damt+10 : 0;
    break;
    case key.left:
      x = -arrowscroll;
    break;
    case key.right:
      x = arrowscroll;
    break;
    default:
      return true; // a key we don't care about
  }

  scrollarray(elem, x, y);
  event.preventdefault();
}

/**
 * mousedown event only for updating activeelement
 */
function mousedown(event) {
  activeelement = event.target;
}


/***********************************************
 * overflow
 ***********************************************/

var cache = {}; // cleared out every once in while
setinterval(function(){ cache = {}; }, 10 * 1000);

var uniqueid = (function() {
  var i = 0;
  return function (el) {
    return el.uniqueid || (el.uniqueid = i++);
  };
})();

function setcache(elems, overflowing) {
  for (var i = elems.length; i--;)
  cache[uniqueid(elems[i])] = overflowing;
  return overflowing;
}

function overflowingancestor(el) {
  var elems = [];
  var rootscrollheight = root.scrollheight;
  do {
    var cached = cache[uniqueid(el)];
    if (cached) {
      return setcache(elems, cached);
    }
    elems.push(el);
    if (rootscrollheight === el.scrollheight) {
      if (!frame || root.clientheight + 10 < rootscrollheight) {
        return setcache(elems, document.body); // scrolling root in webkit
      }
    } else if (el.clientheight + 10 < el.scrollheight) {
      overflow = getcomputedstyle(el, "").getpropertyvalue("overflow-y");
      if (overflow === "scroll" || overflow === "auto") {
        return setcache(elems, el);
      }
    }
  } while (el = el.parentnode);
}


/***********************************************
 * helpers
 ***********************************************/

function addevent(type, fn, bubble) {
  window.addeventlistener(type, fn, (bubble||false));
}

function removeevent(type, fn, bubble) {
  window.removeeventlistener(type, fn, (bubble||false));
}

function isnodename(el, tag) {
  return (el.nodename||"").tolowercase() === tag.tolowercase();
}

function directioncheck(x, y) {
  x = (x > 0) ? 1 : -1;
  y = (y > 0) ? 1 : -1;
  if (direction.x !== x || direction.y !== y) {
    direction.x = x;
    direction.y = y;
    que = [];
    lastscroll = 0;
  }
}

var requestframe = (function(){
  return  window.requestanimationframe       ||
    window.webkitrequestanimationframe ||
    function(callback, element, delay){
    window.settimeout(callback, delay || (1000/60));
  };
})();

/***********************************************
 * pulse
 ***********************************************/

/**
 * viscous fluid with a pulse for part and decay for the rest.
 * - applies a fixed force over an interval (a damped acceleration), and
 * - lets the exponential bleed away the velocity over a longer interval
 * - michael herf, http://stereopsis.com/stopping/
 */
function pulse_(x) {
  var val, start, expx;
  // test
  x = x * pulsescale/2;
  if (x < 1) { // acceleartion
    val = x - (1 - math.exp(-x));
  } else {     // tail
    // the previous animation ended here:
    start = math.exp(-1);
    // simple viscous drag
    x -= 1;
    expx = 1 - math.exp(-x);
    val = start + (expx * (1 - start));
  }
  return val * pulsenormalize;
}

function pulse(x) {
  if (x >= 1) return 1;
  if (x <= 0) return 0;

  if (pulsenormalize == 1) {
    pulsenormalize /= pulse_(1);
  }
  return pulse_(x);
}

addevent("mousedown", mousedown);
addevent("mousewheel", wheel);
addevent("load", init);