Position.includeScrollOffsets = true;

var Engine = {
  detect: function() {
    var UA = navigator.userAgent;
    this.isKHTML = /Konqueror|Safari|KHTML/.test(UA);
    this.isGecko = (/Gecko/.test(UA) && !this.isKHTML);
    this.isOpera = /Opera/.test(UA);
    this.isMSIE  = (/MSIE/.test(UA) && !this.isOpera);
    this.isMSIE7 = this.isMSIE && !(/MSIE 6\./.test(UA) && !this.isOpera);
    this.isMSIE6 = this.isMSIE && !this.isMSIE7;
  }
}
Engine.detect();

if(Engine.isMSIE){
  try {
    document.execCommand("BackgroundImageCache", false, true);
  } catch(e) {}
}

Position.getPageSize = function() {
  var xScroll, yScroll;

  if (window.scrollMaxX) {  
    xScroll = window.innerWidth  + window.scrollMaxX;
    yScroll = window.innerHeight + window.scrollMaxY;
  } else {
    xScroll = document.body.scrollWidth;
    yScroll = document.body.scrollHeight;
  } 
  
  var windowWidth, windowHeight;
  if (self.innerHeight) { // all except Explorer
    windowWidth = self.innerWidth;
    windowHeight = self.innerHeight;
  } else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
    windowWidth = document.documentElement.clientWidth;
    windowHeight = document.documentElement.clientHeight;
  } else if (document.body) { // other Explorers
    windowWidth = document.body.clientWidth;
    windowHeight = document.body.clientHeight;
  }
  // for small pages with total height less then height of the viewport
  pageHeight = Math.max(windowHeight, yScroll);

  // for small pages with total width less then width of the viewport
  pageWidth = Math.max(windowWidth, xScroll);

  return { page: { width: pageWidth, height: pageHeight }, window: { width: windowWidth, height: windowHeight } };
}

Position.scrollX = function(){
  return (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0);
}

var Loader = {
  _assets: $H({}),
  _checkInterval: null,
  _options: {},
  _update: function() {
    var allLoaded = true;
    Loader._assets.each(function(a){
      if(!a[1].complete && a[1].image.complete) {
        a[1].complete = true;
        a[1].completed_at = new Date().getTime();;
        if(a[1].options.onComplete) a[1].options.onComplete(a[0]);
      }
      if(!a[1].complete && !a[1].image.complete) allLoaded = false;
    });
    if(allLoaded) {
      clearInterval(Loader._checkInterval);
      Loader._checkInterval = null;
      if(Loader._options && Loader._options.onComplete) Loader._options.onComplete();
      Loader._options = null;
    }
  },
  initialize: function() {
    var options = arguments[0] || {};
    Loader._options = options;
  },
  cacheOrLoad: function(url) {
    var options = arguments[1] || {};
    if(this.isLoaded(url)) {
      if(options.onComplete) options.onComplete();
    } else {
      this.load(url, options);
    }
  },
  load: function(url) {
    if(Loader._assets[url]) return;
    var options = arguments[1] || {};
    var a = {};
    a.image = new Image();
    a.image.src = url;
    a.complete = false;
    a.options  = options;
    a.loaded_at = new Date().getTime();
    Event.observe(a.image, 'error', function(){ Loader.error(url) });
    Loader._assets[url] = a;
    if(!Loader._checkInterval) Loader._checkInterval = setInterval(Loader._update,10);
  },
  error: function(url) {
    var asset = Loader._assets[url];
    asset.complete = true;
    if(asset.options.onComplete) asset.options.onComplete('/images/empty.gif');
  },
  stats: function(url) {
    return (Loader._assets[url]._complete ?
      (Loader._assets[url]._completed_at - Loader._assets[url]._loaded_at) : null);
  },
  isQueued: function(url) {
    return !!(Loader._assets[url]);
  },
  isLoaded: function(url) {
    return (Loader._assets[url] && Loader._assets[url].complete);
  },
  reset: function() {
    Loader._assets = $H({});
  }
};

Event.localPointer = function(event){
  var p = [Event.pointerX(event), Event.pointerY(event)];
  var element = arguments[1] || Event.element(event);
  var e = Position.page($(element));
  return [
    p[0]-(e[0]+(window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0)),
    p[1]-(e[1]+(window.pageYOffset || document.documentElement.scrollTop  || document.body.scrollTop  || 0))];
};

Effect.HScroll = Class.create();
 Object.extend(Object.extend(Effect.HScroll.prototype, Effect.Base.prototype), {
   initialize: function(delta) {
     this.scrollStart = window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
     
     var w = Position.getPageSize();
     if(this.scrollStart + delta < 0) delta = -this.scrollStart;
     if(this.scrollStart + delta > (w.page.width-w.window.width)) delta = (w.page.width-w.window.width) - this.scrollStart;
     
     this.delta   = delta;
     
     this.start(arguments[1] || {});
   },
   update: function(position) {
     Position.prepare();
     window.scrollTo(this.scrollStart + (position*this.delta), 0); 
   }
 });
 
