var UDR_URL_JSON='http://oir.uark.edu/query?action=udr';
var UDR_URL_EXCEL='https://www2.uark.edu/web-apps/inrs/udrweb/query?action=udr&out=excel';

var VARIABLES_NAMES = {'none':'None',
		'gender':'Gender',
		'race':'Ethnicity',
		'acad_rank':'Rank',
		'acad_rank_aaup':'Rank AAUP',
		'academic_function': 'Academic Function',
		'appointment_location': 'Appointment Location',
		'appointment_period': 'Appointment Period',
		'attend_status': 'Full/Part Time',
		'career_type': 'Undergrad/Grad/Law',
		'acad_college': 'College',
		'acad_dept': 'Department',
		'faculty_category': 'Division',
		'geo_county': 'County',
		'geo_state': 'State',
		'tenure': 'Tenure',
		'tenure_recode': 'Tenured and Tenure Track/Not Tenured',
		'ua_primary_school': 'College',
		'ua_primary_dept': 'Department',
		'ua_level_recode': 'Level',
		'ua_student_status': 'Status',
		'ua_primary_plan': 'UA Plan',
		'ua_primary_award': 'UA Award',
		'degree_1_recode': 'Major',
		'award_1': 'Award',
		'adhe_dept_1': 'Department(AHEIS)',
		'college_1': 'College(AHEIS)',
		'ua_geo_country': 'Country',
		'age_ipeds': 'Age',
		'degree_intent': 'Degree Intent',
		'award_type': 'Degree/Certificate',
		'degree_level_recode': 'Level',
		'degree_1': 'Major',
		'ua_acad_plan_1': 'Plan',
		'cip_1': 'CIP',
		'cip_code_1': 'CIP Prefix',
		'campus': 'On/Off Campus',
		'college_course': 'College',
		'dept_reassign_code': 'Department',
		'course_level_recodec': 'Undergrad/Grad/Law',
		'course_level_recode': 'Undergrad/Master\'s/Doctoral',
		'course_level': 'Level',
		'cip': 'CIP',
		'cip_code': 'CIP Prefix',
		'funding_category': 'Funding Category'
	};

var UDR_TABLE={
	students: {first:1998, last:2009}, 
	employees: {first:2002, last:2008},	
	courses: {first:1998, last:2009},	
	degrees: {first:1999, last:2009},	
	students_detailed: //by calendar year
					   { 0: { 0: {first:1998, last:2008},   //summer II on schedule
							  1: {first:1998, last:2008},   //summer II off schedule
							  9: {first:1998, last:2008} }, //summer II on+off
						 1: { 0: {first:1998, last:2008},   //fall on schedule
							  1: {first:1998, last:2008},   //fall off schedule
							  9: {first:1998, last:2008} }, //fall on+off							  
						 2: { 0: {first:1999, last:2009},   //spring on schedule
							  1: {first:1999, last:2009},   //spring off schedule
							  9: {first:1999, last:2009} },	//spring on+off	  
						 3: { 0: {first:1999, last:2009},   //summer I on schedule
							  1: {first:1999, last:2008},   //summer I off schedule
							  9: {first:1999, last:2008} },	//summer I on+off
						//by academic year
						 9: { 0: {first:1999, last:2008},   //academic year on schedule
							  1: {first:1999, last:2008},   //academic year off schedule
							  9: {first:1999, last:2008} }	//academic year on+off
						}
};
	

