/*
This file contains definitions of the 
DataTable and DataTableManager objects. 
*/

var sid = request.getParameter("sid");
var cid = request.getParameter("gid");
var lid = request.getParameter("lid");

if (sid == null || sid == "null") {
    sid = "wbc";
}

function getNowDate() {
    return new Date(currentTimeMillis);
}
  

/////////// BEGIN DATATABLE OBJECT SCRIPTS ///////////

var DT_SORT_ASC  = 0;
var DT_SORT_DESC = 1;
var DT_NO_SORT   = 2;

var DT_LEFT   = "left";
var DT_RIGHT  = "right";
var DT_CENTER = "center";

var DT_MLB_CLUB_IDS=",108,109,110,111,112,113,114,115,116,117,118,119,120,121,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,158,"

function DataTable(data, colMetadata, initialSortColCode, tableTitle) {

    // ensure that params are valid:
    if (data.length>0) {
        /*
        if (data[0].length!=colMetadata.length) {
            alert("Error constructing DataTable: colMetadata array must have same number of elements as interior data-array elements(data[0].length="+data[0].length+"; colMetadata.length="+colMetadata.length+").")
            return;
        }
        */
    }

    // constructor values:
    this.data = data; 
    this.tableTitle = tableTitle;
    this.initialSortColCode = initialSortColCode;
    this.currentSortColCode = initialSortColCode;
    this.divId = null;
    
    this.currentHighlighedIdx = -1;
    
    this.suppressTitleBar  = false;
    this.suppressHeaderRow = false;
    
    // handling col metadata as arrays instead of in a more "elegant" way for performance reasons:
    this.colCodes = [];
    this.displayNames = [];
    this.sortTypes = [];
    this.visibilities = [];
    this.sortFunctionNames = [];
    this.altColsForSort = [];
    this.rowSuppressionCheckFunctionNames = [];
    this.colWidths = [];
    this.colAligns = [];
    for (var i=0; i<colMetadata.length; i++) {
        this.colCodes[i] = colMetadata[i][0];
        this.displayNames[i] = colMetadata[i][1];
        this.sortTypes[i] = colMetadata[i][2];
        this.visibilities[i] = colMetadata[i][3];
        this.sortFunctionNames[i] = colMetadata[i][4];
        this.altColsForSort[i] = colMetadata[i][5];
        this.rowSuppressionCheckFunctionNames[i] = colMetadata[i][6];
        this.colWidths[i] = colMetadata[i][7];
        this.colAligns[i] = colMetadata[i][8];
    }

    this.tableManagerIdx; // set by DataTableManager

    // methods:
    this.sort = _DataTable_sort;
    this.displaySortedOn = _DataTable_displaySortedOn;
    this.getColIdxFromColCode = _DataTable_getColIdxFromColCode;
    this.write = _DataTable_write;
    this.writePleaseWait = _DataTable_writePleaseWait;
    this.getTableHTML = _DataTable_getTableHTML;
    this.writeTableContainer = _DataTable_writeTableContainer;
    this.doHighlightRow = _doHighlightRow;
    
    // sort on initial sort col:
    if (initialSortColCode != null) {
        this.sort(initialSortColCode);
    }
}

function _getNumber(str) {
    var okChars = "-1234567890.";
    var ret = "";
    for (var i=0; i<str.length; i++) {
        var thisChar = str.charAt(i)
        if (okChars.indexOf(thisChar)>-1) {
            ret += thisChar;
        }
    }
    if (str == "") {
        return 0;
    }
    return parseFloat(str);
}

function _getObject(objId) {
    var doc=document;
    if (doc.getElementById) {
        return doc.getElementById(objId);
    }
    if (doc.all[objId]) {
        return doc.all[objId];
    }
    return null;    
}

