if(typeof(AC)=="undefined"){AC={};}

AC.Bureau=Class.create();
Object.extend(AC.Bureau.prototype,Event.Listener);
Object.extend(AC.Bureau.prototype,{

	drawers:null,
	container:null,

	triggerTimeout:null,

	initialize:function(container){
	this.drawers=[];
	this.container=$(container);
	},

	addDrawer:function(newDrawer){},

	getDrawerCount:function(){
		return this.drawers.length;
	},

	hasDrawers:function(){
		return(this.drawers.length>0);
	},

	getFirstDrawer:function(){
		return this.drawers[0]||null;
	},

	getLastDrawer:function(){
		return this.drawers[this.drawers.length-1]||null;
	},

	scheduleTrigger:function(onFire,delay){
		this.triggerTimeout=setTimeout(onFire,delay);
	},

	clearTrigger:function(){
		clearTimeout(this.triggerTimeout);
	}

});

AC.Drawer=Class.create();
Object.extend(AC.Drawer.prototype,Event.Publisher);
Object.extend(AC.Drawer.prototype,{

	bureau:null,

	contentElement:null,
	handle:null,
	indicator:null,

	isOpen:true,

	beforeOpen:null,
	afterOpen:null,

	beforeClose:null,
	afterClose:null,

	transitionDuration:0.3,
	triggerDelay:0,





	initialize:function(contentElement,handleElement,bureau,options){

		this.contentElement=contentElement;
		this.handle=handleElement;
		this.bureau=bureau;

		var triggerEvent='click';

		if(options!=null&&typeof(options)!='undefined'){
			this.beforeOpen=options.beforeOpen;
			this.afterOpen=options.afterOpen;
			this.beforeClose=options.beforeClose;
			this.afterClose=options.afterClose;


			if(typeof(options.triggerEvent)!='undefined'){
				triggerEvent=options.triggerEvent;
			}

			if(typeof(options.triggerDelay)!='undefined'){
				this.triggerDelay=options.triggerDelay;
			}

			if(typeof(options.transitionDuration)!='undefined'){
				this.transitionDuration=options.transitionDuration;
			}
		}

		if(AC.Detector.isiPhone()){
			this.transitionDuration=0;
			triggerEvent='click';
		}

		Element.addClassName(this.contentElement,'last');

		var fireTrigger=function(evt){

			Event.stop(evt);

			if(this.triggerDelay>0){
				var onFire=this.trigger.bind(this);
				bureau.scheduleTrigger(onFire,this.triggerDelay);
			}else{
				this.trigger();
			}
		}

		Event.observe(this.handle,triggerEvent,fireTrigger.bind(this),false);
		Event.observe(this.handle,'mouseout',bureau.clearTrigger.bind(bureau),false);

	},

	toggle:function(){},

	open:function(){},

	close:function(){}

});


AC.SlidingBureau=Class.create();
Object.extend(AC.SlidingBureau.prototype,AC.Bureau.prototype);
Object.extend(AC.SlidingBureau.prototype,{

	isLocked:false,

	addDrawer:function(newDrawer){

		Element.addClassName(newDrawer.contentElement,'last');
		Element.addClassName(newDrawer.handle,'last');

		if(this.hasDrawers()){

		var lastDrawer=this.getLastDrawer();

		lastDrawer.setNextDrawer(newDrawer);
		newDrawer.setPreviousDrawer(lastDrawer);
		}else{
		Element.addClassName(newDrawer.contentElement,'first');
		Element.addClassName(newDrawer.handle,'first');
		}

		this.listenForEvent(newDrawer,'beforeOpen',false,function(evt){
		var drawer=evt.event_data.data;
		this.open(drawer);
		});

		this.listenForEvent(newDrawer,'afterOpen',false,function(evt){
		var drawer=evt.event_data.data;
		this.acknowledgeOpened(drawer);
		});

		this.listenForEvent(newDrawer,'beforeClose',false,function(evt){
		var drawer=evt.event_data.data;
		this.close(drawer);
		});

		this.listenForEvent(newDrawer,'afterClose',false,function(evt){
		var drawer=evt.event_data.data;
		this.acknowledgeClosed(drawer);
		});



		if(!Element.hasClassName(newDrawer.contentElement,'open')){
			newDrawer.initiateClose();
		}else{
			this.currentDrawer=newDrawer;
		}

		this.drawers.push(newDrawer);
	},

	open:function(drawer){

	if(this.isLocked){
	return;
	}

	this.isLocked=true;








	if(Element.getStyle(this.container,'position')=='relative'){

	var dimensions=Element.getDimensions(this.container);
	Element.setStyle(this.container,{height:dimensions.height+"px"});

	this.wedgeDrawersAfter(drawer);






	var minHeight=Element.getStyle(drawer.contentElement,'min-height');

	if(minHeight){
	Element.setStyle(drawer.contentElement,{
	'min-height':'0px',
	height:minHeight})
	}
	}


	if(this.currentDrawer){
	this.currentDrawer.initiateClose();
	}

	drawer.open(minHeight);
	},

	acknowledgeOpened:function(drawer){
	this.currentDrawer=drawer;

	if(Element.getStyle(this.container,'position')=='relative'){
	if(!AC.Detector.isIEStrict()){
	Element.setStyle(this.container,{height:"auto"});
	}
	this.unwedgeDrawers();
	}

	this.isLocked=false;
	},

	close:function(drawer){

	if(Element.getStyle(this.container,'position')=='relative'){
	var minHeight=Element.getStyle(drawer.contentElement,'min-height');

	if(minHeight){
	Element.setStyle(drawer.contentElement,{
	height:minHeight,
	'min-height':'0px'});
	}
	}

	drawer.close(minHeight);
	},

	acknowledgeClosed:function(drawer){
	if(drawer==this.currentDrawer){
	this.currentDrawer=null;
	}
	},

	wedgeDrawersAfter:function(drawerBeingOpened){

	var wedgeDrawer=function(drawer,offset){
	Element.setStyle(drawer.handle,{
	position:'absolute',
	bottom:offset+'px'})
	}

	var drawer=this.getLastDrawer();
	var offset=0;

	while(drawer!=this.currentDrawer&&drawer!=drawerBeingOpened){
	wedgeDrawer(drawer,offset);
	offset+=drawer.handle.getHeight();
	drawer=drawer.previousDrawer;
	}

	},

	unwedgeDrawers:function(){
	for(var i=this.drawers.length-1;i>=0;i--){
	Element.setStyle(this.drawers[i].handle,{
	position:'static'})
	};
	}


});

