AUI().add('ltt-request-manager', function(A){	
	function LttRequester(){
		LttRequester.superclass.constructor.apply(this, arguments);
	}
	LttRequester.NAME = 'ltt-request-manager';	
	
	LttRequester.ATTRS = {			
		ioConfigs: {
			value: {
				method: 'POST',
				sync: false,					
				timeout: 10000,
				headers: {
					'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'											
				},				 
				on: {
					start: function(){
						Liferay.Ltt.showOverlay();
					},
					end: function(){
						Liferay.Ltt.hideOverlay();
					}
				}
			},
			setter: function(inVal){				
				var retVal = {
						method: 'POST',
						sync: false,					
						timeout: 10000,
						headers: {
							'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
						},
						on: {
							start: function(){
								Liferay.Ltt.showOverlay();
							},
							end: function(){
								Liferay.Ltt.hideOverlay();
							}
						}
					},
					curVal = this.get('ioConfigs');
				if(curVal)
					retVal = A.merge(retVal, curVal);	
				if(!A.Lang.isUndefined(inVal.on)){
					inVal.on = A.merge(retVal.on, inVal.on);
				}
				retVal = 	A.merge(retVal, inVal);				
				return retVal;
			}
		}
	};	
	A.extend(LttRequester, A.Base, {
		 initializer: function(){			 
		 },
		 destructor: function(){},
		 request: function(uri, data){			 
			 return A.io(uri, A.merge(this.get('ioConfigs'),{data: data}));
		 }
	});
	A.LttRequester = LttRequester;
		
	A.on('io:failure', function(transactionId, response){			
		A.log({
			message: "io:failure occure!", 
			arguments: arguments
			},
			Liferay.Util.logCodes.WARN);
		
		/*Liferay.Ltt.showOverlay();
	    new A.Dialog({
            title: '<span style="color:red;">' + "Error" + '</span>',
            bodyContent: A.dump(arguments),
            draggable: false,
            modal: true,
            resizable: false,
            centered: true,
            close: false,
            destroyOnClose: true,
            group: 'default',
            height: 200,
            stack: true,
            width: 400,
            buttons: [
                {
                    text: "Ok",
                    handler: function() {
                    	Liferay.Ltt.hideOverlay();
                        this.close();                        
                    }
                }
            ]
	    }).render();*/
	});

}, '0.5', {
	requires : ['base', 'io-base', 'aui-dialog', 'dump']
});