function _DataTable_writePleaseWait(targetObjId) {
    var targetObj=_getObject(targetObjId);
    var msg="<div align=\"left\"><table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"dataTableClass\" style=\"background-color:#990000; color:#FFFFFF;\"><tr>";
    msg+="<td style=\"background-color:#990000; text-align:left; color:#FFFFFF; font-weight: bold;\">&nbsp;&nbsp;Please wait: sorting table...&nbsp;&nbsp;<br/></td>";
    msg+="</tr></table></div>";

    if (targetObj.insertAdjacentHTML) {
        targetObj.insertAdjacentHTML("afterBegin",msg);
    } else  {
        try {
            var el = document.createElement("span");
            el.innerHTML = msg;
            targetObj.insertBefore(el, targetObj.firstChild);
        } catch(e) {
            targetObj.innerHTML = msg;
        }
    }
}

function _DataTable_write(targetObjId,flipOrderAfterSort) {
    var targetObj = _getObject(targetObjId);
    var tableHTML = this.getTableHTML(targetObjId,flipOrderAfterSort);
    var s = tableHTML.join(""); // build the table html from array contents
    targetObj.innerHTML = s;

    // attach event handlers to data tables to highlight rows
    var elements = targetObj.getElementsByTagName("table");
    for (var i = 0; i < elements.length; i++) {
        var el = elements[i];
        if (el.className == "dataTableClass") {
            if (typeof window.addEventListener != "undefined") {     // the firefox way
                el.addEventListener("mousedown", this.doHighlightRow, false);
            } else if (typeof window.attachEvent != "undefined") {   // the ie way
                el.attachEvent("onmousedown", this.doHighlightRow);
            }
        }
    }
}

// event handler for rowHighlighting
function _doHighlightRow(e) {
    if (!e) e = window.event;  // for IE
	var target = e.target || e.srcElement; // for IE
    var cell = target;
    var row = target;
    var rowId = target.id.substring(5); // store the row id so we can highlighed again after sort

    // go up the tree till we find the parent row
    while ((row.tagName != "TR") && row.parentNode) {
        row = row.parentNode;
    }

    if (row.className.indexOf("dataRow") > -1) {

        // go up the tree till we find the parent table
        while ((target.tagName != "TABLE") && (target.className != "dataTableClass") && target.parentNode) {
            target = target.parentNode;
        }
        if (target.className == "dataTableClass") {
            tableId = target.id.substring(6);
            DataTableManager.dataTables[tableId].currentHighlighedIdx = rowId; // store the id of the row to highlight

            var rows = target.getElementsByTagName("tr");
            for (var l=0; l < rows.length; l++) {
                if (rows[l].className.indexOf("highlightRow") > -1) {
                  rows[l].className = removeString(rows[l].className, "highlightRow");
                }
            }
        }
        row.className += " highlightRow";
    }
}

function _DataTable_writeTableContainer(divId, finalRowContents) {

    if (arguments.length == 1) {
        finalRowContents = null;
    }
    this.divId = divId;

    var tableHTML = this.getTableHTML(divId,false,finalRowContents);
    document.write("<div style=\"border:0px solid #000000; \" id="+divId+" class=\"divContainerClass\" >");
    var tLength = tableHTML.length;
    for (var i=0; i<tLength; i++) {
        if (!tableHTML[i]) {
            break;
        }
        document.write(tableHTML[i]);
    }
    document.write("</div>");

    var elements = document.getElementsByTagName("table");
    for (var i=0; i<elements.length; i++) {
        var el = elements[i];
        if (el.className == "dataTableClass") {
            if (typeof window.addEventListener != "undefined") {     // the firefox way
                el.addEventListener("mousedown", this.doHighlightRow, false);
            } else if (typeof window.attachEvent != "undefined") {   // the ie way
                el.attachEvent("onmousedown", this.doHighlightRow);
            }
        }
    }

}

function clubLink(linkLabel, clubId, hideFlag) {
    if (clubId == "0") {
        return "-";
    }
    if (isMajorLeagueClub(clubId)) {
        return "<a class=\"clubLink\" href=\"http://www.mlb.com/NASApp/mlb/minors/milb_redirector.jsp?cid=t"+clubId+"\" target=\"_blank\">"+linkLabel+"</a>";
    }
    else {
        html = "";
        if (!(hideFlag)) {
            html += "<a target=\"_parent\" href=\"/"+year+"/teams/index.jsp?sid=t"+clubId+"\"><img src=\"/2006/images/flags_sm/flag_t" + clubId + ".gif\" height=\"12\" width=\"18\"  border=\"0\" /></a>&nbsp;";
        }
        html += "<a class=\"clubLink\" target=\"_parent\" href=\"/"+year+"/teams/index.jsp?sid=t"+clubId+"\">"+linkLabel+"</a>";
        return html; 
    }
}