AC.SlidingDrawer=Class.create();
Object.extend(AC.SlidingDrawer.prototype,AC.Drawer.prototype);
Object.extend(AC.SlidingDrawer.prototype,{

	isOpen:true,
	isTransitioning:false,

	setNextDrawer:function(drawer){
		this.nextDrawer=drawer;
		Element.removeClassName(this.contentElement,'last');
		Element.removeClassName(this.handle,'last');
	},

	setPreviousDrawer:function(drawer){
		this.previousDrawer=drawer;
	},

	trigger:function(){
		this.toggle();
	},

	toggleClick:function(clicked){
		this.bureau.clearTrigger(this.bureau);
		this.toggle(clicked);
	},

	toggle:function(clicked){
		
		if(!this.isOpen){
			this.initiateOpen();
		} else if (clicked)
			this.initiateClose(); // AS080203: patching
		
	},

	initiateOpen:function(){

		if(this.isTransitioning||this.isOpen){
		return;
		}

		this.dispatchEvent('beforeOpen',this);

	},

	open:function(minHeight){

		this.isTransitioning=true;


		Element.addClassName(this.contentElement,'open');
		Element.addClassName(this.handle,'open');

		var afterFinish=function(){
			this.isOpen=true;
			if(minHeight){
				Element.setStyle(this.contentElement,{'min-height':minHeight});
				if(!AC.Detector.isIEStrict()){
					Element.setStyle(this.contentElement,{'height':'auto'});
				}
			}
			this.dispatchEvent('afterOpen',this);
			this.isTransitioning=false;
		}.bind(this);

		if(AC.Detector.isiPhone()){
			this.contentElement.show();
			afterFinish();
		}else{
			new Effect.BlindDown(this.contentElement,{
			duration:this.transitionDuration,
			afterFinish:afterFinish});
		}
	},

	initiateClose:function(force){

		if(this.isTransitioning||!this.isOpen){
			return;
		}

		this.dispatchEvent('beforeClose',this);
	},

	close:function(minHeight){

		this.isTransitioning=true;

		var afterFinish=function(){
			this.isOpen=false;
			Element.removeClassName(this.contentElement,'open');
			Element.removeClassName(this.handle,'open');
			if(minHeight){
				Element.setStyle(this.contentElement,{'min-height':minHeight});
				if(!AC.Detector.isIEStrict()){
					Element.setStyle(this.contentElement,{'height':'auto'});
				}
			}
			this.dispatchEvent('afterClose',this);
			this.isTransitioning=false;
		}.bind(this);

		if(AC.Detector.isiPhone()){
			this.contentElement.hide();
			afterFinish();
		}else{
			if (this.contentElement) {
				new Effect.BlindUp(this.contentElement,{
				duration:this.transitionDuration,
				afterFinish:afterFinish});
			}
		}


	}


});


AC.ShingleBureau=Class.create();
Object.extend(Object.extend(AC.ShingleBureau.prototype,AC.Bureau.prototype),{

	drawerDuration:0.5,

	addDrawer:function(newDrawer){


		if(this.hasDrawers()){

			var lastDrawer=this.getLastDrawer();

			lastDrawer.setNextDrawer(newDrawer);
			newDrawer.setPreviousDrawer(lastDrawer);
			newDrawer.closedOffset=lastDrawer.closedOffset+lastDrawer.getHandleHeight()-10;
		}else{
			Element.addClassName(newDrawer.contentElement,'first');
			newDrawer.closedOffset=0-newDrawer.getHeight()+newDrawer.getHandleHeight()-10;
			newDrawer.indicateVisible();
		}


		this.drawers.push(newDrawer);
	},

	getWidth:function(){
		return Element.getWidth(this.container);
	},

	getHeight:function(){
		return Element.getHeight(this.container);
	},

	moveDrawer:function(drawer,x,y){
		new Effect.Move(drawer,{
		x:x,
		y:y,
		mode:'absolute',
		transition:Effect.Transitions.sinoidal,
		duration:this.drawerDuration});
	}

});