function createGrid(config)
{
	var tbl = UDR_TABLE[config.table];
	if (typeof(config.total_width)=='undefined') {
		config.total_width = 900;
	}
	if (typeof(config.renderer)=='undefined') {
		config.renderer = rightAlign;
	}
	
		
   /*
   		 // add in some dummy descriptions and loaded flag
		for (var i = 0; i < data.length; i++) {
	    	data[i].desc = 'Lorem Ipsum';
	    	data[i]._is_loaded = true;
		}
		
		var expander = new Ext.grid.RowExpander({
	      tpl : new Ext.Template(
          '<p><b>Company:</b> {company}</p><br>',
          '<p><b>Summary:</b> {desc}</p>'
    	  )
    	});
*/
    // create the data store
	var cols=[{name: 'category'}];
    var pos=1;
    for (var i=tbl.first; i<=tbl.last; i++) {
    	cols[pos]={name: i+"", type: 'string'}; 
    	pos++;
    }
	cols.push({name: 'desc'});
	cols.push({name: '_id', type: 'int'});
	cols.push({name: '_parent', type: 'int'});
	cols.push({name: '_is_leaf', type: 'bool'});
    var record = Ext.data.Record.create(cols);
	
    var con_params;

    var semestersMenu;
    var scheduleMenu;
	
	function createVarMenu(pos) {
		var vars = config.variables_available;
		var menu = new Ext.menu.Menu();
		var butt_name; 
		if (config.variables_set[pos] == 'none') {
			butt_name = 'Select..'
		}
		else {
			butt_name = VARIABLES_NAMES[config.variables_set[pos]]
		}
		var split_butt = new Ext.Toolbar.SplitButton({
			   	text: butt_name,
			   	menu: menu
		});
	
		var i;
		for(i=0; i<vars.length; i++ ) {
	        var menu_item =  new Ext.menu.Item({text: VARIABLES_NAMES[vars[i]], uPos: pos, uVar:vars[i]});
	        menu_item.addListener('click',function (obj){
	        	var k = obj.initialConfig.uVar;
	        	config.variables_set[obj.initialConfig.uPos] =  k;
	        	if (k == 'none') { 
	        		split_butt.setText("Select..")
	        	}
	        	else {
	        		split_butt.setText(VARIABLES_NAMES[k]);
	        	}
	        	reconfig_params();
	        	store.reload();
	        });
	        menu.add(menu_item);
   		}
		return split_butt;
	}
	
    if (config.show_tbar) {
	    var toolbar = [];					
		if (config.show_semesters) {
			semestersMenu = new Ext.Toolbar.SplitButton({
						   	text: '',
						   	menu: new Ext.menu.Menu({
						        items: [
							        {text: 'Fall', handler: function() {
														config.semester = 1;
														if (config.show_schedule != true) {
															config.schedule = 0;
														}
														config.header_type = 'by_cal_year';
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Spring', handler: function() {
														config.semester = 2;						        					
														if (config.show_schedule != true) {
															config.schedule = 0;
														}
														config.header_type = 'by_cal_year';
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Summer I', handler: function() {
														config.semester = 3;						        					
														if (config.show_schedule != true) {
															config.schedule = 0;
														}
														config.header_type = 'by_cal_year';
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Summer II', handler: function() {
														config.semester = 0;
														if (config.show_schedule != true) {
															config.schedule = 0;
														}
														config.header_type = 'by_cal_year';
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Academic Year', handler: function() {
														config.semester = 9;
														config.schedule = 9;
														config.header_type = 'by_acad_year';
						   								reconfig_params();
						   								store.reload();
						   							}}
						        ]
						   	})
						});
			
			toolbar.push(semestersMenu);
		}
		if (config.show_schedule) {
			if (config.show_semesters) {
				toolbar.push(new Ext.Toolbar.Separator());
			}
			scheduleMenu = new Ext.Toolbar.SplitButton({
						   	text: '',
						   	menu: new Ext.menu.Menu({
						        items: [
							        {text: 'On Schedule', handler: function() {
														config.schedule = 0;						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Off Schedule', handler: function() {
														config.schedule = 1;						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'On And Off Schedule', handler: function() {
														config.schedule = 9;						        					
						   								reconfig_params();
						   								store.reload();
						   							}}
						        ]
						   	})
						});
			toolbar.push(scheduleMenu);
		}
		
		if (config.show_variables) {
			if (config.show_semesters || config.show_schedule) {
				toolbar.push(new Ext.Toolbar.Separator());
			}			
			toolbar.push(new Ext.Toolbar.TextItem('Categories:'));
			for (var i=0; i<config.variables_count; i++) {
				toolbar.push(createVarMenu(i));
				toolbar.push(new Ext.Toolbar.Separator());
			}
		}
		
		toolbar.push(new Ext.Toolbar.Fill());
		
		if (config.show_functions) {
			functionsMenu = new Ext.Toolbar.SplitButton({
						   	text: '',
						   	menu: new Ext.menu.Menu({
						        items: [
							        {text: 'Count', handler: function() {
														config.func = 'count';						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Mean', handler: function() {
														config.func = 'avg';						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Sum', handler: function() {
														config.func = 'sum';						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Min', handler: function() {
														config.func = 'min';						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'Max', handler: function() {
														config.func = 'max';						        					
						   								reconfig_params();
						   								store.reload();
						   							}},
							        {text: 'StDev', handler: function() {
														config.func = 'stdev';						        					
						   								reconfig_params();
						   								store.reload();
						   							}}
						        ]
						   	})
						});
			toolbar.push(functionsMenu);
		}
		
		toolbar.push(new Ext.Toolbar.Button({
							text : 'Excel',
							iconCls:'icon-excel', 							
							handler : function() {
								var url = UDR_URL_EXCEL;								
								for (var p in con_params) {
									if (typeof(con_params[p]) == 'object') {
										var parm = con_params[p];
										for (i=0; i<parm.length; i++) {
											url = url + "&" + p + "=" + parm[i];
										}
									}
									else {
										url = url + "&" + p + "=" + con_params[p];
									}
								}
								location.href = url;
							}
						}));					
		toolbar.push(new Ext.Toolbar.Button({
							text : 'Expand All',
							iconCls:'icon-expandall',
  							enableToggle: true,
       						pressed: config.expand_all,
							toggleHandler : function() {
									if (config.expand_all) {
										config.expand_all = false;
									}
									else {
										config.expand_all = true;
										store.data.each(function(record){
											if(!store.isLeafNode(record) && store.isLoadedNode(record)){store.expandNode(record);}
										});
									}
							}
						}));
    }
	
	
    
    var conn = new Ext.data.Connection({
    	url: UDR_URL_JSON,
		method:'GET',
		disableCaching:false
	});
    
    function reconfig_params() {
    	con_params = {};
    	var con_groups = [];
    	if (typeof(config.groups) != 'undefined') {
    		for (var i=0; i<config.groups.length; i++) {
    			con_groups.push(config.groups[i]);
    		}
    	}

    	if (typeof(config.variables_set) != 'undefined' ) {
    		var already_set = {'none':true};
    		for (var i=0; i<config.variables_count; i++) {
    			var v = config.variables_set[i];
    			if ( !(already_set[v] == true) ) {
    				already_set[v] = true;
    				con_groups.push(v);
    			}
    		}
    	}
    	
    	if (con_groups.length>0) {
    		 con_params['c'] = con_groups;
    	}
    	
    	var filterCount = 0;
    	if (typeof(config.semester) != 'undefined') {
	    	if (config.semester==9 ) {
	    		if (config.table in {'students_year':1, 'students_both':1,'students':1}) {
	    			config.table = 'students_year';
	    		}
	    	}
	    	else {
				filterCount++;
				con_params['f' + filterCount]=['semester',config.semester];
				if (config.table in {'students_year':1, 'students_both':1,'students':1}) {
		    		if (config.schedule==9 ) {
		    			config.table = 'students_both';
		    		}
		    		else {
		    			config.table = 'students';
		    		}
				}
	    	}
	    	if (config.schedule != 9 ) {
				filterCount++;
	   			con_params['f' + filterCount]=['schedule',config.schedule];
	    	}
    	}
    	if (! (typeof(config.filters) == 'undefined')) {
	    	for (i=0; i<config.filters.length; i++) {
				filterCount++;
	   			con_params['f' + filterCount]=config.filters[i];    		
			}
    	}
    	con_params['table'] = config.table;
    	con_params['value'] = config.value;
    	con_params['type'] = config.header_type;
    	if (typeof(config.func) != 'undefined') {
    		con_params['func'] = config.func;
    	}
    	if (config.no_tree) {  
    		con_params['out'] = 'ijson';
    	}
    	else {
    		con_params['out'] = 'json';
    	}
    	conn.extraParams = con_params;
    	
    	if (config.show_semesters) {
			if (config.semester == 0 ) {
				semestersMenu.setText('Summer II');
			}
			else if (config.semester == 1 ) {
				semestersMenu.setText('Fall');
			} 
			else if (config.semester == 2 ) {
				semestersMenu.setText('Spring');
			} 
			else if (config.semester == 3 ) {
				semestersMenu.setText('Summer I');
			} 
			else if (config.semester == 9 ) {
				semestersMenu.setText('Academic Year');
			} 
    	}
    	
    	if (config.show_schedule) {
			if (config.schedule == 0 ) {
				scheduleMenu.setText('On Schedule');
			}
			else if (config.schedule == 1 ) {			
				scheduleMenu.setText('Off Schedule');
			}
			else if (config.schedule == 9 ) {			
				scheduleMenu.setText('On And Off Schedule');
			}
    	}
    	
    	if (config.show_functions) {
    		if (config.func == 'count') {
    			functionsMenu.setText('Count');
    		}
    		else if (config.func == 'avg') {
    			functionsMenu.setText('Mean');
    		} 
    		else if (config.func == 'min') {
    			functionsMenu.setText('Min');
    		} 
    		else if (config.func == 'max') {
    			functionsMenu.setText('Max');
    		} 
    		else if (config.func == 'sum') {
    			functionsMenu.setText('Sum');
    		} 
    		else if (config.func == 'stdev') {
    			functionsMenu.setText('StDev');
    		} 
    	}
    }    
    
    reconfig_params();      
    
    var store = new Ext.ux.maximgb.treegrid.AdjacencyListStore({
    	autoLoad : true,
		reader: new Ext.data.JsonReader({id: '_id'}, record),
		proxy: new Ext.data.HttpProxy(conn)
		//proxy: new Ext.data.MemoryProxy(data2)
	});

   	// create the Grid
	function reconfig_header() {
	    var cols=[{id:'category',header: config.category_title, width: config.category_width, sortable: false, dataIndex: 'category'}];
	    var pos=1;
	    var first=tbl.first;
	    var last=tbl.last;
	    
	    if (typeof(config.schedule) != 'undefined' && typeof(config.semester) != 'undefined' 
	    && config.table in {'students':1,'students_both':1,'students_year':1,'courses':1} ) {
	    	first = UDR_TABLE.students_detailed[config.semester][config.schedule].first;
	    	last = UDR_TABLE.students_detailed[config.semester][config.schedule].last;
	    }
	    
	    for (var i=first; i<=last; i++) {
	    	cols[pos]={header: i+"", width: config.data_width, sortable: false, renderer: config.renderer, dataIndex: i+""}; 
	    	pos++;
	    }
	    return cols;
    }
	
	var grid;
	if (config.no_tree) {
		grid = new Ext.grid.GridPanel({
		  scrollOffset: 2,
		  collapsible: true,
		  collapsed: false,
		  tbar: toolbar,
		  store: store,	  
		  master_column_id : 'category',
		  columns:reconfig_header(),
		  stripeRows: true,
		  autoExpandColumn: 'category',
		  title: config.title,
		  root_title: 'All', 
		  //plugins: expander,
		  renderTo: config.renderTo,
		  height:600,
		  width: config.total_width,
		  viewConfig : { enableRowBody : true }	      
		});
	}
	else {
		grid = new Ext.ux.maximgb.treegrid.GridPanel({
		  scrollOffset: 2,
		  collapsible: true,
		  collapsed: false,
		  tbar: toolbar,
		  store: store,	  
		  master_column_id : 'category',
		  columns:reconfig_header(),
		  stripeRows: true,
		  autoExpandColumn: 'category',
		  title: config.title,
		  root_title: 'All', 
		  //plugins: expander,
		  renderTo: config.renderTo,
		  autoHeight: true,
		  width: config.total_width,
		  viewConfig : { enableRowBody : true }	      
		});
	}
	
	grid.config = config;
	store.on('load', function() {
		//update the column headers
		grid.getColumnModel().setConfig(reconfig_header());
		
		//expand nodes
		if (config.expand_all) {
			store.data.each(function(record){
				if(!store.isLeafNode(record) && store.isLoadedNode(record)){store.expandNode(record);}
			});
		}
		else {
			for (i=0; i<config.expandNodes.length; i++) {
				var record=store.data.map[config.expandNodes[i]];
				if(!store.isLeafNode(record) && store.isLoadedNode(record)){store.expandNode(record);}
			}
		}
	});
	
	grid.getSelectionModel().selectFirstRow();
	return grid;
}
	
function change(val) {
    if (val > 0) {
      val = '<span style="color:green;">' + val + '</span>';
	} 
	else if(val < 0) {
		val = '<span style="color:red;">' + val + '</span>';
    }
    return val;
}

function rightAlign(val) {
    return '<div style="text-align:right;">' + val + '</div>';
 }

 function twoDecimals(val) {
 	if (val != '-') {
    	return '<div style="text-align:right;">' + parseFloat(val).toFixed(2) + '</div>';    	
 	}
 	else {
 		return rightAlign(val);
 	}
 }
  
 
// example of custom renderer function
function pctChange(val) {
	if (val > 0) {
    	val = '<span style="color:green;">' + val + '%</span>';
	} 
	else if(val < 0) {
  		val = '<span style="color:red;">' + val + '%</span>';
    }
    return val;
}





function createGridTable(config)
{
    // create the data store
	var cols=[{name: 'emplid'}];
    var record = Ext.data.Record.create(cols);
	
    
    var conn = new Ext.data.Connection({
    	url: 'http://www.uark.edu/ua/ciprian/query?action=query&query=qa_terms&out=sjson',
		method:'GET',
		disableCaching:false
	});
    
    var store = new Ext.data.Store({
    	autoLoad : true,
		reader: new Ext.data.JsonReader({id:"_id"}, record),
		proxy: new Ext.data.HttpProxy(conn)
	});
	
	var grid;
	grid = new Ext.grid.GridPanel({
		  scrollOffset: 2,
		  collapsible: true,
		  collapsed: false,
		  store: store,	  
		  master_column_id : 'category',
		  columns:cols,
		  stripeRows: true,
		  autoExpandColumn: 'category',
		  title: config.title,
		  root_title: 'All', 
		  renderTo: config.renderTo,
		  width:1200,
		  height:600,
		  viewConfig : { enableRowBody : true }	      
		});
	
	return grid;
}