function isMajorLeagueClub(clubId) {
    // note: DT_MLB_CLUB_IDS is a comma-delimited list of numeric MLB club
    // ids; its first and last char are also commas, so the following test
    // is always valid:
    return ((","+DT_MLB_CLUB_IDS+",").indexOf(clubId)>-1);
}


// note: anchor tag can have this format: 
// "<a href=\"#\" onclick=\"processBookmarkPlayer('~PLAYER_NAME~','~PLAYER_ID~'); return false;\">bookmark</a>"
// ...where ~ chars delimit column values to replace for this row.
// Note that the element must NOT already exist in the "rows" 2D array, but that the
// col MUST exist in the col metadata:
function addEndOfRowButtons(rows, anchorTag, colMetadata) {
    
    for (var i=0; i<rows.length; i++) {
        var row = rows[i];
        var parsedAnchorTag = "" + anchorTag;
        while (parsedAnchorTag.indexOf("~")>-1) {
            var firstIndexOf = parsedAnchorTag.indexOf("~");
            var nextIndexOf = parsedAnchorTag.indexOf("~", firstIndexOf+1);
            var colName = parsedAnchorTag.substring(firstIndexOf+1, nextIndexOf);
            var colValue = escapeQuotes(row[getIdxFromCode(colName, colMetadata)]);
            parsedAnchorTag = parsedAnchorTag.substring(0,firstIndexOf)+colValue+parsedAnchorTag.substring(nextIndexOf+1, parsedAnchorTag.length);
        }
        row[row.length] = parsedAnchorTag;
    }
}

function escapeQuotes(s) {
    var ret = "";
    for (var i=0; i<s.length; i++) {
        var c = s.charAt(i);
        if (c == "\'") {
            ret += "\\\'";
        } else if (c == "\"") {
            ret += "\\\"";
        } else {
            ret += c;
        }
    }
    return ret;
}

function getIdxFromCode(colName, colMetadata) {
    for (var i=0; i<colMetadata.length; i++) {
        if (colMetadata[i][0] == colName) {
            return i;
        }
    }
    return -1;
}

function addPlayerLinkToRow(row, playerNameIdx, playerIdIdx, playerPosIdx) {
    var playerPos = "";
    if (playerPosIdx>=0) {
        playerPos = row[playerPosIdx];
    } else if (playerPosIdx==-1) {
        playerPos = "P";
    } else if (playerPosIdx==-2) {
        // indicates not-a-pitcher; this is all we care about for these purposes:
        playerPos = "";
    }

    if (sid==null || sid=="null") {
        sid = "wbc";
    }

    aTag = "<a class=\"playerLink\" target=\"_parent\" href=\"/app/milb/stats/stats.jsp?n="+escape(row[playerNameIdx])+"&pos="+playerPos+"&sid="+sid+"&t=p_pbp&pid="+row[playerIdIdx]+"\">"+row[playerNameIdx]+"</a>";
    row[playerNameIdx]=aTag;
}

function addClubLinks(rows, clubNameIdx, clubIdIdx) {
    for (var i=0; i<rows.length; i++) {
        var row = rows[i];
        var clubId = row[clubIdIdx];
        if (clubId!=null && clubId.length>0) {
            var clubName = row[clubNameIdx];
            // bold the current team name in stats
            if (("t" + clubId) == ((cid)?cid:sid)) {
                row[clubNameIdx] = "<span class=\"highlightTeam\">" + clubLink(clubName, clubId) + "</span>";
            } else {
                row[clubNameIdx] = clubLink(clubName, clubId);
            }
        }
    }
}

