/*
	XML files will be in an array. This is for a synchronous parsing. 
	There are asynchronous parsing issues where the xml will not be loaded. This has resolved the issues.
	
	livescores and livescoresThin can use the same xml process, but must be ran separately (page).
	
	- Helcon Mabesa
*/

/* global variables used all over */
var timeoutInterval = 20000; //request timeout interval
var xmlHttp = null; // variable holder for the httprequest method
var gameID = null;
var gameDate = null;
var gamesLive = false;
var sb_gameID = null;
var sb_gameDate = null;


var isLive = false;
var fadeForLive = false;
var fadeForLiveLV = false;
var pastHalf = false;
var fadeForHalf = false;


var showNotesLink = true; //default to true after all stars

var errorLogs = ""; //error logs - fuction in helper class errorLogger() pop-up window should be activated to view the logs

var numOfGames = 0; //this is for the number of game nodes 
var numOfPlayers = 0; //this is for the total number of player nodes 
var refNodeExists = false; //boolean to check if there are referee nodes
var messageID = 0; //message id attribute holder. used for checking of new id
var messageIDScr = 0; //for scoreboard
var loadCounter = 0; //xml load counter since initial load

var sb_loadCounter = 0; //xml load counter since initial load
var sb_messageID = "";
var sb_loadCounter = 0;
var sb_numOfGames = 0; //this is for the number of overall games 

//PBP Variables
var PBPID = 0;
var arrOfPBPData = null;
var arrOfPBPIndex = null;
var PBPLoadCounter = 0; //xml load counter since initial load
var PBPCounter = -1; //for the play-by-play array
var  maxPBPEvent = 0; //this is the event tracker to get the max pbp event id


/* ARRAYS DEFINITIONS */
//node arrays
var arrOfTeamData = null;
var arrOfGameData = null;
var arrOfOfficialsData = null;
var arrOfPlayersData = null;

var arrOfOfficialsIndex = null;
var arrOfTeamIndex = null;
var arrOfGameIndex = null;
var arrOfPlayersIndex = null;

var sb_arrOfGameData = null;
var sb_arrOfTeamData = null;

var sb_arrOfGameIndex = null; 
var sb_arrOfTeamIndex = null;
var oldScrObj = null;
var oldScrBxObj = new Array();

//array counters
var teamCounter = -1; // counter for team array
var gameCounter = -1; // game
var refCounter = -1; // offical
var vplyrCounter = -1; // player
var hplyrCounter = -1; // home team player
var plyrCounter = -1; // visitor
var sb_teamCounter = -1; // team array scoreboard
var sb_gameCounter = -1; // game array

//preload images
var img4 = new Image();
img4.src = "/images/ls_listen_btn.gif";

/****************************************************************************
START - MAIN FUNCTIONS 
****************************************************************************/