Effect.HScrollTo = Class.create();
Object.extend(Object.extend(Effect.HScrollTo.prototype, Effect.Base.prototype), {
  initialize: function(scrollEnd) {
    this.scrollStart = window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
    
    var delta = scrollEnd - this.scrollStart;
    var w = Position.getPageSize();
    if(this.scrollStart + delta < 0) delta = -this.scrollStart;
    if(this.scrollStart + delta > (w.page.width-w.window.width)) delta = (w.page.width-w.window.width) - this.scrollStart;
    
    this.delta   = delta;
    
    this.start(arguments[1] || {});
  },
  update: function(position) {
    Position.prepare();
    window.scrollTo(this.scrollStart + (position*this.delta), 0); 
  }
});

Effect.MoveRight = Class.create();
Object.extend(Object.extend(Effect.MoveRight.prototype, Effect.Base.prototype), {
  initialize: function(element, delta) {
    this.element = $(element);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      x:    delta
    }, arguments[2] || {});
    this.start(options);
  },
  setup: function() {
    this.originalRight = this.options.initialRight || parseFloat(this.element.getStyle('right') || '0');
  },
  update: function(position) {
    this.element.setStyle({
      right: Math.round(this.options.x  * position + this.originalRight) + 'px'
    });
  }
});

Effect.ScaleMoveRelative = Class.create();
Object.extend(Object.extend(Effect.ScaleMoveRelative.prototype, Effect.Base.prototype), {
  initialize: function(element) {
    this.element = $(element);
    if(!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      scaleFrom: [0, 0],
      scaleBy: [1, 1],
      moveBy: [0, 0]
    }, arguments[1] || {});
    this.start(options);
  },
  setup: function() {
    this.scale = [
      (this.options.scaleFrom[0]*this.options.scaleBy[0]) - this.options.scaleFrom[0],
      (this.options.scaleFrom[1]*this.options.scaleBy[1]) - this.options.scaleFrom[1]
    ];
    this.scaleTo = [
      this.options.scaleFrom[0] + this.scale[0],
      this.options.scaleFrom[0] + this.scale[1]
    ];
  },
  update: function(position) {
    style = $H({
      width:  Math.round(this.options.scaleFrom[0] + (this.scale[0] * position)),
      height: Math.round(this.options.scaleFrom[1] + (this.scale[1] * position))
    });
    style.left = 
      Math.round(((this.element.deltax || 0) + (this.options.moveBy[0] * position)) * (style.width/this.options.scaleFrom[0])) + 'px';
    style.top = 
      Math.round(((this.element.deltay || 0) + (this.options.moveBy[1] * position)) * this.options.scaleBy[1]) + 'px',
    //console.log('@'+ position + ': ' + style.inspect());
   
    this.element.setStyle({
      left: style.left,
      top: style.top,
      width: style.width + 'px',
      height: style.height + 'px'
    });
  }
});

var wheelCallback = Prototype.K;

function handleMouseWheel(delta) {
  wheelCallback(delta);
}

function wheel(event){
  var delta = 0;
  if (!event) event = window.event;
  if (event.wheelDelta) {
    delta = event.wheelDelta/120; 
    if (window.opera) delta = -delta;
  } else if (event.detail) {
    delta = -event.detail/3;
  }
  if (delta) handleMouseWheel(delta);
  //if (event.preventDefault) event.preventDefault();
  //event.returnValue = false;
}

function scrollToHeadline(headline){
  var find = headline.innerHTML.gsub(/\s/,'');
  var e = $$('h1').detect(function(h){  return (h.innerHTML.gsub(/\s/,'') == find) });
  if(!e) return;
  var p = Position.page(e);
  new Effect.HScrollTo(p[0]-15-32,{transition:Gucci.cubic});
}

if (window.addEventListener)
  window.addEventListener('DOMMouseScroll', wheel, false);
window.onmousewheel = document.onmousewheel = wheel;

// global
var numItems = 0;

function getServerName() {
  var href = document.location.href;
  var rExp = /^https*:\/\//;
  var rExp2 = /\/.*$/;
  var href2 = href.replace(rExp, '')
  var href3 = href2.replace(rExp2, '')
  return href3;
}

function getSecureProtocol(serverName) {
  if(serverName.substring(0,4)=='www.') {
    return "https://";
  }
  else if(serverName.substring(0,6)=='stage.') {
    return "https://";
  }
  else {
    return "http://";
  }
}

function getSite() {
  var href = document.location.href;
  var rExp = /^https*:\/\/[^/]+\/([^/]+)\/.*$/
  var site = href.replace(rExp, '$1');
  return site;
}

function getSecureBaseURL() {
  var serverName = getServerName();
  var protocol = getSecureProtocol(serverName);
  var site = getSite();
  var ur = protocol+serverName+'/'+site;
  return ur;
}