function addPlayerLinks(rows, playerNameIdx, playerIdIdx, playerPosIdx) {
    for (var i=0; i<rows.length; i++) {
        addPlayerLinkToRow(rows[i], playerNameIdx, playerIdIdx, playerPosIdx);
    }
}

function _countVisibleRows(visibilityBooleans) {
    var c = 0;
    for (var i=0; i<visibilityBooleans.length; i++) {
        c += (visibilityBooleans[i]?1:0);
    }
    return c;
}

// note: this function returns an array of strings since this increases performance compared to returning one big string
function _DataTable_getTableHTML(targetObjId,flipOrderAfterSort,finalRowContents) {

    if (arguments.length < 3) {
        finalRowContents = null;
    }
    var supressionFunctionName="returnTrue";
    for (var i=0; i<this.rowSuppressionCheckFunctionNames.length; i++) {
        if (this.currentSortColCode==this.colCodes[i]) {
            if (this.rowSuppressionCheckFunctionNames[i]!=null) {
                supressionFunctionName=this.rowSuppressionCheckFunctionNames[i];
            }
            break;
        }
    }
    var supressionFunction=window[supressionFunctionName];
    var ret=new Array(this.data.length*this.colCodes.length*5);
    var retIdx=0;
    var flipOrderAfterSortArg=flipOrderAfterSort;
    var s="<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"dataTableClass\" id=\"table_" + this.tableManagerIdx + "\">";
    
    if (!this.suppressTitleBar) {
        s+="<tr class=\"titleRow\">";
        s+="<td colspan=\""+_countVisibleRows(this.visibilities)+"\">"+this.tableTitle+"</td>";
        s+="</tr>";
    }
    
    s+="<tr "+(this.suppressHeaderRow?"style=\"display:none;\"":"")+" class=\"headerRow\">";
    var methodCallPrefix="";
    for (var c=0; c<this.colCodes.length; c++) {
        if (this.visibilities[c]) {
            s+="<td style=\"text-align:center;\">";
            if (this.sortTypes[c]!=DT_NO_SORT) {
                if (this.currentSortColCode==this.colCodes[c]) {
                    flipOrderAfterSortArg=!flipOrderAfterSort;
                }
                else {
                    flipOrderAfterSortArg=false;
                }
                s+="<a class=\"headerLinkClass\" href=\"javascript:"+methodCallPrefix+"DataTableManager.dataTables["+this.tableManagerIdx+"].displaySortedOn('"+this.colCodes[c]+"','"+targetObjId+"',"+flipOrderAfterSortArg+")\">";
            }
            s+=this.displayNames[c];
            if (this.sortTypes[c]!=DT_NO_SORT) {
                s+="</a>&nbsp;"; // added filler for cols w/o a header label
            }           
            s+="</td>";
        }
    }
    s+="</tr>";

    ret[retIdx]=s; retIdx++;
    var row;
    var initialIdx;
    var c;
    var cssClass;
    var isCurrentHighlightedRow;
    var dLength = this.data.length;
    var currColIdx = 0;
    for (var i=0; i<this.colCodes.length; i++) {
        if (this.colCodes[i]==this.currentSortColCode) {
            currColIdx = i;
            break;
        }
    }
    
    var rowCount = 0;
    for (var i=0; i<dLength; i++) {
        row = this.data[i];
        if (!supressionFunction(row[currColIdx], row)) {
            // we're not displaying this row as sorted:
            continue;
        }
        isCurrentHighlightedRow = (this.data[i][0]==this.currentHighlighedIdx);
        initialIdx = this.data[i][0];

        var rowClass = "even";
        if (rowCount % 2) { rowClass = "odd"; }

        if (isCurrentHighlightedRow) {
            ret[retIdx] = "<tr class=\"dataRow highlightRow " + rowClass + "\">\n\n"; retIdx++;
        } else {
            ret[retIdx] = "<tr class=\"dataRow " + rowClass + "\">\n\n"; retIdx++;
        }

        var rowShownFlag = false;
        for (c=0; c<this.colCodes.length; c++) {
            if (this.visibilities[c]) {
                cssClass=(this.currentSortColCode==this.colCodes[c]?"currSortDataCell":"dataCell");

                // need to move alignment to a class definition?
                ret[retIdx] = "<td id=\"cell_"+initialIdx+"\""
                +"align=\""+this.colAligns[c]+"\" class=\""+cssClass+"\" style=\"width:"+this.colWidths[c]+"px;\">"
                +this.data[i][c]
                +"</td>";

                retIdx++;
                rowShownFlag = true;
            }
        }
        if (rowShownFlag) { rowCount++; }
        ret[retIdx]="</tr>\n\n"; retIdx++
    }
    if (finalRowContents!=null) {
        ret[retIdx]="<tr><td style=\"text-align:left; background-color: transparent;\" colspan="+_countVisibleRows(this.visibilities)+">"+finalRowContents+"</td></tr>"; retIdx++
    }
    ret[retIdx]="</table>"; retIdx++;
    return ret;
}

