/*!
 * parallax.js v1.5.0 (http://pixelcog.github.io/parallax.js/)
 * @copyright 2016 PixelCog, Inc.
 * @license MIT (https://github.com/pixelcog/parallax.js/blob/master/LICENSE)
 */

;(function ( $, window, document, undefined ) {

	// Polyfill for requestAnimationFrame
	// via: https://gist.github.com/paulirish/1579671
  
	(function() {
	  var lastTime = 0;
	  var vendors = ['ms', 'moz', 'webkit', 'o'];
	  for(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
		window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
		window.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame'] || window[vendors[x]+'CancelRequestAnimationFrame'];
	  }
  
	  if (!window.requestAnimationFrame)
		window.requestAnimationFrame = function(callback) {
		  var currTime = new Date().getTime();
		  var timeToCall = Math.max(0, 16 - (currTime - lastTime));
		  var id = window.setTimeout(function() { callback(currTime + timeToCall); },
			timeToCall);
		  lastTime = currTime + timeToCall;
		  return id;
		};
  
	  if (!window.cancelAnimationFrame)
		window.cancelAnimationFrame = function(id) {
		  clearTimeout(id);
		};
	}());
  
	// Detect whether passive event listener is supported
  
	var supportsPassive = false;
	try {
	  var opts = Object.defineProperty({}, 'passive', {
		get: function() {
		  supportsPassive = true;
		}
	  });
	  window.addEventListener('test', null, opts);
	} catch (e) {}
  
	function passiveOn(el, name, listener) {
	  if (supportsPassive) {
		el.addEventListener(name, listener, {
		  passive: true
		});
	  } else {
		el.addEventListener(name, listener);
	  }
	}
  
	function passiveOff(el, name, listener) {
	  el.removeEventListenr(name, listener);
	}
  
	// Parallax Constructor
  
	function Parallax(element, options) {
	  var self = this;
  
	  if (typeof options == 'object') {
		delete options.refresh;
		delete options.render;
		$.extend(this, options);
	  }
  
	  this.$element = $(element);
  
	  if (!this.imageSrc && this.$element.is('img')) {
		this.imageSrc = this.$element.attr('src');
	  }
  
	  var positions = (this.position + '').toLowerCase().match(/\S+/g) || [];
  
	  if (positions.length < 1) {
		positions.push('center');
	  }
	  if (positions.length == 1) {
		positions.push(positions[0]);
	  }
  
	  if (positions[0] == 'top' || positions[0] == 'bottom' || positions[1] == 'left' || positions[1] == 'right') {
		positions = [positions[1], positions[0]];
	  }
  
	  if (this.positionX !== undefined) positions[0] = this.positionX.toLowerCase();
	  if (this.positionY !== undefined) positions[1] = this.positionY.toLowerCase();
  
	  self.positionX = positions[0];
	  self.positionY = positions[1];
  
	  if (this.positionX != 'left' && this.positionX != 'right') {
		if (isNaN(parseInt(this.positionX))) {
		  this.positionX = 'center';
		} else {
		  this.positionX = parseInt(this.positionX);
		}
	  }
  
	  if (this.positionY != 'top' && this.positionY != 'bottom') {
		if (isNaN(parseInt(this.positionY))) {
		  this.positionY = 'center';
		} else {
		  this.positionY = parseInt(this.positionY);
		}
	  }
  
	  this.position =
		this.positionX + (isNaN(this.positionX)? '' : 'px') + ' ' +
		this.positionY + (isNaN(this.positionY)? '' : 'px');
  
	  if (navigator.userAgent.match(/(iPod|iPhone|iPad)/)) {
		if (this.iosDisabled) {
		  if (this.imageSrc && this.iosFix && !this.$element.is('img')) {
			this.$element.css({
			  backgroundImage: 'url("' + this.imageSrc + '")',
			  backgroundSize: 'cover',
			  backgroundPosition: this.position
			});
		  }
		  return this;
		}
	  }
  
	  if (navigator.userAgent.match(/(Android)/)) {
		if (this.androidDisabled) {
		  if (this.imageSrc && this.androidFix && !this.$element.is('img')) {
			this.$element.css({
			  backgroundImage: 'url("' + this.imageSrc + '")',
			  backgroundSize: 'cover',
			  backgroundPosition: this.position
			});
		  }
		  return this;
		}
	  }
  
	  this.$mirror = $('<div />').prependTo(this.mirrorContainer);
  
	  var slider = this.$element.find('>.parallax-slider');
	  var sliderExisted = false;
  
	  if (slider.length == 0)
		this.$slider = $('<img />').prependTo(this.$mirror);
	  else {
		this.$slider = slider.prependTo(this.$mirror)
		sliderExisted = true;
	  }
  
	  this.$mirror.addClass('parallax-mirror').css({
		visibility: 'hidden',
		zIndex: this.zIndex,
		position: 'fixed',
		top: 0,
		left: 0,
		overflow: 'hidden'
	  });
  
	  this.$slider.addClass('parallax-slider').one('load', function() {
		if (!self.naturalHeight || !self.naturalWidth) {
		  self.naturalHeight = this.naturalHeight || this.height || 1;
		  self.naturalWidth  = this.naturalWidth  || this.width  || 1;
		}
		self.aspectRatio = self.naturalWidth / self.naturalHeight;
  
		Parallax.isSetup || Parallax.setup();
		Parallax.sliders.push(self);
		Parallax.isFresh = false;
		Parallax.requestRender();
	  });
  
	  if (!sliderExisted)
		this.$slider[0].src = this.imageSrc;
  
	  if (this.naturalHeight && this.naturalWidth || this.$slider[0].complete || slider.length > 0) {
		this.$slider.trigger('load');
	  }
  
	}
  
  
	// Parallax Instance Methods
  
	$.extend(Parallax.prototype, {
	  speed:    0.2,
	  bleed:    0,
	  zIndex:   -100,
	  iosFix:   true,
	  iosDisabled: true,
	  androidFix: true,
	  androidDisabled: true,
	  position: 'center',
	  overScrollFix: false,
	  mirrorContainer: 'body',
  
	  refresh: function() {
		this.boxWidth        = this.$element.outerWidth();
		this.boxHeight       = this.$element.outerHeight() + this.bleed * 2;
		this.boxOffsetTop    = this.$element.offset().top - this.bleed;
		this.boxOffsetLeft   = this.$element.offset().left;
		this.boxOffsetBottom = this.boxOffsetTop + this.boxHeight;
  
		var winHeight = Parallax.winHeight;
		var docHeight = Parallax.docHeight;
		var maxOffset = Math.min(this.boxOffsetTop, docHeight - winHeight);
		var minOffset = Math.max(this.boxOffsetTop + this.boxHeight - winHeight, 0);
		var imageHeightMin = this.boxHeight + (maxOffset - minOffset) * (1 - this.speed) | 0;
		var imageOffsetMin = (this.boxOffsetTop - maxOffset) * (1 - this.speed) | 0;
		var margin;
  
		if (imageHeightMin * this.aspectRatio >= this.boxWidth) {
		  this.imageWidth    = imageHeightMin * this.aspectRatio | 0;
		  this.imageHeight   = imageHeightMin;
		  this.offsetBaseTop = imageOffsetMin;
  
		  margin = this.imageWidth - this.boxWidth;
  
		  if (this.positionX == 'left') {
			this.offsetLeft = 0;
		  } else if (this.positionX == 'right') {
			this.offsetLeft = - margin;
		  } else if (!isNaN(this.positionX)) {
			this.offsetLeft = Math.max(this.positionX, - margin);
		  } else {
			this.offsetLeft = - margin / 2 | 0;
		  }
		} else {
		  this.imageWidth    = this.boxWidth;
		  this.imageHeight   = this.boxWidth / this.aspectRatio | 0;
		  this.offsetLeft    = 0;
  
		  margin = this.imageHeight - imageHeightMin;
  
		  if (this.positionY == 'top') {
			this.offsetBaseTop = imageOffsetMin;
		  } else if (this.positionY == 'bottom') {
			this.offsetBaseTop = imageOffsetMin - margin;
		  } else if (!isNaN(this.positionY)) {
			this.offsetBaseTop = imageOffsetMin + Math.max(this.positionY, - margin);
		  } else {
			this.offsetBaseTop = imageOffsetMin - margin / 2 | 0;
		  }
		}
	  },
  
	  render: function() {
		var scrollTop    = Parallax.scrollTop;
		var scrollLeft   = Parallax.scrollLeft;
		var overScroll   = this.overScrollFix ? Parallax.overScroll : 0;
		var scrollBottom = scrollTop + Parallax.winHeight;
  
		if (this.boxOffsetBottom > scrollTop && this.boxOffsetTop <= scrollBottom) {
		  this.visibility = 'visible';
		  this.mirrorTop = this.boxOffsetTop  - scrollTop;
		  this.mirrorLeft = this.boxOffsetLeft - scrollLeft;
		  this.offsetTop = this.offsetBaseTop - this.mirrorTop * (1 - this.speed);
		} else {
		  this.visibility = 'hidden';
		}
  
		this.$mirror.css({
		  transform: 'translate3d('+this.mirrorLeft+'px, '+(this.mirrorTop - overScroll)+'px, 0px)',
		  visibility: this.visibility,
		  height: this.boxHeight,
		  width: this.boxWidth
		});
  
		this.$slider.css({
		  transform: 'translate3d('+this.offsetLeft+'px, '+this.offsetTop+'px, 0px)',
		  position: 'absolute',
		  height: this.imageHeight,
		  width: this.imageWidth,
		  maxWidth: 'none'
		});
	  }
	});
  
  
	// Parallax Static Methods
  
	$.extend(Parallax, {
	  scrollTop:    0,
	  scrollLeft:   0,
	  winHeight:    0,
	  winWidth:     0,
	  docHeight:    1 << 30,
	  docWidth:     1 << 30,
	  sliders:      [],
	  isReady:      false,
	  isFresh:      false,
	  isBusy:       false,
  
	  setup: function() {
		if (this.isReady) return;
  
		var self = this;
  
		var $doc = $(document), $win = $(window);
  
		var loadDimensions = function() {
		  Parallax.winHeight = $win.height();
		  Parallax.winWidth  = $win.width();
		  Parallax.docHeight = $doc.height();
		  Parallax.docWidth  = $doc.width();
		};
  
		var loadScrollPosition = function() {
		  var winScrollTop  = $win.scrollTop();
		  var scrollTopMax  = Parallax.docHeight - Parallax.winHeight;
		  var scrollLeftMax = Parallax.docWidth  - Parallax.winWidth;
		  Parallax.scrollTop  = Math.max(0, Math.min(scrollTopMax,  winScrollTop));
		  Parallax.scrollLeft = Math.max(0, Math.min(scrollLeftMax, $win.scrollLeft()));
		  Parallax.overScroll = Math.max(winScrollTop - scrollTopMax, Math.min(winScrollTop, 0));
		};
  
		var scrollListener = this.scrollListener = function() {
		  loadScrollPosition();
		  Parallax.requestRender();
		};
  
		$win.on('resize.px.parallax load.px.parallax', function() {
			loadDimensions();
			self.refresh();
			Parallax.isFresh = false;
			Parallax.requestRender();
		  })
		  .on('scroll.px.parallax load.px.parallax', scrollListener);
  
		passiveOn(window, 'touchmove', scrollListener);
  
		loadDimensions();
		loadScrollPosition();
  
		this.isReady = true;
  
		var lastPosition = -1;
  
		function frameLoop() {
		  if (lastPosition == window.pageYOffset) {   // Avoid overcalculations
			window.requestAnimationFrame(frameLoop);
			return false;
		  } else lastPosition = window.pageYOffset;
  
		  self.render();
		  window.requestAnimationFrame(frameLoop);
		}
  
		frameLoop();
	  },
  
	  configure: function(options) {
		if (typeof options == 'object') {
		  delete options.refresh;
		  delete options.render;
		  $.extend(this.prototype, options);
		}
	  },
  
	  refresh: function() {
		$.each(this.sliders, function(){ this.refresh(); });
		this.isFresh = true;
	  },
  
	  render: function() {
		this.isFresh || this.refresh();
		$.each(this.sliders, function(){ this.render(); });
	  },
  
	  requestRender: function() {
		var self = this;
		self.render();
		self.isBusy = false;
	  },
	  destroy: function(el){
		var i,
			parallaxElement = $(el).data('px.parallax');
		if (!!parallaxElement.$mirror) {
		  parallaxElement.$mirror.remove();
		}
		for(i=0; i < this.sliders.length; i+=1){
		  if(this.sliders[i] == parallaxElement){
			this.sliders.splice(i, 1);
		  }
		}
		$(el).data('px.parallax', false);
		if(this.sliders.length === 0){
		  $(window).off('scroll.px.parallax resize.px.parallax load.px.parallax');
		  passiveOff(window, 'touchmove', this.scrollListener);
		  this.isReady = false;
		  Parallax.isSetup = false;
		}
	  }
	});
  
  
	// Parallax Plugin Definition
  
	function Plugin(option) {
	  return this.each(function () {
		var $this = $(this);
		var options = typeof option == 'object' && option;
  
		if (this == window || this == document || $this.is('body')) {
		  Parallax.configure(options);
		}
		else if (!$this.data('px.parallax')) {
		  options = $.extend({}, $this.data(), options);
		  $this.data('px.parallax', new Parallax(this, options));
		}
		else if (typeof option == 'object')
		{
		  $.extend($this.data('px.parallax'), options);
		}
		if (typeof option == 'string') {
		  if(option == 'destroy'){
			  Parallax.destroy(this);
		  }else{
			Parallax[option]();
		  }
		}
	  });
	}
  
	var old = $.fn.parallax;
  
	$.fn.parallax             = Plugin;
	$.fn.parallax.Constructor = Parallax;
  
  
	// Parallax No Conflict
	$.fn.parallax.noConflict = function () {
	  $.fn.parallax = old;
	  return this;
	};
 
	// Parallax Data-API
  
	$( function () {
	  $('[data-parallax="scroll"]').parallax();
	});
  
  }(jQuery, window, document));