AUI().add('ltt-training-search-helper', function(A){
	var SEARCH_FIELD_CLASS = 'lttSearchFilterKeywords',
        HINT_CONTAINER_CLASS = 'lttHintContainer',
        HINT_CONTAINER_DIV = '',
		CATEGS_BLK_SLCTR = "#ltt_sh_categories",
		PAGES_BLK_SLCTR = "#ltt_sh_pages",
		TRNNGS_BLK_SLCTR = "#ltt_sh_trainings",
		ITEMS_HLDR_SLCTR = ".search-results",
		HOVERED_ITEM_CLSSNM = "hover",
		ITEM_CLSSNM = "search-result";
		
	var LttSHHintList = new A.Component.create({
		NAME: "LttTrnngSearchHelper",
		EXTENDS: A.Component,        
		ATTRS: {
			allResults: {
				value: []
			},
			curItemNum: {
				value: -2
			},
			categsResults: {
				value: []
			},
			pagesResults: {
				value: []
			},
			trainingsResults: {
				value: []
			},
			categsBlkNode: {},
			pagesBlkNode: {},
			trainingsBlkNode: {},
			categsHldrNode: {},
			pagesHldrNode: {},
			trainingsHldrNode: {}
		},
		prototype: {
			initializer: function(){
				var contentBox = this.get('contentBox'),
					categsBlkNode = contentBox.one(CATEGS_BLK_SLCTR),
					pagesBlkNode = contentBox.one(PAGES_BLK_SLCTR),
					trainingsBlkNode = contentBox.one(TRNNGS_BLK_SLCTR);
				this.set('categsHldrNode', categsBlkNode.one(ITEMS_HLDR_SLCTR));
				this.set('pagesHldrNode', pagesBlkNode.one(ITEMS_HLDR_SLCTR));
				this.set('trainingsHldrNode', trainingsBlkNode.one(ITEMS_HLDR_SLCTR));
				this.set('categsBlkNode', categsBlkNode);
				this.set('pagesBlkNode', pagesBlkNode);
				this.set('trainingsBlkNode', trainingsBlkNode);
			},
			bindUI: function(){
				var instance = this;
					contentBox = instance.get('contentBox');
				A.one("document").on("click", function(e){
					if(instance.get('curItemNum')>-2){
						var curX = e.pageX,
							curY = e.pageY,
							minX = contentBox.getX(),
							maxX = minX + contentBox.get('clientWidth'),
							minY = contentBox.getY(),
							maxY = minY + contentBox.get('clientHeight');
						if(curX<minX || curX>maxX || curY<minY || curY>maxY)
							instance.setResults({});	
					}
					
				});
			},
			resetAll: function(){
				var instance=this;
				instance.set('allResults', []);
				
				instance.set('categsResults', []);
				instance.set('pagesResults', []);
				instance.set('trainingsResults', []);
				
				instance.get('categsBlkNode').hide();
				instance.get('pagesBlkNode').hide();
				instance.get('trainingsBlkNode').hide();
				
				instance.get('categsHldrNode').empty();
				instance.get('pagesHldrNode').empty();
				instance.get('trainingsHldrNode').empty();
				
				instance.set('curItemNum', -2);
			},
			moveNext: function(){
				var instance = this;
					curItemNum = instance.get('curItemNum');
				if(curItemNum>-2){
					var allResults = instance.get('allResults'),
						last = allResults.length-1;
					if(curItemNum<last){						
						if(curItemNum!=-1)
							allResults[curItemNum].node.removeClass(HOVERED_ITEM_CLSSNM);						
					}else{
						allResults[last].node.removeClass(HOVERED_ITEM_CLSSNM);
						curItemNum=-1;
					}
					allResults[++curItemNum].node.addClass(HOVERED_ITEM_CLSSNM);
					instance.set('curItemNum',curItemNum);
				}
			},
			movePrev: function(){
				var instance = this;
					curItemNum = instance.get('curItemNum');
				if(curItemNum>-2){
					var allResults = instance.get('allResults'),
						first = 0,
						last = allResults.length-1;
					if(curItemNum>=first){						
						allResults[curItemNum].node.removeClass(HOVERED_ITEM_CLSSNM);
						if(curItemNum==first)
							curItemNum=last+1;
					}else{
						curItemNum=last+1;							
					}
					allResults[--curItemNum].node.addClass(HOVERED_ITEM_CLSSNM);
					instance.set('curItemNum',curItemNum);
				}
			},
			getCurrentLnk: function(){
				var instance = this,
					curItemNum = instance.get('curItemNum');
				if(curItemNum>-1){
					return instance.get('allResults')[curItemNum].node.one("a");
				}
				return null;
			},
			setResults: function(raw){				
				var instance = this,
					contentBox = instance.get('contentBox');
				contentBox.hide();
				instance.resetAll();	
				
				var	allResults = instance.get('allResults'),
					categsResults = instance.get('categsResults'),
					pagesResults = instance.get('pagesResults'),
					trainingsResults = instance.get('trainingsResults'),
					categsBlkNode = instance.get('categsBlkNode'),
					pagesBlkNode = instance.get('pagesBlkNode'),
					trainingsBlkNode = instance.get('trainingsBlkNode'),
					categsHldrNode = instance.get('categsHldrNode'),
					pagesHldrNode = instance.get('pagesHldrNode'),
					trainingsHldrNode = instance.get('trainingsHldrNode'),
					createTemplate = function(item){
						return '<li class="'+ITEM_CLSSNM+'"><a href="' + item.url + '">' 
						+ item.title + '<span>' + item.content + '</span>'+ '</a></li>';
					},
					createTemplateForPage = function(item){
						return '<li class="'+ITEM_CLSSNM+'"><a href="' + item.url + '" target="_blank">' 
						+ item.title + '<span>' + item.content + '</span>'+ '</a></li>';
					},
					show = false;
				
				
				var cl = (raw.categories)?raw.categories.length:0,
					pl = (raw.pages)?raw.pages.length:0,
					tl = (raw.trainings)?raw.trainings.length:0;
				
				if(cl>0){
					show = true;
					for(var i=0;i<cl;i++){
						var node = new A.Node.create(createTemplate(raw.categories[i])),
							item = {
								pos: allResults.length,
								selected: false,
								node: node
							};
						categsHldrNode.append(node);
						allResults.push(item);
						categsResults.push(item);
					}
					categsBlkNode.show();
				}
				if(pl>0){
					show = true;
					for(var i=0;i<pl;i++){
						var node = new A.Node.create(createTemplateForPage(raw.pages[i])), 
							item = {
								pos: allResults.length,
								selected: false,
								node: node
							};
						pagesHldrNode.append(node);
						allResults.push(item);
						pagesResults.push(item);
					}
					pagesBlkNode.show();
				}
				if(tl>0){
					show = true;
					for(var i=0;i<tl;i++){
						var node = new A.Node.create(createTemplate(raw.trainings[i])),
							item = {
							pos: allResults.length,
							selected: false,
							node: node
						};
						trainingsHldrNode.append(node);
						allResults.push(item);
						trainingsResults.push(item);
					}
					trainingsBlkNode.show();
				}
				if(show){
					instance.set('curItemNum', -1);
					contentBox.show();
					instance.set('allResults', allResults);
					instance.set('categsResults', categsResults);
					instance.set('pagesResults', pagesResults);
					instance.set('trainingsResults', trainingsResults);
				}
			}
		}
	});

	A.LttTrnngSearchHelper = new A.Component.create({
		NAME: "LttTrnngSearchHelper",
		EXTENDS: A.Component,
		ATTRS: {
			urlTemplate: {

			},            
			hintsHldrLstWdgt: {},			
            formId: {

            }
		},
		prototype: {
			initializer: function(){
				this.set('hintsHldrLstWdgt', new LttSHHintList({srcNode: '.' + HINT_CONTAINER_CLASS}));
			},
			renderUI: function(){
				this.get('hintsHldrLstWdgt').render();
			},
			bindUI: function(){
				var instance = this,
					hintsWdg = instance.get('hintsHldrLstWdgt'),
					ajaxURLTemplate = instance.get('urlTemplate'),
					formNode = A.one('#' + instance.get('formId'));
					
				formNode.on('submit',function(e){
					var lnk = hintsWdg.getCurrentLnk();
					if(lnk){
						e.preventDefault(true);
						if(Liferay.Browser.isIe()){
							window.event.returnValue = false;
							event.returnValue = false;
							window.location.assign(lnk._node.href);
							return false;
						}						
						lnk.simulate('click');						
					}
				});	

                formNode.all('input[type="text"]').each(function(field) {
                    
					field.on('keydown', function(e){						
						if(e.keyCode==9)
							hintsWdg.setResults({});						
					});
                    field.after('keyup', function(e) {
                        var ajaxURL = ajaxURLTemplate;
                        var word = field.val();						
						e.preventDefault();						
						if(e.keyCode==38){
							hintsWdg.movePrev();
							return;
						}else if(e.keyCode==40){
							hintsWdg.moveNext();
							return;
						}else if(e.keyCode==13){
							return;
						}						
                        
                        if (word && word.length > 2) {
                            ajaxURL = ajaxURL.replace('KEYWORD_PLACEHOLDER', word);
														
                            A.io(ajaxURL, {
                                method: 'GET',
                                on: {
                                    complete: function(id, o) {
                                        var res = A.JSON.parse(o.responseText);

										
										hintsWdg.setResults(res);                                        
                                    }
                                }
                            });
                        } else {                        	
							hintsWdg.setResults({});
                        }
                    });



                   /* field.on('blur', function() {
                       var container = instance.get("hintsHolder");
                        container.addClass('aui-helper-hidden');
                        container.empty();
                    });  */
                });
			},
			syncUI: function(){}
		}
	});
}, '0.5', {
	requires : ['aui-component', 'aui-node', 'aui-io']
});