function _DataTable_displaySortedOn(colCode,targetObjId,flipOrderAfterSort) {
    this.writePleaseWait(targetObjId);
    
    if (!flipOrderAfterSort) {
        this.sort(colCode);
    }
    else {
        // already sorted; just reversing order:
        this.data = this.data.reverse();
    }
    setTimeout("DataTableManager.dataTables["+this.tableManagerIdx+"].write('"+targetObjId+"',"+flipOrderAfterSort+")",100);
}

function _DataTable_getColIdxFromColCode(colCode) {
    for (var i=0; i<this.colCodes.length; i++) {
        if (this.colCodes[i] == colCode) {
            return i;
        }
    }
    return -1;
}

function _DataTable_sort(colCode) {
    this.currentSortColCode=colCode;
    var colIdx=this.getColIdxFromColCode(colCode);

    colCodeForSort=this.altColsForSort[colIdx];
    if (colCodeForSort==null) {
        colCodeForSort=colCode;
    }
    var colIdxForSort=this.getColIdxFromColCode(colCodeForSort);

    DataTableManager.currSortAscending=(parseInt(this.sortTypes[colIdx])==DT_SORT_ASC);
    DataTableManager.currSortColIndex=colIdxForSort;
    this.data.sort(window[this.sortFunctionNames[colIdx]]);
}

var dataTableLoaded = true;

/////////// END DATATABLE OBJECT SCRIPTS ///////////




/////////// BEGIN DATATABLEMANAGER OBJECT SCRIPTS ///////////

var managerInstanceInstantiated = false;

function _DataTableManager() {
    if (!window.requestLoaded) {
        alert("To use DataTableManager, you must import Request.js first.")
        return null;
    }
    if (!window.dataTableLoaded) {
        alert("To use DataTableManager, you must import DataTable.js first.")
        return null;
    }
    if (managerInstanceInstantiated) {
        alert("_DataTableManager cannot be instantiated more than once; use the 'DataTableManager' instance.")
        return null;
    }
    this.dataTables=[]; // holds references to all DataTables
    this.getDataTable=_DataTableManager_getDataTable;
    this.copyArray=_DataTableManager_copyArray;
    this.reorderData=_DataTableManager_reorderData;

    // bit o non-object-orientation: these are set before every sort:
    this.currSortAscending=false;
    this.currSortColIndex=-1;
}

// * raw-data: 2-dim array of data
// * rawDataColNames: array of strings which are ordered col names in the raw data array
// * colMetadata: column metadata specified for each display type
function _DataTableManager_reorderData(rawData, rawDataColNames, colMetadata) {
    var orderedIdxToRawIdx=new HashMap();
    for (var i=1; i<colMetadata.length; i++) {
        var colName=colMetadata[i][0];
        var rawIdx=-1;
        for (var j=0; j<rawDataColNames.length; j++) {
            if (rawDataColNames[j]==colName) {
                rawIdx=j;
                orderedIdxToRawIdx.put(i, rawIdx);
                break;
            }
        }
        if (rawIdx==-1) {
            // okay; sometimes this will happen:
            //alert("col metadata specifies a col '"+colName+"', but the data says it doesn't contain such a column.")
            //break
        }
    }
    var orderedData=[];
    for (var i=0; i<rawData.length; i++) {
        var row=[];
        row[0]=i; // INITIAL_IDX
        for (var j=1; j<colMetadata.length; j++) {
        //alert(""+orderedIdxToRawIdx.get(j)+" to "+j+"")
            row[j]=rawData[i][orderedIdxToRawIdx.get(j)+1];
        }
        orderedData[i]=row;
    }
    return orderedData;
    
}

