playerbio_tables = (function ($, window, untitled) {
  // Globals
  var bam            = window.bam,
      playerbio      = window.playerbio,
      clubProps,
      globals,
      flags,

  // bam namespaces
  DG                 = bam.datagrid,
  DT                 = bam.datetime,

  // DataGrid classes
  DataGrid           = DG.DataGrid,
  ExpandableDataGrid = DG.ExpandableDataGrid,

  // DataGrid config values
  NUMBER             = DG.DataType.Number,
  TEXT               = DG.DataType.Text,
  ASC                = DG.SortOrder.Asc,
  DESC               = DG.SortOrder.Desc,

  // Shortcuts to utility methods
  getDeepValue       = $.deep,
  ensureArray        = $.ensureArray,
  getQueryResults    = bam.util.getQueryResults,
  getQueryResult     = bam.util.getQueryResult,
  countQueryResults  = bam.util.countQueryResults,
  wrapQueryResults   = bam.util.wrapQueryResults,
  

  STAT_TYPE_HITTING  = '1',
  STAT_TYPE_PITCHING  = '2',
  STAT_TYPE_FIELDING  = '3',
  ERROR_LOADING_DATA = '<div class="error dataError">Error loading data</div>',

  MLB                       = 'mlb',
  MLB_SPORT_CODE            = "'mlb'",
  GAME_TYPE_SPRING_TRAINING = "'S'",
  GAME_TYPE_REGULAR_SEASON  = "'R'",
  GAME_TYPE_ALL_STAR_GAME   = "'A'",
  GAME_TYPE_FIRST_ROUND     = "'F'",
  GAME_TYPE_DIVISION_SERIES = "'D'",
  GAME_TYPE_LEAGUE_SERIES   = "'L'",
  GAME_TYPE_WORLD_SEASON    = "'W'",

  LOADING_MASK_CLASS_NAME = 'loadingMask',

  baseDatagridConfig = {
    tableClass:   'stats_table',
    showHeader:   true,
	noResultsMessage: 'This combination of filters produces no results.',
    dataType:     'json',
    sortable:     false,
    autoClassify: true
  },

  clubPropLookupHash,
  ticketingHash = {},

  /* DATA FIELD CONSTANTS ***************************************************/
  A                       = 'a',
  AB                      = 'ab',
  ACTIVE_SW               = 'active_sw',                // col_ex
  AO                      = 'ao',                       // col_ex
  AVG                     = 'avg',
  BB                      = 'bb',
  BK                      = 'bk',
  CG                      = 'cg',
  CS                      = 'cs',
  D				            = 'd',
  DESCRIPTION             = 'description',
  DISPLAY_GROUP           = 'display_group',
  DATE                    = 'date',
  DP                      = 'dp',
  E                       = 'e',
  ER                      = 'er',
  ERA                     = 'era',
  FPCT                    = 'fpct',
  G                       = 'g',
  GAME_DATE               = 'game_date',
  GAME_ID                 = 'game_id',
  GAME_PK                 = 'game_pk',
  GAME_TIME_ET            = 'game_time_et',
  GAME_TYPE               = 'game_type',
  GIDP                    = 'gidp',
  GO                      = 'go',                       // col_ex
  GO_AO                   = 'go_ao',
  GS                      = 'gs',
  H                       = 'h',
  H2B                     = 'h2b',
  H3B                     = 'h3b',
  HB                      = 'hb',
  HBP                     = 'hbp',
  HLD                     = 'hld',
  HOME_AWAY               = 'home_away',
  HR                      = 'hr',
  IBB                     = 'ibb',
  INN                     = 'inn',
  IP                      = 'ip',
  IR                      = 'ir',
  IRS                     = 'irs',
  L                       = 'l',
  LEAGUE_DISPLAY_ABBREV   = 'league_display_abbrev',    // col_ex
  LEAGUE_DISPLAY_FULL     = 'league_display_full',      // col_ex
  LEAGUE_DISPLAY_SHORT    = 'league_display_short',     // col_ex
  LEAGUE_ID               = 'league_id',                // col_ex
  NAME_DISPLAY_FIRST_LAST = 'name_display_first_last',  // col_ex
  NAME_DISPLAY_LAST_FIRST = 'name_display_last_first',  // col_ex
  NAME_LAST               = 'name_last',                // col_ex
  NP                      = 'np',
  OBP                     = 'obp',
  OPP                     = 'opp',
  OPP_PROBABLE_ERA        = 'opp_probable_era',
  OPP_PROBABLE_ID         = 'opp_probable_id',
  OPP_PROBABLE_L          = 'opp_probable_l',
  OPP_PROBABLE_SP         = 'opp_probable_sp',
  OPP_PROBABLE_W          = 'opp_probable_w',
  OPP_TEAM_ABBREV         = 'opp_team_abbrev',
  OPP_TEAM_DISPLAY_FULL   = 'opp_team_display_full',
  OPP_TEAM_DISPLAY_SHORT  = 'opp_team_display_short',
  OPP_TEAM_ID             = 'opp_team_id',
  OPS                     = 'ops',
  PB                      = 'pb',
  PITCHER                 = 'pitcher',
  PITCHER_ID              = 'pitcher_id',
  PLAYER                  = 'player',
  PLAYER_ID               = 'player_id',                
  PO                      = 'po',
  POSITION				  = 'position',
  POSITION_COUNT          = 'position_count',
  POSITION_SORT          = 'position_sort',
  R                       = 'r',
  RBI                     = 'rbi',
  RF                      = 'rf',
  S                       = 's',
  SAC                     = 'sac',
  SB                      = 'sb',
  SEASON                  = 'season',
  SF                      = 'sf',
  SHO                     = 'sho',
  SIT_DESC                = 'sit_desc',
  SITUATION               = 'situation',
  SLG                     = 'slg',
  SO                      = 'so',
  SIT_CODE                = 'sit_code',
  SORT_ORDER              = 'sort_order',
  SPLIT                   = 'situation',
  SV                      = 'sv',
  SVO                     = 'svo',
  T                      = 't',
  TC                      = 'tc',
  TB                      = 'tb',
  TBF                     = 'tbf',
  TEAM_ABBREV             = 'team_abbrev',
  TEAM                    = 'team_display_abbrev',
  TEAM_COUNT              = 'team_count',               // col_ex
  TEAM_DISPLAY_ABBREV     = 'team_display_abbrev',      // col_ex
  TEAM_DISPLAY_FULL       = 'team_display_full',        // col_ex
  TEAM_DISPLAY_SHORT      = 'team_display_short',       // col_ex
  TEAM_ID                 = 'team_id',
  TEAM_SEQ                = 'team_seq',
  W                       = 'w',
  WHIP                    = 'whip',
  WP                      = 'wp',

  /* COLUMN TITLE CONSTANTS *************************************************/

  EMPTY_TITLE             = '',
  A_TITLE                 = '<abbr title="Assists">A</abbr>',
  AB_TITLE                = '<abbr title="At Bats">AB</abbr>',
  AVG_TITLE               = '<abbr title="Batting Average">AVG</abbr>',
  BB_TITLE                = '<abbr title="Bases on Balls">BB</abbr>',
  CG_TITLE                = '<abbr title="Complete Games">CG</abbr>',
  CS_TITLE                = '<abbr title="Caught Stealing">CS</abbr>',
  D_TITLE                = '<abbr title="Doubles">2B</abbr>',
  DP_TITLE                = '<abbr title="Double Plays">DP</abbr>',
  E_TITLE                 = '<abbr title="Errors">E</abbr>',
  ERA_TITLE               = '<abbr title="Earned Run Average">ERA</abbr>',
  ER_TITLE                = '<abbr title="Earned Runs">ER</abbr>',
  FPCT_TITLE              = '<abbr title="Fielding Percentage">FPCT</abbr>',
  GAME_DATE_TITLE         = 'DATE',
  GAME_PK_TICKETING_TITLE = 'TICKETS',
  GAME_TIME_TITLE         = 'TIME',
  GO_AO_TITLE             = '<abbr title="Ground Outs/Air Outs">GO/AO</abbr>',
  GS_TITLE                = '<abbr title="Games Started">GS</abbr>',
  G_TITLE                 = '<abbr title="Games">G</abbr>',
  H2B_TITLE               = '<abbr title="Doubles">2B</abbr>',
  H3B_TITLE               = '<abbr title="Triples">3B</abbr>',
  HB_TITLE                = '<abbr title="Hit Batsmen">HB</abbr>',
  HBP_TITLE               = '<abbr title="Hit By Pitch">HBP</abbr>',
  HR_TITLE                = '<abbr title="Home Runs">HR</abbr>',
  H_TITLE                 = '<abbr title="Hits">H</abbr>',
  IBB_TITLE               = '<abbr title="Intentional Bases on Balls">IBB</abbr>',
  INN_TITLE               = '<abbr title="Innings At This Position">INN</abbr>',
  IP_TITLE                = '<abbr title="Innings Pitched">IP</abbr>',
  L_TITLE                 = '<abbr title="Losses">L</abbr>',
  NPS_TITLE               = '<abbr title="Number of Pitches-Strikes">NP-S</abbr>',
  OBP_TITLE               = '<abbr title="On-Base Percentage">OBP</abbr>',
  OPP_PROBABLE_SP_TITLE   = '<abbr title="Probable Starting Pitcher (Opponent)">PROB</abbr>',
  OPP_TITLE               = '<abbr title="Opponent">OPP</abbr>',
  OPS_TITLE               = '<abbr title="On-Base Plus Slugging">OPS</abbr>',
  PB_TITLE                = '<abbr title="Passed Ball">PB</abbr>',
  PO_TITLE                = '<abbr title="Putouts">PO</abbr>',
  PITCHER_TITLE           = 'PITCHER',
  PLAYER_TITLE            = 'PLAYER',
  POSITION_TITLE          = '<abbr title="Position">POS</abbr>',
  RBI_TITLE               = '<abbr title="Runs Batted In">RBI</abbr>',
  R_TITLE                 = '<abbr title="Runs">R</abbr>',
  RF_TITLE                = '<abbr title="Range Factor">RF</abbr>',
  S_TITLE                 = '<abbr title="Saves">S</abbr>',
  SAC_TITLE                 = '<abbr title="Sacrifice Bunts">SAC</abbr>',
  SB_TITLE                = '<abbr title="Stolen Bases">SB</abbr>',
  SF_TITLE                 = '<abbr title="Sacrifice Flies">SF</abbr>',
  SEASON_TITLE            = 'SEASON',
  SHO_TITLE               = '<abbr title="Shutouts">SHO</abbr>',
  SLG_TITLE               = '<abbr title="Slugging Percentage">SLG</abbr>',
  SO_TITLE                = '<abbr title="Strikeouts">SO</abbr>',
  SPLIT_TITLE             = 'SPLIT',
  SVO_TITLE               = '<abbr title="Save Opportunities">SVO</abbr>',
  SV_TITLE                = '<abbr title="Saves">SV</abbr>',
  T_TITLE                = '<abbr title="Triples">3B</abbr>',
  TB_TITLE                = '<abbr title="Total Bases">TB</abbr>',
  TC_TITLE                = '<abbr title="Total Chances (assists plus putouts plus errors)">TC</abbr>',
  TEAM_TITLE              = 'TEAM',
  WHIP_TITLE              = '<abbr title="Walks and Hits per Inning Pitched">WHIP</abbr>',
  W_TITLE                 = '<abbr title="Wins">W</abbr>',
  YEAR_TITLE              = 'YEAR',

  /* HELPER FUNCTIONS *******************************************************/

  rehash = function (data, newKey) {
    var ret = {},
        oldKey,
        datum;
    for (oldKey in data) {
      if (data.hasOwnProperty(oldKey)) {
        datum = data[oldKey];
        if (typeof(datum[newKey]) !== "undefined") {
          ret[datum[newKey]] = datum;
        }
      }
    }
    return ret;
  },

  getColumnDataFields = function (cfg) {
    var cols = cfg.columns,
        included = [],
        i, n;
    for (i = 0, n = cols.length; i < n; ++i) {
      included.push(cols[i].dataField);
    }
    return included;
  },

  /* DATAGRID DECORATORS ****************************************************/

  stripeEveryFiveRowsDecorator = function (tr) {
    if (this.index % 5 === 4) {
      $('td', tr).addClass('stripey');
    }
  },
  
 replaceNullValueDecorator = function(cell) {
 	if (cell.value === null || cell.value === "") {
      return '-';
    }
},
  
  stripeGameLogDecorator = function(tr) {
    if (this.cell(DATE)) {
		var prev_date_val,pval;
		var curr_row_index = parseInt(this.index,10);
		var prev_row_index = curr_row_index - 1;
		var curr_date_val = this.cell(DATE).value;
		var cval = curr_date_val.split(" ")[0];
		if (prev_row_index >= 0) {
			prev_display_val = this.parent.rows(prev_row_index).cell(DATE).value;
			pval = prev_display_val.split(" ")[0];
			if ((cval !== pval) && (cval !== "CAREER")) {
				$('td', tr).addClass('stripeyTop');
			}
		}
	}
  },
  
 stripeBySeasonDecorator = function(tr) {
    if (this.cell(SEASON)) {
		var prev_date_val,pval;
		var curr_row_index = parseInt(this.index,10);
		var prev_row_index = curr_row_index - 1;
		var cval = this.cell(SEASON).value;
		if (prev_row_index >= 0) {
			pval = this.parent.rows(prev_row_index).cell(SEASON).value;
			if ((cval !== pval) && (cval !== "CAREER")) {
				$('td', tr).addClass('stripeyTop');
			}
		}
	}
  },
  
stripeNewSplitsDecorator = function(tr) {
	if (this.cell(DISPLAY_GROUP)) {
		var prev_display_val;
		var curr_row_index = parseInt(this.index,10);
		var prev_row_index = curr_row_index - 1;
		var curr_display_val = this.cell(DISPLAY_GROUP).value;
		if (prev_row_index >= 0) {
			prev_display_val = this.parent.rows(prev_row_index).cell(DISPLAY_GROUP).value;
			if ((curr_display_val !== prev_display_val) && (curr_display_val !== "CAREER")) {
				$('td', tr).addClass('stripeyTop');
			}
		}
	}
  },

  expandableSeasonDecorator = function (cell) {
    if (cell.value === null) { return ""; }
    var toggle = ExpandableDataGrid.expandableDecorator.call(this, cell);
    return cell.value + toggle;
  },

  expandableTeamDisplayAbbrevDecorator = function (cell) {

    var prop,stat_text,stat_type,sit_code,url;

    if (cell.value === null) {
      return '';
    }
	stat_type = bbq_stats.getBbqVal("statType");
	if ((typeof(stat_type) === "undefined") || !(stat_type)) {
		stat_type = globals.statType;
	}
	switch(stat_type) {
		case "1": 
			stat_text = "hitting";
			break;
		case "2":
			stat_text = "pitching";
			break;
		case "3":
			stat_text = "fielding";
			break;
	}
	if ((typeof(this.cell(SIT_CODE)) !== "undefined") && this.cell(SIT_CODE)) {
		sit_code = this.cell(SIT_CODE).value;
	}
	
    // Lazy instantiation of clubProps for quick lookup
    clubPropLookupHash = clubPropLookupHash || rehash(clubProps, TEAM_ID);

    prop = clubPropLookupHash[this.cell(TEAM_ID).value];
	if (typeof(prop) === "undefined") {
		return cell.value;
	} else {
		url = '<a href="/stats/sortable.jsp?c_id=' + prop.club + '#playerType=ALL&season=' + this.cell(SEASON).value +'&statType='+stat_text;
	}
	if ((typeof(sit_code) !== "undefined") && sit_code) {
		url += "&split="+sit_code;
	}
	url += '">' + cell.value + '</a>';
	return url;
      
  },

  normalizeGameId = function (gameId) {
    return gameId.replace(/[\-\/]/g, '_');
  },

  makeGamedayLink = function (id, text) {
    return '<a href="javascript:void(launchGameday({gid:\'' + id + '\'}));">' + text + '</a>';
  },
  makeBoxscoreLink = function(id,text) {
  	return '<a href="/news/boxscore.jsp?gid='+id+'">'+text+'</a>';
  },
  
  gameLogSplitTotalDecoration = function (cell) {
  	var sit = this.cell(SITUATION).value;
	if (sit) {
		sit = sit + " Total";
		this.cell(DATE).value = sit;
	}
	return "";
  },
  

  //for last ten tab
  gameDateDecorator = function (cell) {
    if (this.cell(GAME_ID).value === null) { return cell.value; }
	var id = normalizeGameId(this.cell(GAME_ID).value);
	var date = DT.parseISODate(cell.value).toShortDate();
	  	if ((this.cell(GAME_TYPE).value === 'S') || (this.cell(GAME_TYPE).value === 'E') ) {
    	return makeBoxscoreLink(id, date);
	} else {
    	return makeGamedayLink(id, date);
	}
  },
  
  bvpPlayerDecorator = function (cell) {
  	var linky;
  	if (parseInt(globals.statType,10) === 2) {
		if (this.cell(PLAYER_ID).value === null) { 
			return cell.value; 
		} else {
			linky = "<a href='/team/player.jsp?player_id="+this.cell(PLAYER_ID).value+"#sectionType=bvp&statType=1&gameType=%27R%27&season="+bbq_stats.getBbqVal("season")+"'>"+cell.value+"</a>";
		}
	} else {
		if (this.cell(PITCHER_ID).value === null) { 
			return cell.value; 
		} else {
			linky = "<a href='/team/player.jsp?player_id="+this.cell(PITCHER_ID).value+"#sectionType=bvp&statType=2&gameType=%27R%27&season="+bbq_stats.getBbqVal("season")+"'>"+cell.value+"</a>";
		}
	}
	return linky;
  },
  
    //for game log
  gameDateLogDecorator = function (cell) {
    if (this.cell(GAME_ID).value === null) { return cell.value; }
	var id  = normalizeGameId(this.cell(GAME_ID).value);
	var date = this.cell(DATE).value;
    return makeGamedayLink(id, date);
  },
  
  npsDecorator = function (cell) {
    if (this.cell(S).value === null) { return cell.value; }
	var np  = this.cell(NP).value;
	var s = this.cell(S).value;
    return np+"-"+s;
  },

  // for upcoming tab
  gameDateShortDecorator = function (cell) {
    if (this.cell(GAME_ID).value === null) { return cell.value; }
    var id   = normalizeGameId(this.cell(GAME_ID).value),
        date = DT.parseISODate(cell.value).formatDate('MM/dd');
		
  	if ((this.cell(GAME_TYPE).value === 'S') || (this.cell(GAME_TYPE).value === 'E') ) {
    	return (date);
	} else {
    	return makeGamedayLink(id, date);
	}
  },

  gameTimeDecorator = function (cell) {
    var html = DT.parseISODate(cell.value).formatDate('h:mm a');
    return (html === ('3:33 am')) ? 'TBD' : html;
  },

  oppDecorator = function (cell) {
    return (this.cell(HOME_AWAY).value === 'A') ? '@' + cell.value : cell.value;
  },

  oppProbableSpDecorator = function (cell) {
    var id    = this.cell(OPP_PROBABLE_ID).value,
        w     = this.cell(OPP_PROBABLE_W).value,
        l     = this.cell(OPP_PROBABLE_L).value,
        era   = this.cell(OPP_PROBABLE_ERA).value,
        url   = '/team/player.jsp?player_id=' + id,
        title = w + '-' + l + ', ' + era + 'ERA';
    return '<a href="' + url + '" title="' + title + '">' + cell.value + '</a>';
  },

  gamePkTicketingDecorator = function (cell) {

    var html = '',
        ticketData,
        ticketLinks,
        ticketLink,
        location,
        i, n;

    if (typeof ticketingHash !== 'undefined' && (typeof(ticketingHash[cell.value]) !== "undefined")) {
      ticketData  = ticketingHash[cell.value];
	  if (typeof(ticketData.ticket_link)!=="undefined") {
      	ticketLinks = ensureArray(ticketData.ticket_link);
      	for (i = 0, n = ticketLinks.length; i < n; ++i) {
        	ticketLink = ticketLinks[i];
        	if (ticketLink.ticket_category === 'TICKETS') {
          	location = (ticketData.home_team_id === clubProps[globals.cid].team_id) ? 'home' : 'away';
          	html = '<a href="javascript:openTIXXWindow(\'' + ticketLink.tlink + '\', \'' + location + '\', [\'upcomingtab\',\'C1\']);" title="Buy Tickets"><img src="/images/schedule/icon_ticket.gif" class="dynTixLinkIcon TICKETS" alt="Buy Tickets" style="cursor:pointer;"/></a>';
          	break;
        	}
      	}
	 }
   }

    return html;
  },

  postSeasonDescriptionDecoratorRegExp = /[^A-Z]/g,

  postSeasonDescriptionDecorator = function (cell) {
    var abbr = cell.value.replace(postSeasonDescriptionDecoratorRegExp, '');
    return '<abbr title="' + cell.value + '">' + abbr + '</abbr>';
  },
  
  /** get current season status from org history **/
  is_inSeason = function() {
	var inSeason = false;
	var current_date = new Date();
	var month; 
	$.ajax({
		async: false,
		data : {
			"season" : globals.season,
			"sport_code" : "'mlb'",
			"org_id":"1"
		},
		dataType: "json", 
  		url: '/lookup/json/named.properties_info_events_season.bam',
		traditional:true,
  		success: function(data) {
    		var season_start_date_orig = data.properties_info_events_season.org_history.queryResults.row.first_date_seas;
			var season_end_date_orig = data.properties_info_events_season.org_history.queryResults.row.last_date_seas;
			var season_start_date_arr = season_start_date_orig.split(/T/);
			var season_end_date_arr = season_end_date_orig.split(/T/);
			var season_start_date_raw = season_start_date_arr[0];
			var season_end_date_raw = season_end_date_arr[0];
			var season_start_date_elem = season_start_date_raw.split(/-/);
			var season_end_date_elem = season_end_date_raw.split(/-/);
			var start = new Date(season_start_date_elem[0],(season_start_date_elem[1]-1),season_start_date_elem[2]);
			var end = new Date(season_end_date_elem[0],(season_end_date_elem[1]-1),season_end_date_elem[2]);

			if ((start < current_date) && (current_date < end)) {
				inSeason = true;
			}
			if (inSeason === false) {
				month = DT.getMonthFullName(season_end_date_elem[1]);
			} else {
				month = DT.getMonthFullName(current_date.getMonth() + 1);
			}
  		}
	});
	return month;
  },
  
  /******** SPRING TRAINING ***************/
  
  springTrainingConfig,
  springTrainingPanel,

  springTrainingGameTypes = [
    GAME_TYPE_SPRING_TRAINING
  ],

  springTrainingConfigFactory = function (statType) {

    var config = {
      datagridConfig:   $.extend({}, baseDatagridConfig)
    };

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_hitting_season.bam',
        colExProperty:   'mlb_individual_hitting_season.col_ex',
		springTrainingProperty: 'mlb_individual_hitting_season'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: SEASON, type: TEXT, title: EMPTY_TITLE },
		  { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE},
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: TB, type: NUMBER, title: TB_TITLE },
          { dataField: H2B, type: NUMBER, title: H2B_TITLE },
          { dataField: H3B, type: NUMBER, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE},
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ],
		springTrainingColEx: [
        	LEAGUE_DISPLAY_FULL,
			LEAGUE_DISPLAY_SHORT,
			LEAGUE_ID,
			PLAYER_ID,
			TEAM_DISPLAY_FULL,
			TEAM_DISPLAY_SHORT,
			GO,
			AO,
			HBP
      	]
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_pitching_season.bam',
        colExProperty:   'mlb_individual_pitching_season.col_ex',
		springTrainingProperty: 'mlb_individual_pitching_season'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: SEASON, type: TEXT, title: EMPTY_TITLE },
		  { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE},
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ],
		springTrainingColEx: [
			LEAGUE_DISPLAY_ABBREV,
			LEAGUE_DISPLAY_FULL,
			LEAGUE_DISPLAY_SHORT,
			LEAGUE_ID,
			PLAYER_ID,
			TEAM_DISPLAY_FULL,
			TEAM_DISPLAY_SHORT,
			IR,
			IRS,
			OBP,
			SAC,
			SF,
			NP,
			S,
			TBF,
			HLD,
			IBB,
			AB,
			GIDP,
			GO,
			AO,
			BK,
			WP
		]
      });
    }

    return config;
  },

  /******** ALL STAR ***************/
  
  allStarConfig,

  allStarGameTypes = [
    GAME_TYPE_ALL_STAR_GAME
  ],

  allStarConfigFactory = function (selected_stat_type) {
	if (!selected_stat_type) {
		selected_stat_type = statType;
	}
    var config = {
      datagridConfig:   $.extend({}, baseDatagridConfig)
    };

    // Hitting config
    if (selected_stat_type === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_bio_hitting_asg_summary.bam',
		allStarCareerProperty: 'mlb_bio_hitting_asg_summary.mlb_individual_hitting_career',
		allStarSeasonProperty: 'mlb_bio_hitting_asg_summary.mlb_individual_hitting_season_asg'
      });

      $.extend(config.datagridConfig, {
	  	caption: 'HITTING All Star Career Stats',
		rowDecorator: stripeEveryFiveRowsDecorator,
        columns: [
          { dataField: SEASON, type: TEXT, title: YEAR_TITLE },
		  { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE},
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: TB, type: NUMBER, title: TB_TITLE },
          { dataField: H2B, type: NUMBER, title: H2B_TITLE },
          { dataField: H3B, type: NUMBER, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });

    // Pitching config
    } else if (selected_stat_type === STAT_TYPE_PITCHING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_bio_pitching_asg_summary.bam',
		allStarCareerProperty: 'mlb_bio_pitching_asg_summary.mlb_individual_pitching_career',
		allStarSeasonProperty: 'mlb_bio_pitching_asg_summary.mlb_individual_pitching_season_asg'
      });

      $.extend(config.datagridConfig, {
	   	caption: 'PITCHING All Star Career Stats',
		rowDecorator: stripeEveryFiveRowsDecorator,
        columns: [
          { dataField: SEASON, type: TEXT, title: YEAR_TITLE },
		  { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE},
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
		  { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });
    } else {
		$.extend(config, {
        url:             '/lookup/json/named.mlb_bio_fielding_asg_summary.bam',
		allStarCareerProperty: 'mlb_bio_fielding_asg_summary.mlb_individual_fielding_career',
		allStarSeasonProperty: 'mlb_bio_fielding_asg_summary.mlb_individual_fielding_season_asg'
      });
	  
        $.extend(config.datagridConfig, {
		 rowDecorator: stripeBySeasonDecorator,
		 caption: 'FIELDING All Star Career Stats',
       	 columns: [
          	{ dataField: SEASON, type: NUMBER, sortState: ASC, title: YEAR_TITLE},
          	{ dataField: TEAM_ABBREV, type: TEXT, sortState: ASC, title: TEAM_TITLE },
		  	{ dataField: POSITION, type: TEXT, title: POSITION_TITLE },
          	{ dataField: G, type: NUMBER, title: G_TITLE },
          	{ dataField: GS, type: NUMBER, title: GS_TITLE },
          	{ dataField: INN, type: NUMBER, title: INN_TITLE },
          	{ dataField: TC, type: NUMBER, title: TC_TITLE },
          	{ dataField: PO, type: NUMBER, title: PO_TITLE },
          	{ dataField: A, type: NUMBER, title: A_TITLE },
          	{ dataField: E, type: NUMBER, title: E_TITLE },
          	{ dataField: DP, type: NUMBER, title: DP_TITLE },
          	{ dataField: PB, type: NUMBER, title: PB_TITLE },
          	{ dataField: SB, type: NUMBER, title: SB_TITLE },
          	{ dataField: CS, type: NUMBER, title: CS_TITLE },
          	{ dataField: RF, type: NUMBER, title: RF_TITLE },
          	{ dataField: FPCT, type: NUMBER, title: FPCT_TITLE },
			{ dataField: TEAM_ID, type: NUMBER, visible: false },
          	{ dataField: TEAM_SEQ, type: NUMBER, visible: false },
			{ dataField: POSITION_SORT, type: NUMBER, visible: false },
			{ dataField: POSITION_COUNT, type: NUMBER, visible: false }
        ]
      });
	}

    return config;
  },
  
  /* GAME LOG STATS *********************************************************/
  gameLogConfig,
  gameLogPanel,
  
  gameLogConfigFactory = function(statType) {
  	var config = {
		gameLogDatagridConfig : $.extend({},baseDatagridConfig, {
			sortable: true,
	 		//rowDecorator: stripeGameLogDecorator,
			onColumnSort: function() {
				this.parent.refresh();
			}
		}),
		colEx: [
			AO,
        	GO,
			OPP_TEAM_DISPLAY_FULL,
			OPP_TEAM_ID,
			OPP_TEAM_DISPLAY_SHORT
		]
	};
	
// Hitting config
    if (statType === STAT_TYPE_HITTING) {
     $.extend(config, {
        url:            '/lookup/json/named.mlb_individual_hitting_game_log_composed.bam',
		gameLogProperty: 'mlb_individual_hitting_game_log_composed.mlb_individual_hitting_game_log',
		gameLogSplitsProperty: 'mlb_individual_hitting_game_log_composed.mlb_individual_hitting_sits_season_total',
		gameLogTotalProperty: 'mlb_individual_hitting_game_log_composed.mlb_individual_hitting_season_total'
      });
      $.extend(config.gameLogDatagridConfig, {
        columns: [
          { dataField: SITUATION, type: TEXT, title: GAME_DATE_TITLE, decorator:expandableSeasonDecorator },
		  { dataField: HOME_AWAY, type: TEXT, title: EMPTY_TITLE,visible:false },
		  { dataField: GAME_ID, type: TEXT, title: EMPTY_TITLE, visible: false},
		  { dataField: DATE, type: TEXT, title: EMPTY_TITLE, visible:false/*decorator:gameLogSplitTotalDecoration*/ },
		  { dataField: OPP, type: TEXT, title: OPP_TITLE, decorator:oppDecorator },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: TB, type: NUMBER, title: TB_TITLE },
          { dataField: D, type: NUMBER, title: H2B_TITLE },
          { dataField: T, type: NUMBER, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
		  { dataField: HBP, type: NUMBER, title: HBP_TITLE },
		  { dataField: SAC, type: NUMBER, title: SAC_TITLE },
		  { dataField: SF, type: NUMBER, title: SF_TITLE }
        ]
      });
	 } else {
	  	//pitching
		$.extend(config, {
        url:            '/lookup/json/named.mlb_individual_pitching_game_log_composed.bam',
		gameLogProperty: 'mlb_individual_pitching_game_log_composed.mlb_individual_pitching_game_log',
		gameLogSplitsProperty: 'mlb_individual_pitching_game_log_composed.mlb_individual_pitching_sits_season_total',
		gameLogTotalProperty: 'mlb_individual_pitching_game_log_composed.mlb_individual_pitching_season_total'
      });
      $.extend(config.gameLogDatagridConfig, {
        columns: [
          { dataField: SITUATION, type: TEXT, title: GAME_DATE_TITLE, decorator:expandableSeasonDecorator },
		  { dataField: HOME_AWAY, type: TEXT, title: EMPTY_TITLE,visible:false },
		  { dataField: GAME_ID, type: TEXT, title: EMPTY_TITLE, visible: false},
		  { dataField: DATE, type: TEXT, title: EMPTY_TITLE, visible:false/*decorator:gameLogSplitTotalDecoration*/ },
		  { dataField: OPP, type: TEXT, title: OPP_TITLE, decorator:oppDecorator },
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
		  { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
		  { dataField: NP, type: NUMBER, title: NPS_TITLE,decorator:npsDecorator },
		  { dataField: S, type: NUMBER, title: EMPTY_TITLE, visible: false},
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, title: WHIP_TITLE},
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });
	 }
	 return config;
  },
  
  
  /* CAREER & SUMMARY STATS *************************************************/

  careerSummaryConfig,
  careerSummaryPanel,
  summaryPanel,
  careerPanel,

  careerSummaryConfigFactory = function (statType) {

    var config = {
      summaryDatagridConfig: $.extend({}, baseDatagridConfig),
      careerDatagridConfig: $.extend({}, baseDatagridConfig, {
        sortable: true,
        onColumnSort: function () {
          this.parent.refresh();
        }
      }),
      totalColEx: [
        ACTIVE_SW,
        AO,
        GO,
        NAME_DISPLAY_FIRST_LAST,
        NAME_DISPLAY_LAST_FIRST,
        NAME_LAST,
        PLAYER_ID,
        TEAM_COUNT,
        TEAM_DISPLAY_ABBREV,
        TEAM_ID,
        TEAM_SEQ
      ],
      seasonColEx: [
        LEAGUE_DISPLAY_ABBREV,
        LEAGUE_DISPLAY_FULL,
        LEAGUE_DISPLAY_SHORT,
        LEAGUE_ID,
        PLAYER_ID,
        TEAM_DISPLAY_FULL,
        TEAM_DISPLAY_SHORT
      ],
      careerColEx: [
        AO,
        GO,
        PLAYER_ID,
        SEASON
      ]
    };

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:                 '/lookup/json/named.mlb_bio_hitting_summary.bam',
        seasonSportcode:     'mlb_individual_hitting_season_sportcode.season',
        totalProperty:       'mlb_bio_hitting_summary.mlb_individual_hitting_season_total',
        seasonProperty:      'mlb_bio_hitting_summary.mlb_individual_hitting_season',
        careerProperty:      'mlb_bio_hitting_summary.mlb_individual_hitting_career',
        totalColExProperty:  'mlb_individual_hitting_season_total.col_ex',
        seasonColExProperty: 'mlb_individual_hitting_season.col_ex',
        careerColExProperty: 'mlb_individual_hitting_career.col_ex'
      });

      $.extend(config.summaryDatagridConfig, {
        columns: [
          { dataField: SEASON, type: TEXT, title: EMPTY_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: TB, type: NUMBER, title: TB_TITLE },
          { dataField: H2B, type: NUMBER, title: H2B_TITLE },
          { dataField: H3B, type: NUMBER, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });

      $.extend(config.careerDatagridConfig, {
	  	rowDecorator: stripeEveryFiveRowsDecorator,
        columns: [
          { dataField: SEASON, type: NUMBER, sortState: ASC, title: YEAR_TITLE, decorator: expandableSeasonDecorator },
          { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE, decorator: expandableTeamDisplayAbbrevDecorator },
          { dataField: G, type: NUMBER, sortState: DESC, title: G_TITLE },
          { dataField: AB, type: NUMBER, sortState: DESC, title: AB_TITLE },
          { dataField: R, type: NUMBER, sortState: DESC, title: R_TITLE },
          { dataField: H, type: NUMBER, sortState: DESC, title: H_TITLE },
          { dataField: TB, type: NUMBER, sortState: DESC, title: TB_TITLE },
          { dataField: H2B, type: NUMBER, sortState: DESC, title: H2B_TITLE },
          { dataField: H3B, type: NUMBER, sortState: DESC, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, sortState: DESC, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, sortState: DESC, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, sortState: DESC, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, sortState: DESC, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, sortState: DESC, title: SO_TITLE },
          { dataField: SB, type: NUMBER, sortState: DESC, title: SB_TITLE },
          { dataField: CS, type: NUMBER, sortState: DESC, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, sortState: DESC, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, sortState: DESC, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, sortState: DESC, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, sortState: DESC, title: OPS_TITLE },
          { dataField: GO_AO, type: NUMBER, sortState: DESC, title: GO_AO_TITLE },
          { dataField: TEAM_ID, type: NUMBER, visible: false },
          { dataField: TEAM_SEQ, type: NUMBER, visible: false }
        ]
      });

    // Pitching config
    } else if (statType === STAT_TYPE_PITCHING) {

      $.extend(config, {
        url:                 '/lookup/json/named.mlb_bio_pitching_summary.bam',
        seasonSportcode:     'mlb_individual_pitching_season_sportcode.season',
        totalProperty:       'mlb_bio_pitching_summary.mlb_individual_pitching_season_total',
        seasonProperty:      'mlb_bio_pitching_summary.mlb_individual_pitching_season',
        careerProperty:      'mlb_bio_pitching_summary.mlb_individual_pitching_career',
        totalColExProperty:  'mlb_individual_pitching_season_total.col_ex',
        seasonColExProperty: 'mlb_individual_pitching_season.col_ex',
        careerColExProperty: 'mlb_individual_pitching_career.col_ex'
      });

      $.extend(config.summaryDatagridConfig, {
        columns: [
          { dataField: SEASON, type: TEXT, title: EMPTY_TITLE },
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
		  { dataField: IBB, type: NUMBER, sortState: DESC, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });

      $.extend(config.careerDatagridConfig, {
	  	rowDecorator: stripeEveryFiveRowsDecorator,
        columns: [
          { dataField: SEASON, type: NUMBER, sortState: ASC, title: YEAR_TITLE, decorator: expandableSeasonDecorator },
          { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE, decorator: expandableTeamDisplayAbbrevDecorator },
          { dataField: W, type: NUMBER, sortState: DESC, title: W_TITLE },
          { dataField: L, type: NUMBER, sortState: DESC, title: L_TITLE },
          { dataField: ERA, type: NUMBER, sortState: DESC, title: ERA_TITLE },
          { dataField: G, type: NUMBER, sortState: DESC, title: G_TITLE },
          { dataField: GS, type: NUMBER, sortState: DESC, title: GS_TITLE },
          { dataField: CG, type: NUMBER, sortState: DESC, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, sortState: DESC, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, sortState: DESC, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, sortState: DESC, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, sortState: DESC, title: IP_TITLE },
          { dataField: H, type: NUMBER, sortState: DESC, title: H_TITLE },
          { dataField: R, type: NUMBER, sortState: DESC, title: R_TITLE },
          { dataField: ER, type: NUMBER, sortState: DESC, title: ER_TITLE },
          { dataField: HR, type: NUMBER, sortState: DESC, title: HR_TITLE },
          { dataField: HB, type: NUMBER, sortState: DESC, title: HB_TITLE },
          { dataField: BB, type: NUMBER, sortState: DESC, title: BB_TITLE },
		  { dataField: IBB, type: NUMBER, sortState: DESC, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, sortState: DESC, title: SO_TITLE },
          { dataField: AVG, type: NUMBER, sortState: DESC, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, sortState: DESC, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, sortState: DESC, title: GO_AO_TITLE },
          { dataField: TEAM_ID, type: NUMBER, visible: false },
          { dataField: TEAM_SEQ, type: NUMBER, visible: false }
        ]
      });
    } else if (statType === STAT_TYPE_FIELDING) {
		$.extend(config, {
			url:                 '/lookup/json/named.mlb_bio_fielding_summary.bam',
			seasonSportcode:      '',
        	seasonProperty:      'mlb_bio_fielding_summary.mlb_individual_fielding_season',
        	careerProperty:      'mlb_bio_fielding_summary.mlb_individual_fielding_career',
			totalProperty:       'mlb_bio_fielding_summary.mlb_individual_fielding_season_total',
        	totalColExProperty:  'mlb_individual_fielding_season_total.col_ex',
        	seasonColExProperty: 'mlb_individual_fielding_season.col_ex',
        	careerColExProperty: 'mlb_individual_fielding_career.col_ex'
     	 });
		 
		$.extend(config.summaryDatagridConfig, {
       	 columns: [
          	{ dataField: SEASON, type: NUMBER, sortState: ASC, title: SEASON_TITLE},
		  	{ dataField: POSITION, type: TEXT, title: POSITION_TITLE },
          	{ dataField: G, type: NUMBER, title: G_TITLE },
          	{ dataField: GS, type: NUMBER, title: GS_TITLE },
          	{ dataField: INN, type: NUMBER, title: INN_TITLE },
          	{ dataField: TC, type: NUMBER, title: TC_TITLE },
          	{ dataField: PO, type: NUMBER, title: PO_TITLE },
          	{ dataField: A, type: NUMBER, title: A_TITLE },
          	{ dataField: E, type: NUMBER, title: E_TITLE },
          	{ dataField: DP, type: NUMBER, title: DP_TITLE },
          	{ dataField: PB, type: NUMBER, title: PB_TITLE },
          	{ dataField: SB, type: NUMBER, title: SB_TITLE },
          	{ dataField: CS, type: NUMBER, title: CS_TITLE },
          	{ dataField: RF, type: NUMBER, title: RF_TITLE },
          	{ dataField: FPCT, type: NUMBER, title: FPCT_TITLE },
			{ dataField: POSITION_SORT, type: NUMBER, visible: false }
        	]
      	});

      	$.extend(config.careerDatagridConfig, {
		 rowDecorator: stripeBySeasonDecorator,
       	 columns: [
          	{ dataField: SEASON, type: NUMBER, sortState: ASC, title: YEAR_TITLE, decorator: expandableSeasonDecorator },
          	{ dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE, decorator: expandableTeamDisplayAbbrevDecorator },
		  	{ dataField: POSITION, type: TEXT, title: POSITION_TITLE },
          	{ dataField: G, type: NUMBER, title: G_TITLE },
          	{ dataField: GS, type: NUMBER, title: GS_TITLE },
          	{ dataField: INN, type: NUMBER, title: INN_TITLE },
          	{ dataField: TC, type: NUMBER, title: TC_TITLE },
          	{ dataField: PO, type: NUMBER, title: PO_TITLE },
          	{ dataField: A, type: NUMBER, title: A_TITLE },
          	{ dataField: E, type: NUMBER, title: E_TITLE },
          	{ dataField: DP, type: NUMBER, title: DP_TITLE },
          	{ dataField: PB, type: NUMBER, title: PB_TITLE },
          	{ dataField: SB, type: NUMBER, title: SB_TITLE },
          	{ dataField: CS, type: NUMBER, title: CS_TITLE },
          	{ dataField: RF, type: NUMBER, title: RF_TITLE },
          	{ dataField: FPCT, type: NUMBER, title: FPCT_TITLE },
			{ dataField: TEAM_ID, type: NUMBER, visible: false },
          	{ dataField: TEAM_SEQ, type: NUMBER, visible: false },
			{ dataField: POSITION_COUNT, type: NUMBER, visible: false },
			{ dataField: POSITION_SORT, type: NUMBER, visible: false }
        	]
      	});
	}
    return config;
  },

  mergeTotalsAndPartials = function (totals, partials) {

    var rows = ExpandableDataGrid.mergeParentsAndChildren(totals, partials, SEASON, SEASON,[TEAM,TEAM_ID], function (idx, partial) {
      return partial[TEAM_SEQ] - 1;
    }),
    i, n,
    row,
    children,
    child;

    // Extend row with team_display_abbrev if team_display_abbrev is unique
    for (i = 0, n = rows.length; i < n; ++i) {
      row      = rows[i];
      children = row.children || [];
      if (children.length === 1) {
        child = children[0];
        row[TEAM] = child[TEAM];
        row[TEAM_ID] = child[TEAM_ID];
      }
    }

    return rows;
  },
  
  mergeGameLogParentsAndChildren = function(parents, children, parentProp, childProp, sortFn) {
	var dateObj = {
		"JAN" : "January",
		"FEB" : "February",
		"MAR" : "March",
		"APR" : "April",
		"MAY" : "May",
		"JUN" : "June",
		"JUL" : "July",
		"AUG" : "August",
		"SEP" : "September",
		"OCT" : "October",
		"NOV" : "November",
		"DEC" : "December"
	};
    var hash = {},
        sortFnIsFunction = (typeof sortFn === 'function'),
        idx,
        parent,
        child,
		modifiedDate,
		mDate,
		hk,
		hKey,
        hashKey,
		id,
		date,
		h=0,
        merged = [],
        childrenColumnName = 'children',
        i, n;

    for (i = 0, n = children.length; i < n; ++i) {

      child = children[i];
	  mDate =  child[childProp];
	  hKey = child[childProp];
	  hk = hKey.split(" ")[0];
      hashKey = dateObj[hk];
	  
	  if (child.game_id !== null) { 
			id = normalizeGameId(child.game_id);
	  		if ((child.game_type === 'S') || (child.game_type === 'E') ) {
    			modifiedDate = makeBoxscoreLink(id, mDate);
			} else {
    			modifiedDate = makeGamedayLink(id, mDate);
			}
		}
      child.situation = modifiedDate;

	  
      if (typeof(hash[hashKey]) === "undefined") {
        hash[hashKey] = [];
		h=0;
      } else {
	  	h++;
	  }

      //idx = sortFnIsFunction ? sortFn(i, child) : i;
	  idx = parseInt(hKey.split(" ")[1],10);

      hash[hashKey][h] = child;
    }

    // Extend or append children to parents
    for (i = 0, n = parents.length; i < n; ++i) {

      parent = $.extend(true, {}, parents[i]); // Non-destructive

      parent[childrenColumnName] = hash[parent[parentProp]];

      merged.push(parent);
    }

    return merged;
  },
  
 mergeFieldingParentsAndChildren = function(parents, children, parentProp, childProp, sortFn) {

    var hash = {},
        sortFnIsFunction = (typeof sortFn === 'function'),
        idx,
        parent,
		p, 
		pos,
		position,
		h,
		team_seq,
        child,
		prop,
        hashKey,
        merged = [],
		placeholder = [],
        childrenColumnName = 'children',
        // @todo add paramater for custom col name
        i, n;
		
		 for (i = 0; i<parents.length; i++) {
		 	p = parents[i];
			if (p.team_count > 1) {
				hashKey = p[childProp];
				if (typeof(hash[hashKey]) === "undefined") {
        			hash[hashKey] = [];
      			}
			}
		 }
		 for (i=0; i< children.length; i++) {
		 	child = children[i];
			prop = child[childProp];
			if (typeof(hash[prop]) !== "undefined") {
				pos = child.position;
				if (typeof(hash[prop][pos]) === "undefined") {
					hash[prop][pos] = [];
				}
				team_seq = child.team_seq;
				hash[prop][pos][team_seq] = child;
			} else {
				merged.push(child);
			}
		 }
		 
		 for (h in hash) {
		 	for (position in hash[h]) {
				placeholder = hash[h][position];
				placeholder = $.grep(placeholder,function(n,i){
    				return(n);
				});
				if (placeholder.length === 1) {
					merged.push(placeholder[0]);
				} else {
					//placeholder.sort(sortFn);
					 for (i = 0, n = parents.length; i < n; ++i) {
					 	parent = $.extend(true, {}, parents[i]);
						if ((parent.season === placeholder[0].season) && (parent.position === placeholder[0].position) ) {
      						parent.children = placeholder;
							merged.push(parent);
						}
					 }
				}
			}
		 }

    return merged;
  },
  
  mergeFieldingTotalsAndPartials = function (totals, partials) {

    var rows = mergeFieldingParentsAndChildren(totals, partials, 'season','season', function sortfunc(a, b){
		return (a.team_seq - b.team_seq);
	});
    return rows;
  },
  
   mergeGameLogTotalsAndPartials = function (totals, partials) {

    var rows = mergeGameLogParentsAndChildren(totals, partials, 'situation','date', function sortfunc(a, b){
		return (a - b);
	});
   /* i, n,
    row,
    children,
    child;

    // Extend row with team_display_abbrev if team_display_abbrev is unique
    for (i = 0, n = rows.length; i < n; ++i) {
      row      = rows[i];
      children = row.children || [];
      if (children.length === 1) {
        child = children[0];
        row[TEAM] = child[TEAM];
        row[TEAM_ID] = child[TEAM_ID];
      }
    }
*/
    return rows;
  },
  
     handleLoadGameLogSuccess = function (data,statType) {

      var cfg = gameLogConfig || gameLogConfigFactory(statType);

      var gameLogTable,
        i, n, j,
		row_len,
		gl_data,
		row_arr,
		data_arr,
		d_arr_len,
		rows;
	var year = getQueryResults(data, cfg.gameLogTotalProperty)[0];
	var totals = getQueryResults(data, cfg.gameLogSplitsProperty);
	var partials = getQueryResults(data, cfg.gameLogProperty);
	var merged = mergeGameLogTotalsAndPartials(totals, partials);
	var selected_game_type = bbq_stats.getBbqVal("gameType");
	var selected_game_type_text = $('#stats_nav_game_type option:selected').text();
	if (typeof(selected_game_type) === "undefined") {
		selected_game_type = "'R'";
		$("#stats_nav_game_type option[value='"+GAME_TYPE_REGULAR_SEASON+"']").attr("selected","selected");
		//$("#stats_nav_game_type").selectmenu();
	}
	var selected_year = bbq_stats.getBbqVal("season");
	if (!selected_year) {
		selected_year = globals.season;
	}
	/*$.extend(cfg.gameLogDatagridConfig, {
		caption:'GAME LOG: ' + selected_game_type_text + ' ' + selected_year
	 });
	 */
		if (typeof year === 'undefined') {
      		year = {};
    	}
		if (merged.length > 0) {
			year.situation = 'YEAR';
		}
		data_arr = merged;
		d_arr_len = data_arr.length;
		if (d_arr_len > 0) {
			for (i=0;i<d_arr_len;i++) {
				for (j in data_arr[i]) {
					if (!data_arr[i][j]) {
						data_arr[i][j] = "-";
					}
				}
			}
		}
      	gameLogTable = new ExpandableDataGrid(cfg.gameLogDatagridConfig);
      	gameLogTable.loadData({
       	 data:     wrapQueryResults(data_arr),
        	callback: function () {
				gameLogTable.insertFooterRow(year);
         	 	gameLogTable.render('gameLogPanel');
        	}
      	});
	 
	//}
  },
  handleLoadGameLogError = function (yr) {
  	gameLogPanel.html("<div class='error dataError'>No stats available for " + yr + ", please choose another year.</div>");
	gameLogPanel.show();
  },

  handleLoadGameLogStatsComplete = function () {
  	    gameLogPanel.removeClass(LOADING_MASK_CLASS_NAME);
		$("#gameLogPanel table").show();
		$("#gameLogPanel table.stats_table td span.expandable_toggle:last").trigger('click');
  },
  
  /***********bvp************/
  
 handleLoadBvpSuccess = function (data) {
      var cfg = bvpConfig || bvpConfigFactory(globals.statType);
	  
      var bvpTable,
	    totals   = getQueryResults(data, cfg.totalProperty)[0],
        rows = getQueryResults(data, cfg.individualProperty),
        summary  = [],
        i, n, j,
		row_len,
		data_arr, d_arr_len;
    	if (typeof(totals) === 'undefined') {
      		totals = {};
    	}
		if ((rows.length > 1) && (!($.isEmptyObject(totals)))) {
			if (parseInt(globals.statType,10) !== 2) {
    			totals.pitcher = 'TOTAL';
			} else {
				totals.player = 'TOTAL';
			}
		}

		data_arr = rows;
		d_arr_len = data_arr.length;
		if (d_arr_len > 0) {
			for (i=0;i<d_arr_len;i++) {
				for (j in data_arr[i]) {
					if (!data_arr[i][j]) {
						data_arr[i][j] = "-";
					}
				}
			}
		}
      	bvpTable = new ExpandableDataGrid(cfg.bvpDatagridConfig);

      	bvpTable.loadData({
       	 data:     wrapQueryResults(data_arr),
        	callback: function () {
				if (!($.isEmptyObject(totals))) {
					bvpTable.insertFooterRow(totals);
				}
         	 	bvpTable.render('bvpPanel');
				bvpPanel.show();
        	}
      	});
  },
  
  
 handleLoadBvpError = function (yr) {
  	bvpPanel.html("<div class='error dataError'>No stats available for " + yr + ", please choose another year.</div>");
	bvpPanel.show();
  },

  handleLoadBvpComplete = function () {
  	    bvpPanel.removeClass(LOADING_MASK_CLASS_NAME);
		$("#bvpPanel table").show();
  },
  

  handleLoadSummaryDataSuccess = function (data) {

    var summaryTable = new DataGrid(careerSummaryConfig.summaryDatagridConfig);

    summaryTable.loadData({
      data:     data,
      callback: function () {
        summaryTable.render('stats_summary_table');
        summaryPanel.show();
      }
    });
  },
  
  loadCareerFieldingData = function() {
	var fieldingTable = new ExpandableDataGrid(careerSummaryConfig.careerFieldingDatagridConfig);
  	fieldingTable.loadData({
      dataset:     careerSummaryConfig.fieldingProperty,
      callback: function () {
        fieldingTable.render('stats_summary_table');
        summaryPanel.show();
      }
    });
  },
  
  
   handleLoadSpringTrainingSuccess = function (data) {

      var cfg = springTrainingConfig,
	    first_season,
        springTrainingTable,
        i, n, j,
		row_len,
		st_data,
		data_arr,
		d_arr_len,
		row_arr,
		rows;

	  first_season = parseInt(globals.season,10) - 2;
	  rows = $.deep(data, cfg.springTrainingProperty);
	  if (rows.queryResults.totalSize > 0) {
	 	 row_arr = ensureArray(rows.queryResults.row);
	  	row_len = row_arr.length;
	  	st_data = [];
	 	 for (i=0;i<row_len;i++) {
	  		if (row_arr[i].season >= first_season) {
				st_data.push(row_arr[i]);
			}
	 	 }
	  
	  	data_arr = st_data;
		d_arr_len = data_arr.length;
		if (d_arr_len > 0) {
			for (i=0;i<d_arr_len;i++) {
				for (j in data_arr[i]) {
					if (!data_arr[i][j]) {
						data_arr[i][j] = "-";
					}
				}
			}
		}
      	springTrainingTable = new DataGrid(cfg.datagridConfig);

      	springTrainingTable.loadData({
       	 data:     wrapQueryResults(data_arr),
        	callback: function () {
         	 	springTrainingTable.render('spring_training_stats');
        	}
      	});
	 
      		$('#spring_training_stats_year').text('SPRING TRAINING STATS -- LAST THREE SEASONS');
      		springTrainingPanel.show();
	}
  },
  handleLoadSpringTrainingStatsError = function () {},

  handleLoadSpringTrainingStatsComplete = function () {},
  
  loadSpringTrainingStats = function (playerId, statType, season) {
    springTrainingConfig = springTrainingConfig || springTrainingConfigFactory(statType);
    // Configure request
    var cfg = springTrainingConfig,
        params = {
          game_type:  springTrainingGameTypes,
          player_id:  playerId,
		  sort_by: 'season_asc'
        };

    // Optimize query
    params[cfg.colExProperty] = cfg.datagridConfig.springTrainingColEx;

    $.ajax({
      url:      cfg.url,
      data:     params,
      dataType: 'json',
      success:  handleLoadSpringTrainingSuccess,
      error:    handleLoadSpringTrainingStatsError,
      complete: handleLoadSpringTrainingStatsComplete,
	  traditional:true
    });
  },
  /*************** ALL STAR ***********/
  
  handleLoadAllStarSuccess = function (data) {
	$("#additional_stats_nav").hide();
    var allStarTable,career,
        cfg      = allStarConfig,
        allstar   = getQueryResults(data, cfg.allStarSeasonProperty),
        summary  = [],
        season   = parseInt(globals.season, 10),
        i, n, j;
	var stat_type_text = bbq_stats.getBbqVal("statType");
	if ((parseInt(stat_type_text,10) === 3) && (parseInt(globals.statType,10) ===1))  {
		career   = getQueryResults(data, cfg.allStarCareerProperty);
	} else {
		career   = getQueryResults(data, cfg.allStarCareerProperty)[0];
	}

    if (typeof career === 'undefined') {
      career = {};
    }
	
	if (allstar.length > 0) {
    	career.season = 'CAREER';
	}
    	allStarTable = new DataGrid(cfg.datagridConfig);

   		allStarTable.loadData({
     	 data:     wrapQueryResults(allstar),
      	callback: function () {
       	 	if (!($.isArray(career)) || (career.length === 1)) {
				if ($.isArray(career)) {
					career[0].season = "CAREER";
					allStarTable.insertFooterRow(career[0]);
				} else {
        			allStarTable.insertFooterRow(career);
				}
			} else {
				for (i=0;i<career.length;i++) {
					career[i].season = "CAREER";
					allStarTable.insertFooterRow(career[i]);
				}
			}
        	allStarTable.sortColumn(0, DESC);
        	allStarTable.render('careerPanel');
        	careerPanel.show();
      	}
    	});
  },
  
  handleLoadAllStarError = function () {
    careerPanel.html(ERROR_LOADING_DATA);
	careerPanel.show();
  },

  handleLoadAllStarComplete = function () {
    careerPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },
  
  /************CAREER*************/
  handleLoadCareerStatsSuccess = function (data) {
		$("#additional_stats_nav").hide();
    var careerTable, merged, career,
        cfg      = careerSummaryConfig,
        totals   = getQueryResults(data, cfg.totalProperty),
        partials = getQueryResults(data, cfg.seasonProperty),
        summary  = [],
        season   = parseInt(globals.season, 10),
        i, n, j, data_arr, d_arr_len;
    var game_type_text = $("#stat_type_nav select#stats_nav_game_type option:selected").text();
	//var stat_type_text = $("#stat_type_nav input[name='stats_nav_type']:checked").val().toUpperCase();
	var stat_type = bbq_stats.getBbqVal("statType");
	if ((typeof(stat_type) === "undefined") || !(stat_type)) {
		stat_type = globals.statType;
	}

		if ((parseInt(stat_type,10) === 3) && (parseInt(globals.statType,10) ===1))  {
			merged   = mergeFieldingTotalsAndPartials(totals, partials);
			career   = getQueryResults(data, cfg.careerProperty);
		} else {
			merged   = mergeTotalsAndPartials(totals, partials);
			career   = getQueryResults(data, cfg.careerProperty)[0];
		}
	
    if (typeof career === 'undefined') {
      career = {};
    }

	if (merged.length > 0) {
   	 career.season = 'CAREER';
	 if (flags.is_historical !== 'true') {
      for (i = 0, n = merged.length; i < n; ++i) {
        if (merged[i].season === globals.season) {
          summary.push($.extend({}, merged[i], { season: 'SEASON' }));
          break;
        }
      }

   		if (($.isArray(career)) && (career.length === 1)) {
			career[0].season = 'CAREER';
			summary.push(career[0]);
		} else if (!($.isArray(career))) {
     		summary.push(career);
	  	} else {
	  		for (i=0;i<career.length;i++) {
				summary.push($.extend({}, career[i], { season: 'CAREER' }));
			}
			summary.sort(function(a,b) {
				var a_pos_sort = parseInt(a.position_sort,10);
				var b_pos_sort = parseInt(b.position_sort,10);
        		return a_pos_sort - b_pos_sort;
        	});
    	}
		handleLoadSummaryDataSuccess(wrapQueryResults(summary));
	}
}

		data_arr = merged;
		d_arr_len = data_arr.length;
		if (d_arr_len > 0) {
			for (i=0;i<d_arr_len;i++) {
				for (j in data_arr[i]) {
					if (!data_arr[i][j]) {
						data_arr[i][j] = "-";
					}
				}
			}
		}
    careerTable = new ExpandableDataGrid(cfg.careerDatagridConfig);

    careerTable.loadData({
      data:     wrapQueryResults(data_arr),
      callback: function () {
		var sort_idx;
	  	if (!($.isArray(career)) || (career.length === 1)) {
			if ($.isArray(career)) {
				career[0].season = 'CAREER';
				careerTable.insertFooterRow(career[0]);
			} else {
        		careerTable.insertFooterRow(career);
			}
		} else {
			career.sort(function(a,b) {
				var a_pos_sort = parseInt(a.position_sort,10);
				var b_pos_sort = parseInt(b.position_sort,10);
            	return a.position_sort - b.position_sort;
            });
			for (i=0;i<career.length;i++) {
				career[i].season = "CAREER";
				careerTable.insertFooterRow(career[i]);
			}
		}
		if ((typeof(stat_type) !== "undefined") && (parseInt(stat_type,10) === 3) && (parseInt(globals.statType,10) === 1))  {
			sort_idx = parseInt(careerTable.columns('position_sort').index,10);
			careerTable.sortColumns({columns: [0,sort_idx]});
		} else {
			careerTable.sortColumn(0, DESC);
		}
        careerTable.render('careerPanel');
        careerPanel.show();
      }
    });
  },

  handleLoadCareerStatsError = function () {
    careerSummaryPanel.html(ERROR_LOADING_DATA);
	careerSummaryPanel.show();
  },

  handleLoadCareerStatsComplete = function () {
    careerSummaryPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },

  
  /* POST-SEASON STATS ******************************************************/

  postSeasonConfig,
  postSeasonPanel,

  postSeasonGameTypes = [
    GAME_TYPE_DIVISION_SERIES,
    GAME_TYPE_LEAGUE_SERIES,
    GAME_TYPE_WORLD_SEASON
  ],

  postSeasonConfigFactory = function (statType) {

    var config = {
      gameTypeProperty: 'lk_game_type',
      datagridConfig:   $.extend({}, baseDatagridConfig)
    };

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_bio_hitting_postseason_summary.bam',
        colInProperty:   'mlb_individual_hitting_season.col_in',
        gameTypeParam:   'mlb_individual_hitting_season_game_type_repeater.game_type',
        summaryProperty: 'mlb_bio_hitting_postseason_summary',
        seasonProperty:  'mlb_individual_hitting_season_game_type_repeater.mlb_individual_hitting_season',
        totalsProperty:  'mlb_individual_hitting_season'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: DESCRIPTION, type: TEXT, title: EMPTY_TITLE, decorator: postSeasonDescriptionDecorator },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: TB, type: NUMBER, title: TB_TITLE },
          { dataField: H2B, type: NUMBER, title: H2B_TITLE },
          { dataField: H3B, type: NUMBER, title: H3B_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_bio_pitching_postseason_summary.bam',
        colInProperty:   'mlb_individual_pitching_season.col_in',
        gameTypeParam:   'mlb_individual_pitching_season_game_type_repeater.game_type',
        summaryProperty: 'mlb_bio_pitching_postseason_summary',
        seasonProperty:  'mlb_individual_pitching_season_game_type_repeater.mlb_individual_pitching_season',
        totalsProperty:  'mlb_individual_pitching_season'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: DESCRIPTION, type: TEXT, title: EMPTY_TITLE, decorator: postSeasonDescriptionDecorator },
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: WHIP, type: NUMBER, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE }
        ]
      });
    }

    return config;
  },

  sortByGameType = function (a, b) {
    var aa = a[SORT_ORDER],
        bb = b[SORT_ORDER];
    return aa < bb ? -1 : aa > bb ? 1 : 0;
  },

  handleLoadPostSeasonStatsSuccess = function (data) {
	console.log("in handleLoadPostSeasonStatsSuccess");
    var cfg = postSeasonConfig,
        postSeasonTable,
        summary,
        seasons,
        i, n,
        gameTypes,
        rows = [],
        row;

    summary   = $.deep(data, cfg.summaryProperty);
    gameTypes = rehash(getQueryResults(summary, cfg.gameTypeProperty), GAME_TYPE);
    seasons   = $.deep(summary, cfg.seasonProperty);

    for (i = 0, n = seasons.length; i < n; ++i) {
      row = getQueryResult(seasons[i]);
      if (typeof row !== 'undefined') {
        rows.push($.extend({}, row, gameTypes[seasons[i][GAME_TYPE].replace(/'/g, '')]));
      }
    }
	console.log("rows length is " + rows.length);
    if (rows.length > 0) {

      postSeasonTable = new DataGrid(cfg.datagridConfig);

      postSeasonTable.loadData({
        data:     wrapQueryResults(rows.sort(sortByGameType)),
        callback: function () {
          var totals = getQueryResult(summary, cfg.totalsProperty);
          if (typeof totals !== 'undefined') {
            totals[DESCRIPTION] = 'TOTALS';
            postSeasonTable.insertFooterRow(totals);
          }
          postSeasonTable.render('postseason_stats');
        }
      });

      $('#more_career_postseason').attr('href', '/stats/individual_player_postseason.jsp?statType='+globals.statType+'&playerID=' + globals.player_id);
      $('#postseason_stats_year').text(globals.season + ' POSTSEASON STATS SUMMARY');
      postSeasonPanel.show();
    }
  },

  handleLoadPostSeasonStatsError = function () {},

  handleLoadPostSeasonStatsComplete = function () {},

  loadPostSeasonStats = function (playerId, statType, season) {

    postSeasonConfig = postSeasonConfig || postSeasonConfigFactory(statType);

    // Configure request
    var cfg = postSeasonConfig,
        params = {
          game_type:  postSeasonGameTypes,
          sport_code: MLB_SPORT_CODE,
          season:     season,
          player_id:  playerId
        };

    params[cfg.gameTypeParam] = postSeasonGameTypes;

    // Optimize query
    params[cfg.colInProperty] = getColumnDataFields(cfg.datagridConfig);

    $.ajax({
      url:      cfg.url,
      data:     params,
      dataType: 'json',
	  traditional:true,
      success:  handleLoadPostSeasonStatsSuccess,
      error:    handleLoadPostSeasonStatsError,
      complete: handleLoadPostSeasonStatsComplete
    });
  },

  /* LAST 10 TOTALS *********************************************************/

  lastTenConfig,
  lastTenPanel,
  lastTenLoaded = false,

  lastTenConfigFactory = function (statType) {

    var config = {
      gameTypes:  [
        GAME_TYPE_REGULAR_SEASON
		//GAME_TYPE_SPRING_TRAINING
      ],
      datagridConfig: $.extend({}, baseDatagridConfig)
    };

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:                  '/lookup/json/named.mlb_bio_hitting_last_10.bam',
        colInProperty:        'mlb_individual_hitting_last_x_total.col_in',
        gameLogProperty:      'mlb_bio_hitting_last_10.mlb_individual_hitting_game_log',
        lastTenTotalProperty: 'mlb_bio_hitting_last_10.mlb_individual_hitting_last_x_total'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: GAME_DATE, type: TEXT, title: GAME_DATE_TITLE, decorator: gameDateDecorator },
          { dataField: OPP, title: OPP_TITLE, type: TEXT, decorator: oppDecorator },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: HOME_AWAY, type: TEXT, visible: false},
          { dataField: GAME_ID, type: TEXT, visible: false},
          { dataField: GAME_TYPE, type: TEXT, visible: false}
        ]
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:                  '/lookup/json/named.mlb_bio_pitching_last_10.bam',
        colInProperty:        'mlb_individual_pitching_last_x_total.col_in',
        gameLogProperty:      'mlb_bio_pitching_last_10.mlb_individual_pitching_game_log',
        lastTenTotalProperty: 'mlb_bio_pitching_last_10.mlb_individual_pitching_last_x_total'
      });

      $.extend(config.datagridConfig, {
        columns: [
          { dataField: GAME_DATE, type: TEXT, title: GAME_DATE_TITLE, decorator: gameDateDecorator },
          { dataField: OPP, title: OPP_TITLE, type: TEXT, decorator: oppDecorator },
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: HOME_AWAY, type: TEXT, visible: false },
          { dataField: GAME_ID, type: TEXT, visible: false },
          { dataField: GAME_TYPE, type: TEXT, visible: false}
        ]
      });
    }

    return config;
  },

  handleLoadLastTenSuccess = function (data) {

    var cfg = lastTenConfig,
        lastTenTable = new DataGrid(cfg.datagridConfig),
        totals;

    lastTenTable.loadData({
      data:     $.deep(data, cfg.gameLogProperty),
      callback: function () {
        if (countQueryResults(data, cfg.lastTenTotalProperty)) {
          totals = getQueryResults(data, cfg.lastTenTotalProperty)[0];
          totals[GAME_DATE] = 'TOTALS';
          lastTenTable.insertFooterRow(totals);
        }
        lastTenTable.render('lastTenPanel');
      }
    });
  },

  handleLoadLastTenError = function () {
    lastTenPanel.html(ERROR_LOADING_DATA);
  },

  handleLoadLastTenComplete = function () {
    lastTenPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },

  loadLastTen = function (playerId, statType, season) {
    var lastSeason = parseInt(season,10);
	lastSeason = lastSeason - 1;
    if (lastTenLoaded) {
      return;
    }

    lastTenLoaded = true;
    lastTenConfig = lastTenConfig || lastTenConfigFactory(statType);
    lastTenPanel  = $('#lastTenPanel');

    // Configure request
    var cfg = lastTenConfig,
        params = {
          results:    10,
          game_type:  cfg.gameTypes,
          season:     season || playerbio.utils.get_year(),
          player_id:  playerId
        };

    // Optimize query
    params[cfg.colInProperty] = getColumnDataFields(cfg.datagridConfig);

    $.ajax({
      url:      cfg.url,
      dataType: 'json',
      data:     params,
	  traditional:true,
      success:  function (data) {

        if (countQueryResults(data, cfg.gameLogProperty) > 0) {
          handleLoadLastTenSuccess(data);
        } else if (season === playerbio.utils.get_year()) {
          $('#upcomingGamesTab').trigger('click');
          $('#splitsTab, #splitsPanel').hide();
          loadLastTen(playerId, statType, lastSeason);
        }

      },
      error:    handleLoadLastTenError,
      complete: handleLoadLastTenComplete
    });

  },

  /* UPCOMING GAMES *********************************************************/

  upcomingGamesConfig,
  upcomingGamesPanel,
  upcomingGamesLoaded = false,

  upcomingGamesConfigFactory = function () {

    var config = {
      url:           '/lookup/json/named.mlb_upcoming_games.bam',
      gameTypes: [
	  	//GAME_TYPE_SPRING_TRAINING,
        GAME_TYPE_REGULAR_SEASON,
        GAME_TYPE_ALL_STAR_GAME,
        GAME_TYPE_FIRST_ROUND,
        GAME_TYPE_DIVISION_SERIES,
        GAME_TYPE_LEAGUE_SERIES,
        GAME_TYPE_WORLD_SEASON
      ],
      colInProperty: 'mlb_upcoming_games.col_in',
      gamesProperty: 'mlb_upcoming_games',
      datagridConfig: $.extend({}, baseDatagridConfig)
    };

    $.extend(config.datagridConfig, {
      columns: [
        { dataField: GAME_DATE, type: TEXT, title: GAME_DATE_TITLE, decorator: gameDateShortDecorator },
        { dataField: OPP_TEAM_ABBREV, title: OPP_TITLE, type: TEXT, decorator: oppDecorator },
        { dataField: GAME_TIME_ET, title: GAME_TIME_TITLE, type: TEXT, decorator: gameTimeDecorator },
        { dataField: OPP_PROBABLE_SP, title: OPP_PROBABLE_SP_TITLE, type: TEXT, decorator: oppProbableSpDecorator },
        { dataField: GAME_PK, title: GAME_PK_TICKETING_TITLE, type: TEXT, decorator: gamePkTicketingDecorator },
        { dataField: HOME_AWAY, type: TEXT, visible: false },
        { dataField: GAME_ID, type: TEXT, visible: false },
        { dataField: OPP_PROBABLE_ID, type: TEXT, visible: false },
        { dataField: OPP_PROBABLE_W, type: TEXT, visible: false },
        { dataField: OPP_PROBABLE_L, type: TEXT, visible: false },
        { dataField: OPP_PROBABLE_ERA, type: TEXT, visible: false },
        { dataField: GAME_TYPE, type: TEXT, visible: false}
      ]
    });

    return config;
  },

  handleLoadUpcomingGamesSuccess = function (data) {

    var cfg = upcomingGamesConfig,
        upcomingGamesTable = new DataGrid(cfg.datagridConfig);
    
    upcomingGamesTable.loadData({
      data:     $.deep(data, cfg.gamesProperty),
      callback: function () {
        upcomingGamesTable.render('upcomingGamesPanel');
        var link = '<a id="schedule_link" href="/schedule/index.jsp?c_id=' +
          clubProps[globals.cid].club + '">Full Schedule &gt;</a>';
        upcomingGamesPanel.after(link);
      }
    });
  },

  handleLoadUpcomingGamesError = function () {
    upcomingGamesPanel.html(ERROR_LOADING_DATA);
  },

  handleLoadUpcomingGamesComplete = function () {
    upcomingGamesPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },

  loadUpcomingGames = function () {

    if (upcomingGamesLoaded) {
      return;
    }

    upcomingGamesLoaded = true;
    upcomingGamesConfig = upcomingGamesConfig || upcomingGamesConfigFactory();
    upcomingGamesPanel  = $('#upcomingGamesPanel');

    // Configure request
    var cfg = upcomingGamesConfig,
        params = {
          results:    10,
          game_type:  cfg.gameTypes,
          player_id:  globals.player_id
        };

    // Optimize query
    params[cfg.colInProperty] = getColumnDataFields(cfg.datagridConfig);
    $.ajax({
      url:      cfg.url,
      dataType: 'json',
      data:     params,
      success:  handleLoadUpcomingGamesSuccess,
      error:    handleLoadUpcomingGamesError,
      complete: handleLoadUpcomingGamesComplete,
	  traditional:true
    });
  },

  /* TICKETING **************************************************************/

  ticketingLoaded = false,

  handleLoadTicketingSuccess = function (data) {
    var games = ensureArray($.deep(data, 'events.game')),
        game,
        i, n;

    for (i = 0, n = games.length; i < n; ++i) {
      game = games[i];
      if(!ticketingHash[game.schedule_id]) {
        ticketingHash[game.schedule_id] = game;
      } else {
        $.extend(ticketingHash[game.schedule_id], game);
      }
    }
  },

  handleLoadTicketingError = function () {},

  handleLoadTicketingComplete = function () {
    loadUpcomingGames();
  },

  loadTicketing = function () {

    if (ticketingLoaded) {
      return;
    }

    ticketingLoaded = true;

    var now = DT.DateTime(new Date()),
        params = {
          sport_id:     1,
          site_section: "'DEFAULT'",
          team_id:      clubProps[globals.cid].team_id,
          year:         now.getFullYear(),
          begin_date:   now.toYMD(),
          end_date:     now.incrementMonth(2).toYMD(),
		  game_type:["'R'", "'D'", "'L'", "'W'"],
		  events: "10"
        };

    $.ajax({
      url:      '/ticketing-client/json/Game.tiksrv',
      dataType: 'json',
      data:     params,
      success:  handleLoadTicketingSuccess,
      error:    handleLoadTicketingError,
      complete: handleLoadTicketingComplete,
	  traditional:true
    });

  },
  
   /* Batter Vs. Pitcher *****************************************************************/

  bvpConfig,
  bvpPanel,
  bvpLoaded = false,
  
  bvpConfigFactory = function (statType) {

    var config = {
		bvpDatagridConfig:  $.extend({},baseDatagridConfig, {
			sortable: false,
			rowDecorator: stripeEveryFiveRowsDecorator,
			onColumnSort: function() {
				this.parent.refresh();
			}
		})
	};

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.stats_batter_vs_pitcher_composed.bam',
        individualProperty: 'stats_batter_vs_pitcher_composed.stats_batter_vs_pitcher',
		totalProperty: 'stats_batter_vs_pitcher_composed.stats_batter_vs_pitcher_total'
      });
	  
	  
	  $.extend(config.bvpDatagridConfig, {
        columns: [
          { dataField: PITCHER, type: TEXT, title: PITCHER_TITLE,decorator:bvpPlayerDecorator},
		  { dataField: SEASON, type: TEXT, title: SEASON_TITLE},
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: D, type: NUMBER, title: D_TITLE },
          { dataField: T, type: NUMBER, title: T_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
		  { dataField: TEAM_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		  { dataField: PITCHER_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		  { dataField: SIT_CODE, type: TEXT, title: EMPTY_TITLE, visible:false }
        ]
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:             '/lookup/json/named.stats_batter_vs_pitcher_composed.bam',
        individualProperty: 'stats_batter_vs_pitcher_composed.stats_batter_vs_pitcher',
		totalProperty: 'stats_batter_vs_pitcher_composed.stats_batter_vs_pitcher_total'
      });
	  
	  $.extend(config.bvpDatagridConfig, {
        columns: [
          { dataField: PLAYER, type: TEXT, title: PLAYER_TITLE,decorator:bvpPlayerDecorator},
		  { dataField: SEASON, type: TEXT, title: SEASON_TITLE},
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: D, type: NUMBER, title: D_TITLE },
          { dataField: T, type: NUMBER, title: T_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
		  { dataField: TEAM_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		  { dataField: PLAYER_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		  { dataField: SIT_CODE, type: TEXT, title: EMPTY_TITLE, visible:false }
        ]
		});
    }

    return config;
  },

  

  /* SPLITS *****************************************************************/

  splitsConfig,
  careerSplitsConfig,
  splitsPanel,
  careerSplitsPanel,
  splitsLoaded = false,
  
  splitsCareerConfigFactory = function (statType) {

    var config = {
		careerSplitsDatagridConfig:  $.extend({},baseDatagridConfig, {
			sortable: false,
			rowDecorator: stripeNewSplitsDecorator,
			onColumnSort: function() {
				this.parent.refresh();
			}
		})
	};

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_hitting_sits_composed.bam',
        sitsProperty: 'mlb_individual_hitting_sits_composed.mlb_individual_hitting_sits_season',
		sitsTotalProperty: 'mlb_individual_hitting_sits_composed.mlb_individual_hitting_sits_season_total',
		sitsCareerProperty: 'mlb_individual_hitting_sits_composed.mlb_individual_hitting_season_total'
      });
	  
	  
	  $.extend(config.careerSplitsDatagridConfig, {
        columns: [
          { dataField: SPLIT, type: TEXT, title: SPLIT_TITLE},
		  { dataField: DISPLAY_GROUP, type: TEXT, title: EMPTY_TITLE,visible:false },
		  { dataField: TEAM, type: TEXT, title: TEAM_TITLE,decorator:expandableTeamDisplayAbbrevDecorator },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: AB, type: NUMBER, title: AB_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: D, type: NUMBER, title: D_TITLE },
          { dataField: T, type: NUMBER, title: T_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: RBI, type: NUMBER, title: RBI_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
          { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
          { dataField: SB, type: NUMBER, title: SB_TITLE },
          { dataField: CS, type: NUMBER, title: CS_TITLE },
          { dataField: AVG, type: NUMBER, title: AVG_TITLE },
          { dataField: OBP, type: NUMBER, title: OBP_TITLE },
          { dataField: SLG, type: NUMBER, title: SLG_TITLE },
          { dataField: OPS, type: NUMBER, title: OPS_TITLE },
		  { dataField: TEAM_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		  { dataField: SEASON, type: TEXT, title: EMPTY_TITLE, visible:false },
		  { dataField: SIT_CODE, type: TEXT, title: EMPTY_TITLE, visible:false }
        ]
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_pitching_sits_composed.bam',
        sitsProperty: 'mlb_individual_pitching_sits_composed.mlb_individual_pitching_sits_season',
		sitsTotalProperty: 'mlb_individual_pitching_sits_composed.mlb_individual_pitching_sits_season_total',
		sitsCareerProperty: 'mlb_individual_pitching_sits_composed.mlb_individual_pitching_season_total'
      });
	  
	  $.extend(config.careerSplitsDatagridConfig, {
        columns: [
          { dataField: SPLIT, type: TEXT, title: SPLIT_TITLE},
		  { dataField: DISPLAY_GROUP, type: TEXT, title: EMPTY_TITLE,visible:false },
		  { dataField: TEAM, type: TEXT, sortState: ASC, title: TEAM_TITLE,decorator:expandableTeamDisplayAbbrevDecorator},
          { dataField: W, type: NUMBER, title: W_TITLE },
          { dataField: L, type: NUMBER, title: L_TITLE },
          { dataField: ERA, type: NUMBER, title: ERA_TITLE },
          { dataField: G, type: NUMBER, title: G_TITLE },
          { dataField: GS, type: NUMBER, title: GS_TITLE },
          { dataField: CG, type: NUMBER, title: CG_TITLE },
          { dataField: SHO, type: NUMBER, title: SHO_TITLE },
          { dataField: SV, type: NUMBER, title: SV_TITLE },
          { dataField: SVO, type: NUMBER, title: SVO_TITLE },
          { dataField: IP, type: NUMBER, title: IP_TITLE },
          { dataField: H, type: NUMBER, title: H_TITLE },
          { dataField: R, type: NUMBER, title: R_TITLE },
		  { dataField: ER, type: NUMBER, title: ER_TITLE },
          { dataField: HR, type: NUMBER, title: HR_TITLE },
          { dataField: HB, type: NUMBER, title: HB_TITLE },
          { dataField: BB, type: NUMBER, title: BB_TITLE },
		  { dataField: IBB, type: NUMBER, title: IBB_TITLE },
          { dataField: SO, type: NUMBER, title: SO_TITLE },
		  { dataField: AVG, type: NUMBER, title: AVG_TITLE },
		  { dataField: WHIP, type: NUMBER, title: WHIP_TITLE },
          { dataField: GO_AO, type: NUMBER, title: GO_AO_TITLE },
		   { dataField: TEAM_ID, type: NUMBER, title: EMPTY_TITLE, visible:false },
		   { dataField: SEASON, type: TEXT, title: EMPTY_TITLE, visible:false },
		   { dataField: SIT_CODE, type: TEXT, title: EMPTY_TITLE, visible:false }
        ]
		});
    }

    return config;
  },


  splitsConfigFactory = function (statType) {

    var config = {};

    // Hitting config
    if (statType === STAT_TYPE_HITTING) {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_hitting_bio_sits.bam',
        colInProperty:   'mlb_individual_hitting_bio_sits.col_in',
        bioSitsProperty: 'mlb_individual_hitting_bio_sits'
      });

    // Pitching config
    } else {

      $.extend(config, {
        url:             '/lookup/json/named.mlb_individual_pitching_bio_sits.bam',
        colInProperty:   'mlb_individual_pitching_bio_sits.col_in',
        bioSitsProperty: 'mlb_individual_pitching_bio_sits'
      });

    }

    return config;
  },

  handleLoadSplitsSuccess = function (data) {

    var cfg = splitsConfig,
        splits = rehash(getQueryResults(data, cfg.bioSitsProperty), SIT_DESC),
        tableDefinitions,
        tableDefinition,
        tableName,
        tables = {},
        table,
        tbody,
        key,
        val,
        i, n;
    var season_month = is_inSeason();
    if (countQueryResults(data, cfg.bioSitsProperty) > 0) {

      tableDefinitions = {
        leftRight:   ['vs Left', 'vs Right'],
        homeAway:    ['Home Games', 'Away Games'],
        grassTurf:   ['On Grass', 'On Turf'],
        dayNight:    ['Day Games', 'Night Games'],
        currentLast: ['Current Month', 'Last 30 Days']
      };

      for (tableName in tableDefinitions) {
        if (tableDefinitions.hasOwnProperty(tableName)) {
          tableDefinition = tableDefinitions[tableName];

          if (tableDefinition.length > 0) {

            table = $('<table></table>').addClass('quick_splits');
            tbody = $('<tbody></tbody>');

            for (i = 0, n = tableDefinition.length; i < n; ++i) {

              key = tableDefinition[i];
              val = $.deep(splits, key + '.avg') || '--';

              if (key === 'Current Month') {
                key = season_month;
              }

              $('<tr></tr>').append(
                $('<th></th>').text(key),
                $('<td></td>').text(val)
              ).appendTo(tbody);
            }

            tbody.appendTo(table);
            tables[tableName] = table;
          }
        }
      }
	  var regular_season_disclaimer = $("<span />").text("(Regular season stats only)").css({"float":"left","width":"100%","margin-top":"8px","margin-left":"8px"});
      splitsPanel
        .empty()
        .append($('<div></div>')
          .attr('id', 'splits_col_left')
          .append(tables.leftRight)
          .append(tables.homeAway)
          .append(tables.grassTurf))
        .append($('<div></div>')
          .attr('id', 'splits_col_right')
          .append(tables.dayNight)
          .append(tables.currentLast))
		.append(regular_season_disclaimer);
    }
  },
  
  handleLoadCareerSplitsSuccess = function (data) {
      var cfg = careerSplitsConfig || splitsCareerConfigFactory(statType);
      var careerSplitsTable,
	    totals   = getQueryResults(data, cfg.sitsTotalProperty),
        partials = getQueryResults(data, cfg.sitsProperty),
        merged   = mergeTotalsAndPartials(totals, partials),
        career   = getQueryResults(data, cfg.sitsCareerProperty)[0],
        summary  = [],
        i, n, j,
		row_len,
		splits_data,
		data_arr, d_arr_len,
		row_arr,
		rows;

    	if (typeof career === 'undefined') {
      		career = {};
    	}
		if (merged.length > 0) {
    		career.situation = 'YEAR';
		}

		data_arr = merged;
		d_arr_len = data_arr.length;
		if (d_arr_len > 0) {
			for (i=0;i<d_arr_len;i++) {
				for (j in data_arr[i]) {
					if (!data_arr[i][j]) {
						data_arr[i][j] = "-";
					}
				}
			}
		}
	
		/*rows = $.deep(data, cfg.sitsProperty);
	  	if (rows.queryResults.totalSize > 0) {
	 	 	row_arr = ensureArray(rows.queryResults.row);
	  		row_len = row_arr.length;
	  		splits_data = [];
	 	 	for (i=0;i<row_len;i++) {
					splits_data.push(row_arr[i]);
	 	 	}*/
      	careerSplitsTable = new ExpandableDataGrid(cfg.careerSplitsDatagridConfig);

      	careerSplitsTable.loadData({
       	 data:     wrapQueryResults(data_arr),
        	callback: function () {
				careerSplitsTable.insertFooterRow(career);
        		//careerSplitsTable.sortColumn(0, DESC);
         	 	careerSplitsTable.render('splitsCareerPanel');
				careerSplitsPanel.show();
        	}
      	});
	 
		//}
			
  },

  handleLoadSplitsError = function () {
    splitsPanel.html(ERROR_LOADING_DATA);
  },

  handleLoadSplitsComplete = function () {
    splitsPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },
  
   handleLoadCareerSplitsError = function () {
    careerSplitsPanel.html(ERROR_LOADING_DATA);
  },

  handleLoadCareerSplitsComplete = function () {
    careerSplitsPanel.removeClass(LOADING_MASK_CLASS_NAME);
  },

  loadSplits = function (playerId, statType, season) {

    if (splitsLoaded) {
      return;
    }

    splitsLoaded = true;
    splitsConfig = splitsConfig || splitsConfigFactory(statType);
    splitsPanel  = $('#splitsPanel');

    // Configure request
    var cfg = splitsConfig,
        params = {
          sport_code: MLB_SPORT_CODE,
          game_type:  GAME_TYPE_REGULAR_SEASON, //replace with GAME_TYPE_REGULAR_SEASON, in regular season
          season:     season,
          player_id:  playerId
        };

    // Optimize query
    params[cfg.colInProperty] = [SIT_DESC, AVG];

    $.ajax({
      url:      cfg.url,
      dataType: 'json',
      data:     params,
      success:  handleLoadSplitsSuccess,
      error:    handleLoadSplitsError,
      complete: handleLoadSplitsComplete,
	  traditional:true
    });
  },
  
  /* INIT *******************************************************************/
  expand_collapse = function(index,is_checked) {
  	var $selected_toggle = $("#gameLogPanel table.stats_table td span.expandable_toggle").eq(index);
  	if (is_checked) {
		if ($selected_toggle.is(".expandable_toggle, .expandable_expand") && !$selected_toggle.is(".expandable_collapse")) {
			$selected_toggle.trigger("click", [index]);
		}
	} else {
		if ($selected_toggle.is(".expandable_toggle, .expandable_collapse") && !$selected_toggle.is(".expandable_expand")) {
			$selected_toggle.trigger("click", [index]);
		}
	}
	
  },

  initPlayerStats = function () {

    // Import globals into closure
    globals   = window.globals;
    flags     = window.flags;
    clubProps = window.clubProps;

    var playerId = globals.player_id,
        statType = globals.statType,
        season   = globals.season,
        clubId   = globals.cid;

    $.ajaxSetup({
      timeout: 30000
    });
    $('.stats_table th.sortable, .expandable_toggle')
      .live('mouseover', function () {
        $(this).addClass('hover');
      })
      .live('mouseout', function () {
        $(this).removeClass('hover');
      });

    careerSummaryPanel = $('#stats_career_summary_wrapper');
    careerPanel        = $('#stats_career_wrapper');
	springTrainingPanel        = $('#spring_training_stats_wrapper');
	postSeasonPanel = $('#postseason_stats_wrapper');
	gameLogPanel = $('#stats_career_wrapper');

	$("#expand_all_months").button();
	$('#stats_nav_game_type').val("'R'");
	//$('#stats_nav_game_type').selectmenu({style:'popup'});
	//$("#bvp_team_select").selectmenu({style:'popup'});
		

	
	//calling these directly instead of using a tab click to avoid triggering tracking
	//
  // loadCareerStats(playerId, statType);
	//$("#careerTab").addClass("active");
	
	$("#expand_all_months").live('click',function() {
		bam.tracking.track({async:{
isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Expand All Months Click",actionGen:true}});
		var is_checked = $(this).attr("checked");
		var i = 0;
		var count_toggles,j; 
		var $selected_toggle;
		$("#gameLogPanel table.stats_table td span.expandable_toggle").each(function(i) {
			count_toggles = i;
			i++;
		});
		for (j=count_toggles;j>=0;j--) {
			expand_collapse(j,is_checked);
		}
	});
	
	$("#stats_nav_season").live('change',function () {
		bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Season Click",actionGen:true}});
  		var selected_year = $("#stats_nav_season").val();
		bbq_stats.updateBbqHash({"season":selected_year});
  	});
	$("#stats_nav_game_type").live('change',function () {
		bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Time Frame Click",actionGen:true}});
  		var selected_game_type = $("#stats_nav_game_type").val();
		bbq_stats.updateBbqHash({"gameType":selected_game_type});
  	});
	$("#bvp_team_select").live('change',function () {
		bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Batter Vs. Pitcher Team Click",actionGen:true}});
  		var selected_team = $("#bvp_team_select").val();
		bbq_stats.updateBbqHash({"bvpTeam":selected_team,"bvpPlayer":""});
  	});
	$("#bvp_player_select").live('change',function () {
		bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Batter Vs. Pitcher Player  Click",actionGen:true}});
  		var selected_player = $("#bvp_player_select").val();
		bbq_stats.updateBbqHash({"bvpPlayer":selected_player});
  	});
	$("input[name='stats_nav_type']").live('click',function () {
		bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:"Player Page Stats Module: Stat Type Click",actionGen:true}});
		var selected_stat_type = $("input[name='stats_nav_type']:checked").val();
		bbq_stats.updateBbqHash({"statType":selected_stat_type});
	});
	
		  
	  $('#stats_career_wrapper').tigerTabs({
        beforeShow: function (e, panel) {
		  var discard = panel.indexOf("Panel");
		  var selected_stat_type = panel.substring(1,discard);
          switch(panel) {

            case '#careerPanel':
				tabName = "Player Page Stats Module: Career Tab Click";
				bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:tabName,actionGen:true}});
				bbq_stats.updateBbqHash({"sectionType":selected_stat_type});
              break;

            case '#gameLogPanel':
				tabName = "Player Page Stats Module: Game Log Tab Click"; 
				bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:tabName,actionGen:true}});
				bbq_stats.updateBbqHash({"sectionType":selected_stat_type});
              break;

            case '#splitsCareerPanel':
				tabName = "Player Page Stats Module: Splits Tab Click";
				bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:tabName,actionGen:true}});
				bbq_stats.updateBbqHash({"sectionType":selected_stat_type});
              break;
			case '#bvpPanel':
				tabName = "Player Page Stats Module: Batter Vs Pitcher Tab Click";
				bam.tracking.track({async:{isDynamic:true,compName:"Player Page Stats Module",compActivity:tabName,actionGen:true}});
				bbq_stats.updateBbqHash({"sectionType":selected_stat_type});
             break;
			  
          }
        }
      });

    if (flags.is_historical !== 'true') {

      summaryPanel = $('#stats_summary');

      $('#stats_wrapper').tigerTabs({
        beforeShow: function (e, panel) {
          switch(panel) {

            case '#lastTenPanel':
              loadLastTen(playerId, statType, playerbio.utils.get_year());
              break;

            case '#upcomingGamesPanel':
              // @todo DRY this up, decouple ticketing and upcoming games
              // Code duplicated below in $.ready
              if (clubId !== MLB) {
                loadTicketing();
              } else {
                loadUpcomingGames();
              }
              break;

            case '#splitsPanel':
              loadSplits(playerId, statType, season);
              break;
          }
        }
      });

      
      loadPostSeasonStats(playerId, statType, season);  //for postseason add this back
	  
      //loadSpringTrainingStats(playerId, statType, season); //add for spring training
	  loadLastTen(playerId, statType, playerbio.utils.get_year());
	  $("#lastTenTab").trigger('click');
      // Once the page loads, call slow loadUpcomingGames service
      // Remove when query is optimized
     window.setTimeout(function () {
        if (clubId !== MLB) {
          loadTicketing();
        } else {
          loadUpcomingGames();
        }
      }, 3000);
    }
  };

  $(function () {
    playerbio.init();
    initPlayerStats();
  });
    var _public = {
		loadGameLogStats : function (playerId, statType, season,selected_game_type) {
  			$("#gameLogPanel table").empty();
			var game_type_text = $('#stats_nav_game_type option:selected').text();
  			//gameLogPanel.addClass(LOADING_MASK_CLASS_NAME);
  			if (!season) {
				season = globals.season;
			}
   	 		gameLogConfig = gameLogConfig || gameLogConfigFactory(statType);
			$.extend(gameLogConfig.gameLogDatagridConfig, {
				caption:'GAME LOG: ' + game_type_text + ' ' + season
	 		});
    		// Configure request
    		var cfg = gameLogConfig,
        		params = {
         	 	game_type:  selected_game_type,
          		player_id:  playerId,
		  		season: season,
		  		sit_code :["'2'","'3'","'4'","'5'","'6'","'7'","'8'","'9'","'10'","'11'"]
        	};
    	// Optimize query
  		// params[cfg.colExProperty] = cfg.gameLogDatagridConfig.gameLogColEx;

    	$.ajax({
      		url:      cfg.url,
      		data:     params,
      		dataType: 'json',
      		success:  handleLoadGameLogSuccess,
      		error:    function(a,b,c) {
	  			console.log("error: "+a+":"+b+":"+c);
			},
      		complete: handleLoadGameLogStatsComplete,
	  		traditional:true
    	});
 	 },
	 
	 loadBVP : function(playerId, statType,season, pitcher_id, team_id) {
   	 	bvpConfig = bvpConfig || bvpConfigFactory(statType);
    	bvpPanel  = $('#bvpPanel');

    // Configure request
    	var cfg = bvpConfig,
        	params = {
          	sport_code: MLB_SPORT_CODE,
          	game_type:  GAME_TYPE_REGULAR_SEASON
        	};

		if ((typeof(pitcher_id) !== "undefined") && (pitcher_id != null)) {
			//$("#stats_nav_season").selectmenu('disable');
			$("#stats_nav_season").attr("disabled","disabled");
			if ( parseInt(statType,10) === 2) { 
				params.player_id = pitcher_id;
				params.pitcher_id = playerId;
			} else {
				params.player_id = playerId;
				params.pitcher_id = pitcher_id;
			}
		} else if ( (parseInt(statType,10) === 2) && (typeof(team_id) !== "undefined") ) {
			//$("#stats_nav_season").selectmenu('enable');
			$("#stats_nav_season").removeAttr("disabled");
			params.pitcher_id = playerId;
			params.team_id = team_id;
			params.season = season;
		} else if ( (parseInt(statType,10) !== 2) && (typeof(team_id) !== "undefined") ) {
			//$("#stats_nav_season").selectmenu('enable');
			$("#stats_nav_season").removeAttr("disabled");
			params.player_id = playerId;
			params.opp_team_id = team_id;
			params.season = season;
		}
    	$.ajax({
      		url:      cfg.url,
      		dataType: 'json',
      		data:     params,
      		success:  handleLoadBvpSuccess,
      		error:    handleLoadBvpError,
      		complete: handleLoadBvpComplete,
	  		traditional:true
    	});
  
  	},
  
	 loadCareerSplits : function (playerId, statType, season,selected_game_type) {
    	careerSplitsConfig = careerSplitsConfig || splitsCareerConfigFactory(statType);
    	careerSplitsPanel  = $('#splitsCareerPanel');
		if (typeof(selected_game_type) === "undefined") {
			selected_game_type = "'R'";
			$("#stats_nav_game_type option[value='"+GAME_TYPE_REGULAR_SEASON+"']").attr("selected","selected");
			//$("#stats_nav_game_type").selectmenu();
		}
		var selected_game_type_text = $("#stats_nav_game_type option:selected").text();
		var sits = [];
		if (statType === STAT_TYPE_HITTING) {
			sits = 	["'vl'","'vr'","'h'","'a'","'g'","'t'","'d'","'n'","'3'","'4'","'5'","'6'","'7'","'8'","'9'","'10'","'preas'","'posas'","'h1'","'h2'","'lc'","'ac'","'bc'","'o0'","'o1'","'o2'","'i01'","'ix'","'b1'","'r0'","'r1'","'r2'","'r3'","'r12'","'r13'","'r23'","'r123'","'risp'"];
		} else {
			sits = ["'sp'","'rp'","'vl'","'vr'","'h'","'a'","'g'","'t'","'d'","'n'","'3'","'4'","'5'","'6'","'7'","'8'","'9'","'10'","'preas'","'posas'","'h1'","'h2'","'lc'","'ac'","'bc'","'b1'","'r0'","'r1'","'r2'","'r3'","'r12'","'r13'","'r23'","'r123'","'risp'","'o0'","'o1'","'o2'","'ix'"];
		}
		$.extend(careerSplitsConfig.careerSplitsDatagridConfig, {
			caption:'SPLITS: ' + selected_game_type_text + ' ' + season
	 	});
    	// Configure request
    	var cfg = careerSplitsConfig,
        	params = {
          	sport_code: MLB_SPORT_CODE,
          	game_type:  selected_game_type, 
          	season:     season,
          	player_id:  playerId,
		  	sit_code : sits
        };

    	$.ajax({
      	url:      cfg.url,
      	dataType: 'json',
      	data:     params,
      	success:  handleLoadCareerSplitsSuccess,
      	error:    handleLoadCareerSplitsError,
      	complete: handleLoadCareerSplitsComplete,
	  	traditional:true
    	});
  	},

  	loadAllStarStats : function (playerId, selected_stat_type) {
		if (!selected_stat_type) {
			selected_stat_type = statType;
		}
   	 	allStarConfig = allStarConfigFactory(selected_stat_type);

    	// Configure request
    	var cfg = allStarConfig,
        	params = {
         	 game_type: allStarGameTypes,
          	sort_by:   "'season_asc'",
          	player_id: playerId
        	};
		if (parseInt(selected_stat_type,10) === 3) {
			params.position = ["'1'","'2'","'3'","'4'","'5'","'6'","'7'","'8'","'9'","'O'"];
		}

    	$.ajax({
      		url:      cfg.url,
      		data:     params,
      		dataType: 'json',
      		success:  handleLoadAllStarSuccess,
      		error:    handleLoadAllStarError,
      		complete: handleLoadAllStarComplete,
	  		traditional:true
    	});
  	},
	loadCareerStats : function (playerId, selected_stat_type,selected_game_type) {
		var stat_type_text;
		if (typeof(selected_stat_type) === "undefined") {
			selected_stat_type = statType;
		}
    	careerSummaryConfig = careerSummaryConfigFactory(selected_stat_type);
		if (typeof(selected_game_type) === "undefined") {
			selected_game_type = "'R'";
			$("#stats_nav_game_type option[value='"+GAME_TYPE_REGULAR_SEASON+"']").attr("selected","selected");
			//$("#stats_nav_game_type").selectmenu();
		}
		var game_type_text = $("#stats_nav_game_type option:selected").text();
		$("#expand_months").hide();
    	// Configure request
    	var cfg = careerSummaryConfig,
        	params = {
          	game_type: selected_game_type,
          	sort_by:   "'season_asc'",
          	player_id: playerId
       	 };
		 if (parseInt(selected_stat_type,10) === 3) {
		 	params.position=["'1'","'2'","'3'","'4'","'5'","'6'","'7'","'8'","'9'","'O'"];
		 }
		if (parseInt(selected_stat_type) !== 3)  {
    		params[cfg.seasonSportcode] = playerbio.utils.get_year();
		}

    	// Optimize query (not a complete optimization, but significant)
		if (parseInt(selected_stat_type,10) !== 3) {
    		params[cfg.careerColExProperty] = cfg.careerColEx;
    		params[cfg.totalColExProperty]  = cfg.totalColEx;
    		params[cfg.seasonColExProperty] = cfg.seasonColEx;
		}

		if (parseInt(selected_stat_type,10) === 1) {
			stat_type_text = "BATTING";
		} else if (parseInt(selected_stat_type,10) === 2) {
			stat_type_text = "PITCHING";
		} else if (parseInt(selected_stat_type,10) === 3) {
			stat_type_text = "FIELDING";
		}
		$.extend(cfg.careerDatagridConfig, {
	  		caption: stat_type_text + " " +game_type_text+' Career Stats'
		});
    	$.ajax({
			url:      cfg.url,
      		data:     params,
      		dataType: 'json',
      		success:  handleLoadCareerStatsSuccess,
      		error:    handleLoadCareerStatsError,
      		complete: handleLoadCareerStatsComplete,
	  		traditional:true
    	});
  	}

	
	};