AUI().add('ltt-glossary-starter', function(A){
	
	var GLSSRY_POPUP_HEADER_CLSSNM = "header",
	GLSSRY_POPUP_BODY_CLSSNM = "body",
	GLSSRY_POPUP_CNTRLS_CLSSNM = "controls",
	GLSSRY_POPUP_CTRL_MOVER_CLSSNM = "drag-panel",
	readyMoverClassname = "",
	GLSSRY_POPUP_CTRL_CLOSE_CLSSNM = "close",
	readyCloseClassname = "",
	GLSSRY_POPUP_CTRL_LINKS_BLK_CLSSNM = "linksBlock",
	GLSSRY_POPUP_CTRL_LINKS_HDLN_CLSSNM = "linksHdln",
	GLSSRY_POPUP_CTRL_LINKS_HLDR_CLSSNM = "linksHldr",
	GLSSRY_POPUP_CTRL_LINK_HLDR_CLSSNM = "linkHldr",
	GLSSRY_POPUP_CTRL_LINK_MORE_CLSSNM = "link-more";

	var LttGlossaryPopup = new A.Component.create({
		NAME: "ltt-glossary-popup",
		EXTENDS: A.Component,		
		ATTRS: {			
			headerNode: {},
			bodyNode: {},
			headerHtml: {},
			bodyHtml: {},
			cntrlsNode: {},
			moverNode: {},
			closerNode: {},
			linksNode: {},
			linkMoreTxt: {},
			linkMoreLinks: {},
			x: {},
			y: {},		
			addBottomIndent: {
				value: 43
			}
		},
		prototype: {
			initializer: function(){
				this.hide();
				this._generateContentStruct();
			},
			_generateContentStruct: function(){
				var contentBox = this.get("contentBox"),
					linkMoreLinks = this.get("linkMoreLinks");
				readyMoverClassname = this.getClassName(GLSSRY_POPUP_CTRL_MOVER_CLSSNM);
				readyCloseClassname = this.getClassName(GLSSRY_POPUP_CTRL_CLOSE_CLSSNM);
				var	header = A.Node.create("<div class='"+this.getClassName(GLSSRY_POPUP_HEADER_CLSSNM)+"'>"+this.get("headerHtml")+"</div>"),
					body = A.Node.create("<div class='"+this.getClassName(GLSSRY_POPUP_BODY_CLSSNM)+"'>"+this.get("bodyHtml")+"</div>"),
					cntrls = A.Node.create("<div class='"+this.getClassName(GLSSRY_POPUP_CNTRLS_CLSSNM)+"'></div>"),
					mover = A.Node.create("<div class='"+readyMoverClassname+"'></div>"),
					closer = A.Node.create("<button type='button' class='"+readyCloseClassname+"'></button>"),
					lnksBlock = A.Node.create("<div class='"+
							this.getClassName(GLSSRY_POPUP_CTRL_LINKS_BLK_CLSSNM)+"'><div class='"+
							this.getClassName(GLSSRY_POPUP_CTRL_LINKS_HDLN_CLSSNM)+"'>"+this.get('linkMoreTxt')+
							"</div></div>"),
					lnksHldr = A.Node.create("<ul class='"+this.getClassName(GLSSRY_POPUP_CTRL_LINKS_HLDR_CLSSNM)+"'></ul>");
				cntrls.append(mover);
				cntrls.append(closer);
				var len = linkMoreLinks.length;
				for(var i=0;i<len;i++){
					lnksHldr.append(A.Node.create("<li class='"+this.getClassName(GLSSRY_POPUP_CTRL_LINK_HLDR_CLSSNM)+
							"'><a href='" + linkMoreLinks[i] + "' target='_blank' class='"+this.getClassName(GLSSRY_POPUP_CTRL_LINK_MORE_CLSSNM)+
							"'>"+linkMoreLinks[i].replace("http://","")+"</a></li>"));
				}
				if(len>0){
					lnksBlock.append(lnksHldr);				
					cntrls.append(lnksBlock);				
				}
				contentBox.append(header);				
				contentBox.append(body);
				contentBox.append(cntrls);
				this.set("headerNode",header);
				this.set("bodyNode",body);
				this.set("cntrlsNode",cntrls);
				this.set("moverNode",mover);
				this.set("closerNode",closer);
				this.set("linksNode",lnksHldr);
			},
			renderUI: function(){
				var bb = this.get("boundingBox");
				bb.setStyle("position", "absolute");
				bb.plug(A.Plugin.Drag);
				bb.dd.addHandle(this.get('moverNode'));
			},
			bindUI: function(){
				var instance = this;
				instance.get("closerNode").on("click", function(e){					
					instance.hide();					
				});
			},			
			syncUI: function(){},
			show: function(nx, ny){				
				var boundingBox = this.get("boundingBox"),
					x = this.get('x'),
					y= this.get('y'),
					addBottomIndent = this.get('addBottomIndent'),
					docH = boundingBox.get('docHeight');;
				
				if(arguments.length==2){
					x = nx;
					y = ny;
					this.set("x", x);
					this.set("y", y);
				}
				boundingBox.setStyles({
					left: x,
					top: y
				});
				boundingBox.show();
				var	hY = boundingBox.getY(),
            		hH = boundingBox.get('offsetHeight');
				if(docH-addBottomIndent<hY+hH)
					boundingBox.setY(docH-hH-addBottomIndent);
			},
			hide: function(){
				this.get("boundingBox").hide();
			}
		}
	});	
	
	
	var LttGlossaryStarter = function(){
		LttGlossaryStarter.superclass.constructor.apply(this, arguments);
	};
	LttGlossaryStarter.NAME = 'ltt-glossary-starter';		
	LttGlossaryStarter.ATTRS = {			
		wordSlctr: {
			value: '.glossary'
		},
		requester: {},
		requestUrl: {},			
		replaceVar: {
			value: "WORD_PLACEHOLDER"
		},
		cache: {}
	};	
	A.extend(LttGlossaryStarter, A.Base, {
		 initializer: function(){
			 var instance = this,			 	
			 	requestUrl = instance.get("requestUrl"),
			 	replaceVar = instance.get("replaceVar"),
			 	cache = {};			 
			 
			 var requester = new A.LttRequester({
				ioConfigs: {
					method: 'GET',
					on: {
						success: function(id, o, args) {
							try{
								var callback = A.JSON.parse(o.responseText);
		                        if(callback.success == true){			                        	
		                            var hinterNode = cache[id];
		                            var hinter = new LttGlossaryPopup({
		                            	x: hinterNode.getData("x"),
		                            	y: hinterNode.getData("y"),
		                            	headerHtml: callback.word,
		                    			bodyHtml: callback.content,
		                    			linkMoreTxt: callback.urlMessage,
		                    			linkMoreLinks: callback.urls
		                            });
		                            hinter.render();
		                            hinter.show();		                           
		                            hinterNode.setData("hinter", hinter);
		                        }else{
		                        	A.fire('io:failure',{id:id, response: callback});                                                                                
		                        }
							}catch (e) {
                         		A.fire('io:failure',{id:id, response: A.dump(e)});
							}
	                    }
					}
				}
			 });
			 
			 var body = A.one("body"); 
			 body.delegate("click", function(e){
				 e.preventDefault();
				 var termNode = e.target,
				 	hinter = termNode.getData('hinter');
				 if(hinter){
					hinter.show(); 
				 }else{					
					 termNode.setData("x", e.pageX);
					 termNode.setData("y", termNode.getY());
					 var res = requester.request(A.clone(requestUrl).replace(replaceVar, e.target.text()));
					 cache[res.id] = termNode;
				 }				 
			 },instance.get("wordSlctr"));
			 A.on(Liferay.Ltt.eventNames.GLOSSAR_CLOSE_ALL_HINTS, function(e){
				 A.all("." + readyCloseClassname).each(function(closer){
					if(Liferay.Browser.isIe())
						closer._node.click();
					else
						closer.simulate("click");
				 });
			 });
		 },
		 destructor: function(){}		 
	});	
	
	A.LttGlossaryStarter = LttGlossaryStarter;
	
}, '0.5', {
	requires : ['aui-component', 'node', 'event', 'oop', 'dd-plugin', 'ltt-request-manager']
});