function _DataTableManager_getDataTable(data, colMetadata, initialSortColCode, tableTitle) {
    var dataTable=new DataTable(data, colMetadata, initialSortColCode, tableTitle);
    dataTable.tableManagerIdx=this.dataTables.length;
    this.dataTables[dataTable.tableManagerIdx]=dataTable;
    return dataTable;
}

function _DataTableManager_copyArray(a) {
    if (a==null) {
        return null;
    }
    var ret=[];
    for (var i=0; i<a.length; i++) {
        ret[i]=a[i];
    }
    return ret;
}

// "native" sort functions (others can be added to implementing pages):
function alphaSort(a1, a2) {
    var idx=DataTableManager.currSortColIndex;
    var s1=(a1[idx]==null?"":""+a1[idx]);
    var s2=(a2[idx]==null?"":""+a2[idx]);
    if (s1==s2) {
        return 0;
    }
    var ret=(s1>s2?1:-1);
    return (DataTableManager.currSortAscending?ret:ret*-1);
}

function numericSort(a1, a2) {
    var idx = DataTableManager.currSortColIndex;
    var n1 = a1[idx];
    var n2 = a2[idx];
    var ret; 

    if (n1 == "*.**") { n1 = Number.POSITIVE_INFINITY; }  // handle when ERA passed as something other than a number
    if (n2 == "*.**") { n2 = Number.POSITIVE_INFINITY; } 

    if (n1 == "-") { n1 = Number.NEGATIVE_INFINITY; }  // handle "empty" stats
    if (n2 == "-") { n2 = Number.NEGATIVE_INFINITY; } 
    if (n1 == "---") { n1 = Number.NEGATIVE_INFINITY; } 
    if (n2 == "---") { n2 = Number.NEGATIVE_INFINITY; } 

    try { 
        var re = /,/g;  // strip commas before trying to parse the number
        n1 = (n1?parseFloat(n1.replace(re,"")):0);
        n2 = (n2?parseFloat(n2.replace(re,"")):0);
    } catch (e) { }

    if (n1 == n2) {
        return 0
    }
    ret = (n1 > n2?1:-1);
    return (DataTableManager.currSortAscending?ret:ret*-1);   // reverse sort order if not ascending
}

var DataTableManager = new _DataTableManager();

// needs to be defined here because some types don't define it:
var dataTable1 = null;

var dataTableManagerLoaded = true;

/////////// END DATATABLEMANAGER OBJECT SCRIPTS ///////////



/////////// START GENERAL SCRIPTS ///////////


// used for filtering of many columns:
function isOverZero(v, rowArr) {
    // note: rowArr is ignored
    if (v == null || v == "") {
        v = 0;
    } 
    v = parseFloat(v);
    return (v>0);
}

// actually NOT at-bats minimum but total-plate-appearances minimum:
function meetsAtBatsMinimum(v, rowArr) {
    // ouch: I need to not have the col idx hardcoded: 
    var totalPlateAppearances=rowArr[25]; // TPA
    var teamGamesPlayed=rowArr[6];        // TEAM_GAME

    return (totalPlateAppearances > reqdAtBatsForLeagueLeaders * teamGamesPlayed);
}

// used for filtering of many columns:
function meetsInningsPitchedMinimum(v, rowArr) {
    // ouch: I need to not have the col idx hardcoded:
    var totalInningsPitched=rowArr[15]; // IP_SORT
    var teamGamesPlayed=rowArr[4];      // TEAM_GAME

    return (totalInningsPitched > reqdInningsPitchedLeagueLeaders * teamGamesPlayed);
}

