// !Datatable

pf.ui.datatable = {

	render: function () {
		
		// ie requires this
		delete datatable;
		datatable = "";
		
		Y.get("datatable-frame") ? Y.get("datatable-frame").innerHTML = "" : "";
		
		// create the datatable
		datatable = new YAHOO.widget.DataTable("datatable-frame", 
            pf.ui.datatable.init.columndefs(), 
            pf.ui.datatable.init.datasource(), 
            pf.ui.datatable.init.configs()
        );
		
		// update the result count whenever the datatable is changed
		datatable.subscribe("renderEvent", pf.ui.datatable.updateresultcount);
		
		// use client side sorting in embed iframes and when the embed panel is open, otherwise use server side		
		if (typeof(pf.embed) === "undefined" && !$('#embed-frame').is(':visible')) {
			datatable.sortColumn = pf.ui.datatable.handlesort;
		}
		
		pf.ui.datatable.datatable = datatable;	
		pf.ui.sparklines.render();
	},
	
	init: {
	
		columndefs: function () {

			columndefs = [];
			childrendefs = [];
			
			// add rank column (1, 2, 3 ...)
			columndefs[columndefs.length] = {
				key: "k", label:"", className: "rank-column", sortable: false
			};
			
			// add player column
			columndefs[columndefs.length] = {
				key: "n", label:"Player", parser:"string", className:"colPlayer", sortable: true, resizable: true 
			};
    		
			// sorted sparkline column (available for player and season mode only)
			if (pf.screen.sparkline.on == true && pf.screen.mode.type != "w" && pf.screen.gtf.type != "week") {
				
				sparkline = "";
				
				// only add sparkline column if sparkline data is available.
				// accounts for sorted columns that do not have sparkline data,
				// such as player or &gtf=career.
				// added as a special case for g,desc&gtf=career&s=t.
				if (typeof(pf.screen.criteria[pf.screen.sortkey]) !== "undefined" && typeof(pf.screen.results[0].g) !== "undefined") {

    				sparkline_label = 
    				pf.ui.datatable.init.formatters.header_label(pf.screen.criteria[pf.screen.sortkey]);
    				
    				// sorted sparkline plots season values in season mode
    				if (pf.screen.mode.type == "s") {
    					sparkline_label += " (Season)";
    				}
    				
    				if (pf.screen.mode.type == "t") {
    					columndefs[columndefs.length] = {
    						key: "g",
    						label: sparkline_label,
    						formatter: pf.ui.datatable.init.formatters.sparkline_default,
    						className:"col-sparkline col-sparkline-sorted", sortable: false
    					};
    				}
				}
			}

		    // if it is week mode, add the week, opponent and score columns
		    if (pf.screen.mode.type == "w" || pf.screen.gtf.type == "week") {
				

	   			if (pf.screen.gtf.type != "week") {	
					
					if (pf.sport == "nba") {
						columndefs[columndefs.length] = {
							key: "d", label:"Game", className: "col-mode",
							parser:"number", sortable: true
						}; 
					
					} else {
						// week column
			   			// do not show for gtf.mode=week, since it'd be redunant
						columndefs[columndefs.length] = {
							key: "w", label:"Week", className: "col-mode",
							parser:"number", sortable: true
						}; 
					}
				
				}
				
				// opponent column
			    columndefs[columndefs.length] = {
 					key: "o", label:"Opp", parser:"string", className:"col-mode",
 					sortable: false, resizable: true
			    };
			    
			    // score column
			   	columndefs[columndefs.length] = {
			   		key: "s", label:"Score", parser:"string", className:"col-mode",
			   		sortable: false, resizable: true
			   	};
			   	
		    }
			
			// if it is season mode, add the season column
			if (pf.screen.mode.type == "s") {
				columndefs[columndefs.length] = {
					key: "y", label:"Season", parser:"number", sortable: true, className: "col-mode"
				};     
			}

			// count the number of weekly items
			// if it is greater than 1, use our special week x header for it (colgroup) 
			weekly_count = 0;
			
			for (var i=0; i<pf.screen.criteria.length; i++) {
				if (pf.screen.criteria[i].weekly == true) {
					weekly_count++;
				}
			}
			
			// add the rest of the crtieria
			if (pf.screen.criteria) {
				for (var i=0; i<pf.screen.criteria.length; i++) {
					var c = pf.screen.criteria[i];
					
					// custom column formatting for week mode and single weeks 
					if (pf.screen.mode.type == "w" || pf.screen.gtf.type == "week") {
					
						// hide stdg and avpg columns unless they have a local timeframe
						if ((c.aggop == "stdg" || c.aggop == "avpg") && !c.tf) {
							c.shidden = true;
						}
						
						// hide sparklines
						if (c.sparkline == true) {
							c.shidden = true;
							Y.get("log").innerHTML += "yo: " + c.name + "<br />";
						}
						
						// hide g column (always shows 1)
						if (c.name == "g" && !c.tf) {
							c.shidden = true;
						}
					}
					
					weekly_stats_array = ["lm", "fplm", "opta", "avgopta", "rkopta"];						
					weekly_stats = {};
					
					for (var x=0; x<weekly_stats_array.length; x++) {
						weekly_stats[weekly_stats_array[x]] = " ";
					}
											
					hidden_var = (c.hidden || c.shidden);
					class_var = "";
					
						
					if (c.name == "ftm") {
						class_var = "ftm";
					} else if (c.type == 1 && c.name != "opp") {
						class_var = "text";
					} else if (c.name == "opp" || c.name == "lm") {
						class_var = "text-right";
					}
					
					if (c.weekly == true) {
						class_var += " small-col";
					} else if (c.type == 0) {
						class_var += " min-col";
					}
					
					// sparkline columns should not be sortable
					if (c.sparkline == true) {
						sortable_var = false;
						class_var += " col-sparkline";
					} else {
						sortable_var = true;
					}
					
					// special fantasy week columns
					if (c.weekly == true && weekly_count > 1 && pf.page == "fantasy") {
						
						class_var += " this-week-col";
					
						childrendefs[childrendefs.length] = {
							key: i+"",
							label: pf.ui.datatable.init.formatters.header_label(c),
							formatter: pf.ui.datatable.init.formatters[c.formatter],
							sortable: true,
							resizable: true,
							hidden: c.hidden,
							className: class_var,
							sortOptions: { defaultDir: c.defaultsort }
						};
						
					} else { 
					
						// need to add label, className
						// if (!(c.hidden || c.shidden)) {
						columndefs[columndefs.length] = {
							key: i+"",
							label: pf.ui.datatable.init.formatters.header_label(c),
							formatter: pf.ui.datatable.init.formatters[c.formatter],
							sortable: sortable_var,
							hidden: hidden_var,
							className: class_var,
							sortOptions: { defaultDir: c.defaultsort }
						};
					}
				}
			
				if (weekly_count > 1) {
					columndefs.splice(2,0,{
						key: "this-week",
						label: pf.THIS_YEAR + " Week "+pf.this_week,
						className: "th-this-week",
						children: childrendefs
					});
				} else {
					columndefs.splice(2,0)
				}
				
				return columndefs;
			
			}
			
		}, 
		
		schema: function() {
		
			var schema = [
    			{key: "k"}, {key: "n"}, {key: "i"}, {key: "t"}, {key: "g"}, 
    			{key: "o"}, {key: "s"}, {key: "w"}, {key: "d"}, {key: "o"}, 
    			{key: "y"}];
			
			// add the rest of the crtieria
			if (pf.screen.criteria) {
				for (var i=0; i<pf.screen.criteria.length; i++) {
					// need to add label, className and formatter
					schema[schema.length] = i+"";
				}
			}
							
			return schema;

		},
		
		configs: function() {
			
			data = {};
			
			// template 

			paginator = new YAHOO.widget.Paginator({
				rowsPerPage: 30,
				pageLinks: 6,
				totalRecords: pf.screen.resultcount,
				// pageLabelBuilder: pf.ui.datatable.paginator_custom_pagelinks,
				previousPageLinkLabel: "< Prev",
				nextPageLinkLabel: "Next >",
				lastPageLinkLabel: "Last >",
				firstPageLinkLabel: "< First",
				containers: "footer-paginator-frame",
				//template: "",
				template:
					'<div id=\"footer-rpp-frame\">' + 
					'<span class=\"footer-rpp\">Results per page: {RowsPerPageDropdown}</span>' +
					'</div>' + 
					'<div class="footer-paginator">{PreviousPageLink} {PageLinks} {NextPageLink}</div>',
				// pageReportTemplate: ("{startIndex} - {endIndex} of {totalRecords} results"),
				rowsPerPageOptions: [5, 10, 15, 30, 50, 100]
			});
			
			pf.ui.datatable.paginator = paginator;
			// automatic offset
			paginator.subscribe("pageChange", pf.ui.datatable.handleoffset);
			paginator.set("totalRecords", 403);
			return { 
				'paginator': paginator, 
				// highlights sorted data table row
				sortedBy: {key: pf.screen.sortkey, dir: pf.screen.sortdir },
				draggableColumns: true
			}
		},
		
		paginator_custom_pagelinks: function(x) {
			
	        /* if (e && e.prevVal === e.newVal) {
	            return;
	        } */
			
			p = pf.ui.datatable.paginator;
			
	        // var p           = this.paginator,
	        currentPage = p.getCurrentPage();
	
	        // Replace content if there's been a change
	        // if (this.current !== currentPage || !currentPage || e.rebuild) {
	            var labelBuilder = p.get('pageLabelBuilder'),
	                range        = YAHOO.widget.Paginator.ui.PageLinks.calculateRange(
	                                currentPage,
	                                p.getTotalPages(),
	                                p.get('pageLinks')),
	                start        = range[0],
	                end          = range[1],
	                content      = '',
	                linkTemplate,i;
	
	            linkTemplate = 'xxx<a href="#" class="' + p.get('pageLinkClass') +
	                           '" page="';
	            for (i = start; i <= end; ++i) {
	                if (i === currentPage) {
	                    content +=
	                        '<span class="' + p.get('currentPageClass') + ' ' +
	                                          p.get('pageLinkClass') + '">x' +
	                        labelBuilder(i,p) + '</span>';
	                } else {
	                    content +=
	                        linkTemplate + i + '">' + labelBuilder(i,p) + '</a>';
	                }
	            }
	
	            this.container.set('className', p.get('pageLinksContainerClass'));
	            this.container.set('innerHTML', content);
	        //}
		}, //*/
		
		modified_results: function(cr) {
			
			if (cr) {
				results = cr;
			} else {
				results = pf.screen.results;
			}
			criteria = pf.screen.criteria;
			
			if (results) {
				
				ftm_index = false;
				
				for (i=0; i<criteria.length; i++) {
					if (criteria[i].name == "ftm") {
						ftm_index = i;
					}					
				}
			
				for (i=0; i<results.length; i++) {
	
					r = results[i];
					
	            	// delete items with blank values
		            for (val in r) {
	                    value = r[val];
	                    if (value == "--") {
							delete r[val];
	    	       		}
	            	}
	            
		            // add a space between the season and week 
		            // for weeks (eg 200917 -> 2009 17)
		            if (r["w"]) {
			            var str = r["w"] + "";
			            r["w"] = str.substring(0,4) + " " + str.substring(4,6);          
					}
					
					// when m=s the ws doesn't return a season, so the season column is left blank
					// this adds the season				
					if (pf.screen.mode.type == "s" && pf.screen.gtf.type == "season") {
						r["y"] = pf.screen.gtf.season;
					}
	                 
					results[i]["name"] = r["n"];

					// add link to player page
	    			if (typeof(r["l"]) !== "undefined") {
	    				r["n"] = "<a href='/nfl/players"+r["l"]+"' class='plink'>" + r["n"] + "</a> ";
	    			}
					// add fantasy team
					// AUTH_REM
					/* if (ftm_index) {
						
						if (pf.league_data) {	
							/// my team or no team
							if (r[ftm_index] == pf.league_data[pf.league_selected].mytm) {
								r[ftm_index] = '<div class="ftm-my-team">&nbsp;</div>';
							// other team
							} else if(r[ftm_index]) {
								r[ftm_index] = '<div class="ftm-other-team">&nbsp;</div>';
							// no team								
							} else {
								r[ftm_index] = '<div class="ftm-free-agent">&nbsp;</div>';
							}
						} else {
							r[ftm_index] = '<div class="ftm-off">&nbsp;</div>';
						}
						
					} */	
	
		            // add team, position, retired year to player column 
		            // if player is retired, include retired year
		            if (pf.sport == "nfl") {
		            
			            if (r["r"]) { 
			            	// 'born' year
			            	str_b = r["b"]+"";
			            	str_b = str_b.substring(2,4);
			            	// retired
			            	str = r["r"]+"";
			            	str = str.substring(2,4);
			            	r["n"] += " <span class='playertext'>"+r["p"]+" "+r["t"]+" "+str_b+"-"+str+"</span>";
			    		} else {
			               	r["n"] += " <span class='playertext'>" +r["p"]+ " " + r["t"] + "</span>";
		    			}
					
					}
						    			
				results[i] = r;
				
				}
			}
						
			return results;
		
		},
		
		formatters: {
			// do not modify
			none: function (el, oRecord, oColumn, oData) {
				el.innerHTML = oData;
			},
			// default numerical formatter - add commas
			numbers_default: function (el, oRecord, oColumn, oData) {
				
				if (YAHOO.lang.isNumber(oData)) {
					var nStr = oData;
					nStr += '';
					var x = nStr.split('.');
					var x1 = x[0];
					var x2 = x.length > 1 ? '.' + x[1] : '';
					var rgx = /(\d+)(\d{3})/;
					while (rgx.test(x1)) {
						x1 = x1.replace(rgx, '$1' + ',' + '$2');
					}
					oData = x1 + x2;
					el.innerHTML = oData;
				} else {
					el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "-";				
				}
			},
			// default qualitative formatter
			qualitative_default: function (el, oRecord, oColumn, oData) {
				// replace blank values with dashes
				el.innerHTML = YAHOO.lang.isValue(oData) ? oData : "-";			
			},
			sparkline_default: function(e, r, c, d) {
				
				// create the div for the sparkline
				// id is the unique column key plus unique record id
				chart_id = 'sparkline-' + c.getKey() + '-' + r.getId();
				e.innerHTML = '<div id="' + chart_id + '" class="sparkline-frame">&nbsp;</div>';
				
				// replace empty values with null
				// so games with null values will be represented correctly
				results = r.getData()[c.key];				
				for (var i=0; i<results.length; i++) {
					if (results[i] == "--") {
						results[i] = null;
					}
				}
				
				// compile the sparkline metadata for later use 
				pf.ui.sparklines.cache[pf.ui.sparklines.cache.length] = {
					"id": chart_id, "criteria": c, "results": results
				};
				
			},
			// convert inches to feet and inches 
			height: function (el, oRecord, oColumn, oData)  {
				var ft = oData/12;
        		var ftint = parseInt(ft);
        		var inch = parseInt((ft-ftint)*12);
        		oData = ""+ftint+"'"+inch+'"';
				el.innerHTML = oData;
			},
			// last matchup date
			// convert 200804 to 2008 04
			lm: function (el, record, column, data) {
				
				if (data) {
					data += "";
					data = data.substring(0,4) + " " + data.substring(4,6);
					el.innerHTML = data;
				}  else {
					el.innerHTML = "-";
				}
				
			},
			// column header labels
			header_label: function (c) {
				
				// if there is a shortname, use it, otherwise use the full name
				if (typeof(c.shortname) !== "undefined") {
					label = c.shortname; 
				} else if (typeof(c.termname) !== "undefined") {
					label = c.termname;
				} else {
					label = c.name;
				}
				
				c.aggop == "stdg" ? label += " (dev.)":"" ;
				
				if (c.aggop == "avpg") {
					label += " (avg.)";
				}

				// local tf labels
				if (typeof(c.tf) != "undefined") {
					
					if (c.tf.type == "season") {
						label += " (" + c.tf.season + ")";
					} else if (c.tf.type == "seasons") {
						label += " (" + c.tf.seasons[0] + "-" + tf.seasons[c.tf.seasons.length-1] + ")";
					} else if (c.tf.type == "week") {
						str = " (";
						str += c.tf.week;
						str += ")";
						label += str;
					} else if (c.tf.type == "weeks") {
						str = " (";
						str += c.tf.weeks[0];
						str += "-"; 
						str += c.tf.weeks[c.tf.weeks.length-1];
						str += ")";
						label += str;
					} else if (c.tf.type == "career") {
					 	label += " (Career)";
					} else if (c.tf.type == "lweeks") {
						str = " (Last ";
						str += c.tf.week_count;
						str += "W)";
						label += str;
					} else if (c.tf.type == "lseasons") {
						str = " (Last ";
						str += c.tf.season_count;
						str += "Y)";
						label += str;
					}
				
				}
				
				// inserts proper position for opta column labels, which are QB by default
				// e.g. Fan Pts Allowed to QB/RB/WR/TEs
				if (c.name == "avgopta" || c.name == "opta" || c.name == "rkopta") {
					newlabel = false;
					if (typeof(pf.ui.page_links.getSelected()) != "undefined") {
						newlabel = label.replace("QB", pf.ui.page_links.getSelected().toUpperCase());
					}
					newlabel ? label = newlabel : "";
				}
				
				return label;
			}
		},
		datasource: function() {
			// var datasource = new YAHOO.util.FunctionDataSource(pf.ui.datatable.init.modified_results);\
			var datasource = new YAHOO.util.FunctionDataSource(pf.ui.datatable.init.modified_results);
			datasource.responseType = YAHOO.util.FunctionDataSource.TYPE_JSARRAY;
			datasource.responseSchema = { 
				fields: pf.ui.datatable.init.schema(),
				metaFields: { 
					totalRecords: pf.screen.resultcount, 
					/* paginationRecordOffset: "startIndex", 
					paginationRowsPerPage: "pageSize", 
					sortKey: "sort", 
					sortDir: "dir" */
				}
			};
			return datasource;			
		},
		
		paginator: {},
		datatable: {}
		
	},
	handleoffset: function(e) {
		
		scroll(0,0);
		
		paginator = pf.ui.datatable.paginator;
		datatable = pf.ui.datatable.datatable;
		
		var page = paginator.getCurrentPage();
		var totalpages = paginator.getTotalPages();
		var s = pf.screen;
		
		
		// if this is the last page 
		// if (page == totalpages && !pf.screen.limit) {
		if (page == totalpages && !$('#embed-frame').is(':visible')) {

			if((s.offset + s.pagesize) < s.resultcount) {
				// var lquerystring = querystring;
				// lquerystring += '&offset=';
				pf.newscreen.offset = s.offset + s.limit;
				var request = Y.ajax(
					'GET', 
					pf.js.buildQs(), 
					{ 
						success: function(o) { 
							pf.utils.initializeResponse(o.responseText);
							datatable.addRows(pf.ui.datatable.init.modified_results());
							pf.ui.sparklines.render();
						}, 
						failure: function (o) { alert ("failure 2"); }
					}
				);
			}
		}
	},
	handlesort: function (o) {
		
		if (typeof(o.key) === "undefined") {
		
			e = o;
			div = Y.getTarget(e);
			Y.preventDefault(e);
			
			if (div.nodeName == "TH" || $(div).closest("TH")) {
				
				$(div).closest("TH") ? id = $(div).closest("TH")[0].id : id = div.id;
				o = {key: id.split("-")[3]};
				$('html,body').animate({ scrollTop: $("html").offset().top }, { duration: 'fast', easing: 'swing'});
			
			}
			
		}
		
		// if we are re-sorting the currently sorted column
		// switch the sort dir
		if (o.key == pf.screen.sortkey) {
			if (pf.screen.sortdir == "asc") {
				pf.newscreen.sortdir = "desc";
			} else {
				pf.newscreen.sortdir = "asc";
			}
		// if we are sorting on a different column
		// sort on its default sort dir
		} else {
			pf.newscreen.sortkey = o.key;
			if (pf.newscreen.sortkey == "n" || pf.newscreen.sortkey == "w" || pf.newscreen.sortkey == "s" || pf.newscreen.sortkey == "y") {
				pf.newscreen.sortdir = "asc";
			} else {
				pf.newscreen.sortdir = pf.screen.criteria[o.key].sort;
			}
		}
		
		delete pf.newscreen.offset;	
		pf.js.getData(pf.newscreen);
		
	}, 
	updateresultcount: function (e) {
		
		paginator = pf.ui.datatable.paginator;
		
		var div = Y.get("result-count");
		var div2 = Y.get("paginator-frame");
		var page = paginator.getCurrentPage();
		var pagesize = paginator.getRowsPerPage();
		var totalpages = paginator.getTotalPages();
		
		var src = "";				

		pf.ui.sparklines.render();

		if (pf.screen.resultcount > 0) {
			
			// Calculate min result count range for this page
			// E.g. *61* of 86
			// 1 + ([Page 3]-1)*[30 results per page]
			// 1 + 2*30 = 61
			pagemin = 1 + (page-1)*pagesize;
						
			// Calculate max result count range for this page
			// E.g. 61 of *90*
			// [30 per page] + ([Page 3]-1)*[30]
			// 30 + 2*30 = 90

			pagemax = pagesize + (page-1)*pagesize;
			// if pagemax is larger than the actual count, use that (e.g. 86)
			if (pagemax > pf.screen.resultcount) {
				pagemax = pf.screen.resultcount;
			}
			
			src += "Viewing " + pagemin + "-" + pagemax + " of " + pf.screen.resultcount;
			
			pf.screen.mode.type == "t" ? src += " players" : "";
			pf.screen.mode.type == "w" ? src += " games" : "";
			pf.screen.mode.type == "s" ? src += " seasons" : "";
			
			// src += "</h3>";
			
			// src += pf.screen.resultcount + " results";

		} else {
			src += "No results";
		}

		div.innerHTML = src;
		div2.innerHTML = src;

	}		
	
};