return _public;
})(jQuery, window);
(function ($) {

  $.fn.tigerTabs = function (cfg) {

    var eventDispatcher = $({});

    cfg = $.extend({
      display:      0,
      activeClass:  'active',
      beforeShow:   null,
      afterShow:    null
    }, cfg || {});

    if ($.isFunction(cfg.beforeShow)) {
      eventDispatcher.bind('show:before', cfg.beforeShow);
    }

    if ($.isFunction(cfg.afterShow)) {
      eventDispatcher.bind('show:after', cfg.afterShow);
    }

    return this.each(function (index) {

      var $this   = $(this),
          $tabs   = $this.find('.tabs a'),
          $panels = $this.find('.panels'),
		  active;
          if (index === 0) {
		  	active = this;
		  }

      $tabs.click(function (e) {
        e.preventDefault();

        if (active !== this) {
		  $this.find("a."+cfg.activeClass).each(function(){$(this).removeClass(cfg.activeClass);}); 
          var $tab = $(this);
          eventDispatcher.trigger('show:before', [this.hash]);
          $(active).removeClass(cfg.activeClass);
          $tab.addClass(cfg.activeClass);
          $panels.find(this.hash).show().siblings().hide();
          active = this;
          eventDispatcher.trigger('show:after', [this.hash]);
        }
      });

      // Display initial panel
     // .eq(cfg.display).trigger('click');

    });
  };

})(jQuery);