function getYmdParam(dateObj) {
    if (typeof dateObj=="undefined") {
        alert("in getYmdParam(), dateObj is undefined.");
    }
    var yr = "" + dateObj.getFullYear();
    var mo = dateObj.getMonth() + 1;
    if (("" + mo).length==1) {
        mo = "0" + mo;
    }
    var dt = dateObj.getDate()
    if (("" + dt).length == 1) {
        dt = "0" + dt;
    }
    return yr + mo + dt;
}

function returnTrue() {
    //function that always returns true
    return true;
}

var typesToSuffixesMap = new HashMap();
typesToSuffixesMap.put("l_bat","playerBatLead"); // league leaders, batting
typesToSuffixesMap.put("l_pit","playerPitLead"); // league leaders, pitching
typesToSuffixesMap.put("l_att","att");
typesToSuffixesMap.put("l_sta","sta");
typesToSuffixesMap.put("l_tra","tra");
typesToSuffixesMap.put("l_sco","sco");
typesToSuffixesMap.put("t_ros","ros");
typesToSuffixesMap.put("t_sch","sch");
typesToSuffixesMap.put("g_box","box");
typesToSuffixesMap.put("g_lin","lin");
typesToSuffixesMap.put("g_log","log");
typesToSuffixesMap.put("g_wra","wra");
typesToSuffixesMap.put("l_tba","teamBat"); // league-level team batting
typesToSuffixesMap.put("l_tpi","teamPit"); // league-level team pitching
typesToSuffixesMap.put("t_tst","teamLeagueRec"); // team stats

typesToSuffixesMap.put("t_alu",null); // alumni report: unlike other resultsets, handled as a special case since two files may have to be imported
typesToSuffixesMap.put("t_ibp",null); // individual batting, pitching: unlike other resultsets, handled as a special case since two files may have to be imported
typesToSuffixesMap.put("p_pbp",null); // player batting, pitching: unlike other resultsets, handled as a special case since two files may have to be imported

var entityId = "";
var statsTier = "";
var altDefaultSortCol = request.getParameter("adsc");
// for when we potentially have two different table types on a page (e.g. batting and pitching):
var altDefaultSortCol2 = request.getParameter("adsc2");
var clubId = request.getParameter("cid");
var leagueId = request.getParameter("lid");
var gameId = request.getParameter("gid");
var playerId = request.getParameter("pid");
var type = request.getParameter("t");
var year = request.getParameter("y");
if (year == null) {
    year = defaultYear;
}
var statsTierShort = "";

if (clubId == null) {
    clubId = "wbc";
}
if (type == null) {
    if (!(window["isLinescorePage"])) {
        //        alert("Error: t param (type) not specified.");
        window.status = "Error: t param (type) not specified.";
    }
    else {
        type = "t_lin";
    }
}

if (type.indexOf("l_")==0) {
    statsTier="leagues";
    statsTierShort="l";
    if (leagueId==null) alert("Error: lid param (league ID) not specified.");
    entityId=leagueId;
} else if (type.indexOf("g_")==0) {
    statsTier="games";
    statsTierShort="g";
    if (gameId==null) alert("Error: gid param (game ID) not specified.");
    entityId=gameId;
} else if (type.indexOf("p_")==0) {
    statsTier="players";
    statsTierShort="p";
    if (playerId==null) alert("Error: pid param (player ID) not specified.");
    entityId=playerId;
} else if (type.indexOf("t_")==0) {
    statsTier="clubs";
    statsTierShort="t";
    entityId=clubId;
}

var filenameSuffix = typesToSuffixesMap.get(type);

var ymdParam = null;