AC.ShingleDrawer=Class.create();
Object.extend(Object.extend(AC.ShingleDrawer.prototype,AC.Drawer.prototype),{

	openedOffset:0,
	closedOffset:0,

	previousDrawer:null,
	nextDrawer:null,

	isVisible:false,

	trigger:function(){
		if(!this.isVisible){
			this.open(true);
			this.indicateVisible();
		}
	},

	toggle:function(){

		if(!this.isOpen){
			this.open();
			this.indicateVisible();
		}else{
			this.close();
		}

	},

	open:function(force){

		if(this.isOpen&&!force){
			return;
		}

		if(this.previousDrawer!==null){
			this.previousDrawer.close();
			this.previousDrawer.indicateObscured();
		}

		if(this.nextDrawer!==null){
			this.nextDrawer.open();
			this.nextDrawer.indicateObscured();
		}

		this.indicateVisible();
		this.isOpen=true;

		this.bureau.moveDrawer(this.contentElement,0,this.openedOffset);
	},

	close:function(force){

		if(!this.isOpen){
			return;
		}

		if(this==this.bureau.getLastDrawer()){
			return;
		}

		if(this.previousDrawer!==null){
			this.previousDrawer.close();
		}

		this.bureau.moveDrawer(this.contentElement,0,this.closedOffset);
		this.indicateObscured();
		this.isOpen=false;

	},

	setPreviousDrawer:function(drawer){
		this.previousDrawer=drawer;

		this.indicateObscured();

		this.openedOffset=this.previousDrawer.openedOffset+this.previousDrawer.getHandleHeight()-10;
		Element.setStyle(this.contentElement,{top:this.openedOffset+"px"});
	},

	setNextDrawer:function(drawer){
		this.nextDrawer=drawer;

		Element.removeClassName(this.contentElement,'last');

		if(this.previousDrawer!=null){
		this.previousDrawer.setNextDrawer(this);
	}


	zIndex=parseInt(Element.getStyle(this.contentElement,'zIndex'));
		Element.setStyle(this.contentElement,{'zIndex':zIndex+1});
	},

	indicateObscured:function(){
		Element.addClassName(this.contentElement,'obscured');
		this.isVisible=false;
	},

	indicateVisible:function(){
		this.isVisible=true;
		Element.removeClassName(this.contentElement,'obscured');
	},

	getHandleWidth:function(){
		return Element.getWidth(this.handle);
	},

	getHandleHeight:function(){
		return Element.getHeight(this.handle);
	},

	getWidth:function(){
		return Element.getWidth(this.contentElement);
	},

	getHeight:function(){
		return Element.getHeight(this.contentElement);
	}


});



AC.SectionBureau=Class.create();
Object.extend(AC.SectionBureau.prototype,AC.Bureau.prototype);
Object.extend(AC.SectionBureau.prototype,{

	currentDrawer:null,
	locked:false,

	addDrawer:function(newDrawer){
		this.drawers.push(newDrawer);
		newDrawer.handle.addClassName('obscured');
		Element.hide(newDrawer.contentElement);
	},

	openingDrawer:function(drawer){
		if(this.currentDrawer!=null){
			this.currentDrawer.close();
		}

		this.currentDrawer=drawer;
	}

});

AC.SectionDrawer=Class.create();
Object.extend(AC.SectionDrawer.prototype,AC.Drawer.prototype);
Object.extend(AC.SectionDrawer.prototype,{

	isOpen:false,

	trigger:function(){
		this.toggle();
	},

	toggle:function(){

		if(!this.isOpen){
			this.open();
		}

	},

	open:function(){

		if(this.bureau.locked){
			return;
		}

		var afterTransition=function(){
			Element.show(this.contentElement);
		}.bind(this);


		if(typeof(this.afterOpen)=='function'){
			this.bureau.locked=true;
			afterTransition=this.afterOpen.bind(this);
		}

		this.bureau.openingDrawer(this);

			if(typeof(this.beforeOpen)=='function'){
		this.beforeOpen();
		}

		this.isOpen=true;
		Element.removeClassName(this.handle,'obscured');

		new Effect.Appear(this.contentElement,{
		afterFinish:afterTransition,
		duration:this.transitionDuration,
		queue:{scope:'sectionalscope'}});

	},

	close:function(){

		if(typeof(this.beforeClose)=='function'){
		this.beforeClose();
		}

		this.isOpen=false;
		Element.addClassName(this.handle,'obscured');


		var afterTransition=function(){
		if(typeof(this.afterClose)=='function'){
		this.afterClose();
		}

		}.bind(this)

		new Effect.Fade(this.contentElement,{
		afterFinish:afterTransition,
		duration:this.transitionDuration,
		queue:{scope:'sectionalscope'}});

	},

	reportFinishedOpening:function(){
		this.bureau.locked=false;
	}

});