var main = {
	
	//IT ALL STARTS HERE
	initXMLHttp : function() {
		//parseXML = false; //re-initialize this
		window.status = ""; //just for display
	
		//set up xmlhttp request
		try {
			//xmlHttp = helper.setXMLHttpRequest();
		
			main.getXMLData();
		
			//timer = new Date();
			
			setTimeout("main.initXMLHttp()", timeoutInterval);
		
		}
		catch(e) {
			helper.errorLogger("XML Initialization error ", "initXMLHttp", "none", e.message);
		}
		
	},
	
	//SYNCHRONOUS XML PARSER
	getXMLData : function() {
		
		var getFeed = (sb_loadCounter%20==0);
		
		var callBack = "";
		var xmlDoc = null;
		//var requestMethod = xmlHttpMethod;
		var loader = new Array();
		
		try {
			
				for (var x =0; x < xmlFiles.length; x++) {
				     var passID = "";
					//new Array("livescores", "/scores/boxscore.jsp?gamecode=20060106/ORLNJN");
					switch(xmlFiles[x][0]) {
						case ("livescores") : {
							passID = messageID; 
							callBack = main.xmlProcessData;
						break;
						}	
						case ("playbyplay") : {
							passID = PBPID; 
							callBack = pbp.xmlProcessDataPBP;
						break;
						}
						case ("sb") : {
							passID = messageIDScr; 
							callBack = scoreboard.sb_xmlProcessData;
						break;
						}
						case ("fullsb") : {
							passID = messageIDScr; 
							callBack = scoreboard.sb_xmlProcessData;
						break;
						}
						
						case ("rss") : { 
							passID = messageIDScr; 
							callBack = rss.xmlProcessData;
						break;
						}
												
					}
			
                                         //alert(callBack);
                                        if (xmlFiles[x][1].indexOf(".xml") < 0){

                                                var msg=(passID==0)?'':'&msgID='+passID;

                                                var getUrl = xmlFiles[x][1] + msg;

                                                loader[loader.length] = new net.ContentLoader(getUrl,callBack,null,null,null,null,xmlFiles[x][0]);
                                         } else {
                                                var getUrl = xmlFiles[x][1];
                                                loader[loader.length] = new net.ContentLoader(getUrl,callBack,null,null,null,null,xmlFiles[x][0]);

                                                //var d = new Date();
                                                //var cToday = d.getSeconds();
                                                //var getUrl = xmlFiles[x][1] //+ "&cbus="+cToday;
                                                // rsslimit capper
                                                //if (getFeed){
                                                        //loader[loader.length] = new net.ContentLoader(getUrl,callBack,null,null,null,null,xmlFiles[x][0]);
                                                //}
                                         }

				}
		

		}
		catch (e) {
			helper.errorLogger("XML Parsing error ", "getXMLData", "", e.message);
		}
		
	},
	
	
	//INITIAL PROCESSING OF XML DATA (LIVESCORES)
	xmlProcessData : function() {
		
		/* CHECK IF ERROR NODE */
		
		var xmlType = this._xmlType;
		var xmlData = this.req.responseXML.documentElement;		
		
		
		if (xmlData.nodeName == "error") {
			window.status = "no XML data";
		}
		else {
			
			loadCounter++; //increment per xml loading
			//alert(loadCounter);
	
			/* LEVEL TWO CHECKING  - check for current message ID. This is after the xml has been parsed, though. */
			var idChange = false;
			var curMessageID = helper.getAttrib(xmlData, "id");
			
	
			if (messageID == 0 || messageID == null) { 
				messageID = curMessageID;
				
				idChange = true;
			}
			else {
		
				if (messageID != curMessageID) {
					if (curMessageID > messageID) {
						messageID = curMessageID;
						idChange = true;
					}
					else {
						idChange = false;
					}
				}
			}
			
			if (idChange) { //parse xml NOW!!!!!
		
				//window.status += " NEW DATA!!!";
				gameDate = helper.getAttrib(xmlData, "gdt");
				
				teamCounter = -1; // team arrays
				gameCounter = -1; // game
				refCounter = -1; // officials
				plyrCounter = -1; // player(indexed array)
				vplyrCounter = -1; // visitor
				hplyrCounter = -1; // home
		
		
				var cNode = xmlData.childNodes;
				numOfGames = helper.nodeCounter(cNode); //define number of games with this global variable
				refNodeExists = main.checkRefNodes(cNode); //check if there exists a referee node
				
				if (loadCounter ==1) { // ALL loadCounter if clauses are ran only during first load of xml
					//declare arrays
					arrOfGameData = new Array();
					arrOfGameIndex = new Array();
			
					arrOfTeamData = new Array();
					arrOfTeamIndex = new Array();
			
					if (refNodeExists) { //declare only if there are officials node
						arrOfOfficialsData = new Array();
						arrOfOfficialsIndex = new Array();
					}
			
					//count the total number of player nodes in this xml
					numOfPlayers = main.countNumPlayerNodes(cNode);
					
					if (numOfPlayers > 1) { //players array only defined when there are player nodes
						arrOfPlayersData = new Array();
						arrOfPlayersIndex = new Array();
					}
				
				}
		
				for (var xNode = 0; xNode < cNode.length; xNode++) {
					if (helper.chkNType(cNode[xNode]) == 1) 
						main.nodeFunctions(cNode[xNode]); //node breakdown
				}
		
				//DISPLAY
				display.buildGameOutputData(xmlType);
		
			}
			else { //no change in message id
	
				//window.status += " no new boxscore data...";	
		
			}
	
		}
		
	},
	
	//THIS WILL BREAK DOWN THE NODES (LIVESCORES)
	nodeFunctions : function(node) {
		
		//START - CHECK FOR GAME NODES
		if ((node.nodeName).toLowerCase() == "game") {
		
			//check if there are games live
			if (!gamesLive)
				if (helper.getAttrib(node, "gstat") == "2")
					gamesLive = true;
		
			gameCounter++;//increment number of games in array
			//process game node (HIGHEST LEVEL)
			main.gameNode_Populate(this.gameNode_Data(node), gameCounter, "game");
		
			//get data from game's child nodes (SECOND LEVEL)
			var gameChild = node.childNodes;
			for (var ch = 0; ch < gameChild.length; ch++) {
				if (helper.chkNType(gameChild[ch])==1) {
					//grab team nodes
					if ((gameChild[ch].nodeName).toLowerCase() == "vtm" || (gameChild[ch].nodeName).toLowerCase() == "htm") {
						
						teamCounter++; //increment team number in array
						//process team node
						main.gameChild_TeamPopulate(this.gameNode_Data(gameChild[ch]), gameChild[ch].nodeName, teamCounter, gameChild[ch].nodeName);
					
						//grab for player nodes (if there are any)
						var tmPlayers = gameChild[ch].childNodes;
						for (var tch = 0; tch < tmPlayers.length; tch++) {
							if	(helper.chkNType(tmPlayers[tch])==1) {
								//data per player
								if ((tmPlayers[tch].nodeName).toLowerCase() == "pl") {
									
									//increment player number in array
									plyrCounter++;
									var tmpPlyrCounter = 0;
									if ((gameChild[ch].nodeName).toLowerCase() == "vtm") {
										vplyrCounter++;
										tmpPlyrCounter = vplyrCounter;
									}
									else {
										hplyrCounter++;
										tmpPlyrCounter = hplyrCounter;
									}
									//process player nodes
									main.teamChild_PlayersPopulate(this.gameNode_Data(tmPlayers[tch]), tmpPlyrCounter, gameChild[ch].nodeName, tmPlayers[tch].nodeName, plyrCounter);
								
								}
							}
						}
					
					}
				
					//grab officials nodes
					if ((gameChild[ch].nodeName).toLowerCase() == "officials") {
					
						refCounter++;
						main.gameChild_OfficialsPopulate(this.gameNode_Data(gameChild[ch]), refCounter, gameChild[ch].nodeName);

					}
				
				}
			}
		
		}
		
	},
	
	/****************************************************************************
	END - MAIN FUNCTIONS 
	****************************************************************************/

	/****************************************************************************
	START - DATA HANDLE FUNCTIONS 
	****************************************************************************/
	
	//PUTS ALL THE ATTRIBUTE DATA INTO ONE SINGE STRING
	gameNode_Data : function(gmNnode) {
		
		var returnThis = "";
		var tempStr = "";
		var attrName = "";
	
		for (var x = 0; x < gmNnode.attributes.length; x++) {
			attrName = gmNnode.attributes[x].nodeName;
			tempStr = helper.getAttrib(gmNnode, attrName);
		
			if (x == 0) 
				returnThis += attrName + "~" + tempStr;
			else
				returnThis += "@!" + attrName + "~" + tempStr;
		}
	
		//specifically get the data of the event node (play-by-play)
		if ((gmNnode.nodeName).toLowerCase() == "event")
			returnThis += "@!" + "pbptext" + "~" + gmNnode.childNodes[0].data; 
	
		return	returnThis;
		
	},
	
	//COUNT THE TOTAL NUMBER OF PLAYER NODES FOR ARRAY PURPOSES
	countNumPlayerNodes : function(mainNode) {
		
		var h = helper;
		
		var nodeCount = -1;
		for (var x = 0; x < mainNode.length; x++) {
			if (h.chkNType(mainNode[x]) == 1) {
				if ((mainNode[x].nodeName).toLowerCase() == "game") {
					for (var y = 0; y < mainNode[x].childNodes.length; y++) {
						mainChild = mainNode[x].childNodes[y];
						if (h.chkNType(mainChild) == 1) {
							if (mainChild.nodeName == "vtm" || mainChild.nodeName == "htm") {
								for (var z = 0; z < mainChild.childNodes.length; z++) {
									playerChild = mainChild.childNodes[z];
									if (h.chkNType(playerChild) == 1) {
										if (playerChild.nodeName == "pl")
											nodeCount++;
									} } } } } } }
		}
		return nodeCount;
		
	},
	
	//CHECK IF THERE IS AN OFFICIALS NODE
	checkRefNodes : function(mainNode) {
		
		var nodeExists = false;
		for (var x = 0; x < mainNode.length; x++) {
			if (helper.chkNType(mainNode[x]) == 1) {
				if ((mainNode[x].nodeName).toLowerCase() == "game") {
					for (var y = 0; y < mainNode[x].childNodes.length; y++) {
						mainChild = mainNode[x].childNodes[y];
						if (helper.chkNType(mainChild) == 1) 
							if (mainChild.nodeName == "officials") 
								nodeExists = true;
					} } }
		}
		return nodeExists;

	},
	
	/****************************************************************************
	END - DATA HANDLE FUNCTIONS 
	****************************************************************************/
	
	/****************************************************************************
	START - DATA ARRAY STORAGE FUNCTIONS 
	****************************************************************************/
	
	//POPULATE GAME NODE
	gameNode_Populate : function(gmNdata, dCounter, dNodeName) {
		
		var nodeSplit = null;
		var nodes = gmNdata.split("@!"); // split
		var attribName = "";
	
		//this is for game id only. check from the nodes what value game id is
		var id = "";
		for (i = 0; i < nodes.length; i++) {
			id = nodes[i].split("~");
			if (id[0] == "id") {
				gameID = id[1]; //global variable
			}
		}
	
		//SPECIFIC ARRAY NAME ASSIGNMENT ( ex. [game-123456789] )
		var arrayName = dNodeName + "-" + gameID;
		
		if (loadCounter == 1)  //create the game object only on first load.
			arrOfGameData[arrayName] = new Object();
	
		for (var xSplit = 0; xSplit < nodes.length; xSplit++) {
			nodeSplit = nodes[xSplit].split("~"); //per game attribute split
		
			if (loadCounter == 1) { //initial loading of data into object
				//these are the attributes that has to be split again and store into the object	
				if (nodeSplit[0] == "arn")
					main.attribSplitFunctions (nodeSplit, arrayName, dNodeName);
				
				if (nodeSplit[0] == "timet" || nodeSplit[0] == "timloc" || nodeSplit[0] == "timh" || nodeSplit[0] == "timv")
					//convert times to 12-hr am/pm format
					nodeSplit[1] = helper.setStrTime(nodeSplit[1]);
			
					//store data into the object	
					arrOfGameData[arrayName][nodeSplit[0]] = nodeSplit[1];
			
			}
			else {	//only those attributes that are known to change are checked.
				if (nodeSplit[0] == "gstat" || nodeSplit[0] == "gstattxt" || nodeSplit[0] == "clk" || nodeSplit[0] == "tie" || nodeSplit[0] == "poss" || nodeSplit[0] == "seq" || nodeSplit[0] == "rcp" || nodeSplit[0] == "prd") {
					if (arrOfGameData[arrayName][nodeSplit[0]] != nodeSplit[1]) 
						arrOfGameData[arrayName][nodeSplit[0]] = nodeSplit[1]; 
				}
			}
		
		}
	
		if (loadCounter == 1) { //for data which are specified and only loaded once
			arrOfGameData[arrayName].id = gameID;
			arrOfGameData[arrayName].date = gameDate;
			arrOfGameIndex[dCounter] = arrOfGameData[arrayName]; // indexed array
		}
		
	},
	
	//HOME TEAM AND VISITING TEAM
	gameChild_TeamPopulate : function(gmCdata, dTeam, dCounter, dNodeName) {
		
		var nodeSplit = null;
		var nodes = gmCdata.split("@!");
		var arrayName = dNodeName + "-" + gameID;
	
		if (loadCounter == 1) 
			arrOfTeamData[arrayName] = new Object();
	
		for (var xSplit = 0; xSplit < nodes.length; xSplit++) {
			nodeSplit = nodes[xSplit].split("~");
		
			if (loadCounter == 1) {
			
				if (nodeSplit[0] == "tm" || nodeSplit[0] == "std" || nodeSplit[0] == "brd" || nodeSplit[0] == "scr" || nodeSplit[0] == "stat" || nodeSplit[0] == "gstat" || nodeSplit[0] == "tstat" || nodeSplit[0] == "timout" || nodeSplit[0] == "pld" || nodeSplit[0] == "rld" || nodeSplit[0] == "ald" || nodeSplit[0] == "bld")
					main.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
			
				arrOfTeamData[arrayName][nodeSplit[0]] = nodeSplit[1];
			
			}
			else {
			
				if (nodeSplit[0] == "std" || nodeSplit[0] == "rcd" || nodeSplit[0] == "scr" || nodeSplit[0] == "stat" || nodeSplit[0] == "gstat" || nodeSplit[0] == "tstat" || nodeSplit[0] == "timout" || nodeSplit[0] == "pld" || nodeSplit[0] == "rld" || nodeSplit[0] == "ald" || nodeSplit[0] == "bld" || nodeSplit[0] == "tfoul")
					if (arrOfTeamData[arrayName][nodeSplit[0]] != nodeSplit[1]) {//check for new data
						if (nodeSplit[0] == "std" || nodeSplit[0] == "scr" || nodeSplit[0] == "stat" || nodeSplit[0] == "gstat" || nodeSplit[0] == "tstat" || nodeSplit[0] == "timout")
							this.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
						arrOfTeamData[arrayName][nodeSplit[0]] = nodeSplit[1];
					}
			
			}
		
		}
	
		if (loadCounter == 1) {
			arrOfTeamData[arrayName].id = gameID;
			arrOfTeamData[arrayName].teamident = dTeam;
			arrOfTeamIndex[dCounter] = arrOfTeamData[arrayName];
		}
		
	},
	
	//GAME OFFICIALS
	gameChild_OfficialPopulate : function(gmCdata, dCounter, dNodeName) {
		
		var nodeSplit = null;
		var nodes = gmCdata.split("@!"); 
		var arrayName = dNodeName + "-" + gameID;
	
		if (loadCounter == 1) 
			arrOfOfficialsData[arrayName] = new Object();

		for (var xSplit = 0; xSplit < nodes.length; xSplit++) {
			nodeSplit = nodes[xSplit].split("~"); //per official attribute split
		
			if (loadCounter == 1) {
				arrOfOfficialsData[arrayName].id = gameID;
				arrOfOfficialsData[arrayName].nm = nodeSplit[1];
				main.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
			}
		
		}
	
		if (loadCounter == 1) 
			arrOfOfficialsIndex[dCounter] = arrOfOfficialsData[arrayName];
		
	},
	
	//PLAYERS
	teamChild_PlayersPopulate : function(tmPData, dCounter, dTeamNode, dNodeName, pCounter) {
		
		var nodeSplit = null;
		var nodes = tmPData.split("@!");
		var arrayName = dNodeName + "_" + dTeamNode + "-" + gameID + "-" + dCounter;
	
	
		if (loadCounter == 1)
			arrOfPlayersData[arrayName] = new Object();
	
		for (var xSplit = 0; xSplit < nodes.length; xSplit++) {
			nodeSplit = nodes[xSplit].split("~");
		
			if (loadCounter == 1) {
			
				if (nodeSplit[0] == "name" || nodeSplit[0] == "stat")
					this.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
				arrOfPlayersData[arrayName][nodeSplit[0]] = nodeSplit[1];
			
			}
			else {
				if (arrOfPlayersData[arrayName][nodeSplit[0]] != nodeSplit[1]) {
					if (nodeSplit[0] == "name" || nodeSplit[0] == "stat") 
						main.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
					arrOfPlayersData[arrayName][nodeSplit[0]] = nodeSplit[1];
				}
			}
		
		}
	
		if (loadCounter == 1) {
			arrOfPlayersData[arrayName].id = gameID; //game id
			arrOfPlayersData[arrayName].teamident = dNodeName + "_" + dTeamNode;
			arrOfPlayersIndex[pCounter] = arrOfPlayersData[arrayName]; //place in indexed array
		}
		
	},
	
	
	gameChild_OfficialsPopulate : function(gmCdata, dCounter, dNodeName) {

		var nodeSplit = null;
		var nodes = gmCdata.split("@!");
		var arrayName = dNodeName + "-" + gameID;
		
		if (loadCounter == 1) 
			arrOfOfficialsData[arrayName] = new Object();

		for (var xSplit = 0; xSplit < nodes.length; xSplit++) {
			nodeSplit = nodes[xSplit].split("~");
		
			if (loadCounter == 1) {
			
				arrOfOfficialsData[arrayName].id = gameID;
				arrOfOfficialsData[arrayName].nm = nodeSplit[1];
			
				main.attribSplitFunctions(nodeSplit, arrayName, dNodeName);
		
			}
		
		}
	
		if (loadCounter == 1) 
			arrOfOfficialsIndex[dCounter] = arrOfOfficialsData[arrayName]; //place in indexed array
	
	},
	
	
	//SPLITTING ATTRIBUTES WITH MULTIPLE DATA
	attribSplitFunctions : function(attrib, arrayName, nodeName) {
		
		var attribName = attrib[0];
		var attribData = attrib[1];
	
		var splitData  = null; 
		var data = null;
	
		splitData = attribData.split("|");
	
		for (var x = 0; x < splitData.length; x++) {
		
			data = splitData[x];
	
			//split for arena
			if (attribName == "arn") {
				
				switch (x) {
					case 0: arrOfGameData[arrayName].arena_id = data; break;
					case 1: arrOfGameData[arrayName].arena_name = data; break;
					case 2: arrOfGameData[arrayName].arena_loc = data; break;
					case 3: arrOfGameData[arrayName].arena_att = data; break;
					case 4: arrOfGameData[arrayName].arena_cap = data; break;
				}
			}
		
			//split for team
			if (attribName == "tm")
				switch (x) {
					case 0: arrOfTeamData[arrayName].team_id = data; break;
					case 1: arrOfTeamData[arrayName].team_name = data; break;
					case 2: arrOfTeamData[arrayName].team_city = data; break;
					case 3: arrOfTeamData[arrayName].team_abr = data; break;
				}
		
			//split for standings
			if (attribName == "std")
				switch (x) {
					case 0: arrOfTeamData[arrayName].std_conf = data; break;
					case 1: arrOfTeamData[arrayName].std_div = data; break;
				}
		
			//split for team broadcaster	
			if (attribName == "brd") 
				switch (x) {
					case 0: arrOfTeamData[arrayName].brdcst_tv = data; break;
					case 1: arrOfTeamData[arrayName].brdcst_rd = data; break;
				}
		
			//split for score
			if (attribName == "scr")
				switch (x) {
					case 0: arrOfTeamData[arrayName].score_q1 = data; break;
					case 1: arrOfTeamData[arrayName].score_q2 = data; break;
					case 2: arrOfTeamData[arrayName].score_q3 = data; break;
					case 3: arrOfTeamData[arrayName].score_q4 = data; break;
					case 4: arrOfTeamData[arrayName].score_ot1 = data; break;
					case 5: arrOfTeamData[arrayName].score_ot2 = data; break;
					case 6: arrOfTeamData[arrayName].score_ot3 = data; break;
					case 7: arrOfTeamData[arrayName].score_ot4 = data; break;
					case 8: arrOfTeamData[arrayName].score_final = data; break;
				}
		
			//splits for group stats
			if (attribName == "gstat")
				switch (x) {
					case 0: arrOfTeamData[arrayName].group_reb = data; break;
					case 1: arrOfTeamData[arrayName].group_fgp = data; break;
					case 2: arrOfTeamData[arrayName].group_3pp = data; break;
					case 3: arrOfTeamData[arrayName].group_ftp = data; break;
					case 4: arrOfTeamData[arrayName].group_to = data; break;
				}
		
			//splits for team stats
			if (attribName == "tstat")
				switch (x) {
					case 0: arrOfTeamData[arrayName].team_fbpts = data; break;
					case 1: arrOfTeamData[arrayName].team_llead = data; break;
					case 2: arrOfTeamData[arrayName].team_upts = data; break;
					case 3: arrOfTeamData[arrayName].team_ppts = data; break;
				}
		
			//splits for timeouts
			if (attribName == "timout")
				switch (x) {
					case 0: arrOfTeamData[arrayName].to_tk = data; break;
					case 1: arrOfTeamData[arrayName].to_fulltk = data; break;
					case 2: arrOfTeamData[arrayName].to_20tk = data; break;
				}
		
			//splits for player name
			if (attribName == "name" &&  nodeName == "pl")
				switch (x) {
					case 0: arrOfPlayersData[arrayName].player_id = data; break;
					case 1: arrOfPlayersData[arrayName].player_code = data; break;
					case 2: arrOfPlayersData[arrayName].player_name = data; break;
					case 3: arrOfPlayersData[arrayName].player_status = data; break;
					case 4: arrOfPlayersData[arrayName].player_pos = data; break;
					case 5: arrOfPlayersData[arrayName].player_jersey = data; break;
				}
		
			//splits for player stats line (PLAYER)
			if (attribName == "stat") {
		
				if (nodeName == "pl")
					switch (x) {
						case 0: {
							if (data == ":" || data == undefined || data == "")
								data = "00:00";
							arrOfPlayersData[arrayName].stat_min = data; break;
						}
						case 1: arrOfPlayersData[arrayName].stat_fg = data; break;
						case 2: arrOfPlayersData[arrayName].stat_3p = data; break;
						case 3: arrOfPlayersData[arrayName].stat_ft = data; break;
						case 4: arrOfPlayersData[arrayName].stat_oreb = data; break;
						case 5: arrOfPlayersData[arrayName].stat_dreb = data; break;
						case 6: arrOfPlayersData[arrayName].stat_treb = data; break;
						case 7: arrOfPlayersData[arrayName].stat_ast = data; break;
						case 8: arrOfPlayersData[arrayName].stat_pf = data; break;
						case 9: arrOfPlayersData[arrayName].stat_stl = data; break;
						case 10: arrOfPlayersData[arrayName].stat_to = data; break;
						case 11: arrOfPlayersData[arrayName].stat_blk = data; break;
						case 12: arrOfPlayersData[arrayName].stat_eff = data; break;
						case 13: arrOfPlayersData[arrayName].stat_efa = data; break;
						case 14: arrOfPlayersData[arrayName].stat_tpts = data; break;
						case 15: arrOfPlayersData[arrayName].stat_plusminus = data; break;
						case 16: arrOfPlayersData[arrayName].stat_blkag = data; break;
					}
				
				//split for stats line (TEAM)
				if (nodeName == "vtm" || nodeName == "htm")
					switch (x) {
						case 0: arrOfTeamData[arrayName].stat_min = data; break;
						case 1: arrOfTeamData[arrayName].stat_fg = data; break;
						case 2: arrOfTeamData[arrayName].stat_3p = data; break;
						case 3: arrOfTeamData[arrayName].stat_ft = data; break;
						case 4: arrOfTeamData[arrayName].stat_oreb = data; break;
						case 5: arrOfTeamData[arrayName].stat_dreb = data; break;
						case 6: arrOfTeamData[arrayName].stat_treb = data; break;
						case 7: arrOfTeamData[arrayName].stat_ast = data; break;
						case 8: arrOfTeamData[arrayName].stat_pf = data; break;
						case 9: arrOfTeamData[arrayName].stat_stl = data; break;
						case 10: arrOfTeamData[arrayName].stat_to = data; break;
						case 11: arrOfTeamData[arrayName].stat_blk = data; break;
						case 12: arrOfTeamData[arrayName].stat_eff = data; break;
						case 13: arrOfTeamData[arrayName].stat_efa = data; break;
						case 14: arrOfTeamData[arrayName].stat_tpts = data; break;
					}
			}
		
		}
		
	}
	
	/****************************************************************************
	END - DATA ARRAY STORAGE FUNCTIONS 
	****************************************************************************/
}