// Get the data:
if (!(window["isLinescorePage"])) {
    if (filenameSuffix!=null) {
        // if filename suffix isn't null, then we just import the data 
        // (with the exception of wraps and scoreboards; these special cases 
        // is handled in this clause too), which will 
        // be in the form of an array called "raw":
        if (!(type=="g_wra")) {
            if (type=="l_sco") {
                // special case: need to import a date-specific scoreboard datafile:
                ymdParam=request.getParameter("ymd");
                if (ymdParam==null) {
                    ymdParam=getYmdParam(getNowDate());
                }
                var dataUrl="/gen/2006/stats/jsdata/"+year+"/leagues/l"+leagueId+"_"+ymdParam+"_sco.js";
            } else if (type=="l_tra") {
                // special case: need to import a month-specific transactions datafile
                ymdParam=request.getParameter("ymd");
                if (ymdParam==null) {
                    ymdParam=getYmdParam(getNowDate()).substring(0,6);
                }
                
                var dataUrl="/gen/2006/stats/jsdata/"+year+"/leagues/l"+leagueId+"_"+ymdParam+"_tra.js";

            } else if (type=="l_sta") {
                // special case: we need to look at if we're showing current, or 1st half standings
                //
                // this is passed by the 'period' param, which is
                // set to h1 when looking for first half standings
                periodParam=request.getParameter("period");

                if (periodParam == "h1") {
                    var dataUrl="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_"+filenameSuffix+"_h1.js";
                } else {

                    var dataUrl="/gen/2006/jsdata/"+statsTier+"/"+statsTierShort+""+entityId+"_"+filenameSuffix+".js";



                }

            } else {
                // special case: we need to look at if we're showing current, or just post season stats
                //
                // this is passed by the 'period' param, which is
                // set to 'playoff' for post season batting/pitching playoff stats

                if (type == "g_lin") { 
                    var dataUrl="/gen/2006/jsdata/games/g"+entityId+"_lin.js";
                } else { 
                    var dataUrl="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_"+filenameSuffix+".js";
                }


            }
            ScriptIncluder.include(dataUrl, true);
        } 
        else {
            var gameIdForPath=gameId.replace(/\//g,"_").replace(/-/g,"_");
            var dataUrl="/gen/2006/stats/jsdata/games/"+gameIdForPath+"/wrap.js";
            ScriptIncluder.include(dataUrl, true);
        }
    }
    else {
        // else null, which means we have to handle the importing of data as a
        // special case, because two datasets (batting, pitching) need
        // to be imported:
        if (type=="t_alu") {
            // alumni report:
            var dataUrl1="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_playerBatAlum.js";
            var dataUrl2="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_playerPitAlum.js";
            ScriptIncluder.include(dataUrl1, true);
            ScriptIncluder.include(dataUrl2, true);
        }
        else if (type=="t_ibp") {
            // indiv batting/pitching:


            var dataUrl1="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_playerBat.js";
            var dataUrl2="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"_playerPit.js";

            ScriptIncluder.include(dataUrl1, true);
            ScriptIncluder.include(dataUrl2, true);
        }
        else if (type=="p_pbp") {
            // player-level batting, pitching:
            if (entityId.indexOf("#")>-1) {
                entityId=entityId.substring(0, entityId.length-1);
            }
            var dataUrl1="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"Bat.js";
            var dataUrl2="/gen/2006/stats/jsdata/"+year+"/"+statsTier+"/"+statsTierShort+""+entityId+"Pit.js";
            ScriptIncluder.include(dataUrl1, true);
            ScriptIncluder.include(dataUrl2, true);
        }
    }
} else {


    var dataUrl="/gen/2006/jsdata/games/g"+request.getParameter("gid")+"_lin.js";
    ScriptIncluder.include(dataUrl, true);
}

// Get the scripts to write the data for this type of resultset:
if (!(window["isLinescorePage"])) {
    var dataWriter = "/" + year + "/scripts/stats/datawriters/" + type + ".jsp";
    if (localize) { dataWriter += "?sid=" + sid + "&loc=1"; }
    ScriptIncluder.include(dataWriter, false);
} else {
    // Get the scripts to write the data for this type of resultset:
    var filename = "";
    if (typeof isGameStatusLinescore == "undefined") {
        isGameStatusLinescore = false;
    }
    if (isGameStatusLinescore) {
        filename = "g_lsg.jsp";
    } else {
        filename = "g_lin.jsp";
    }
    var dataWriter = "/" + year + "/scripts/stats/datawriters/" + filename;
    if (localize) { dataWriter += "?sid=" + sid + "&loc=1"; }
    ScriptIncluder.include(dataWriter, true);
}

/////////// END GENERAL SCRIPTS ///////////