var singlePrefix = "SP",
	multiPrefix = "MP",
	singleLength = 3,
	multiLength = 5;

var barHeight = 15;

/*
var pieChartLegend = "Pie Chart :: ";
	barChartLegend = "Bar Chart :: ";
*/
	
var pieChartId = "piechart",
	barChartId = "barchart";
	
var weaponNamesMap = {};

var rangeWarningFlag = false,
	rangeWarningText = "<span style='color:#AB6F1B'>WARNING!</span> There are values returned outside "
			+ "the expected range and they are not shown on the graph."
			+ " If you think that there are missing values please "
			+ "<a href='mailto:*Tools@rockstarnorth.com?subject=Stats Value Ranges' "
			+	"title='Contact Tools' target='_blank'>Contact Tools</a>";

var commasFixed2 = function(d) {return d3.format(",")(d.toFixed(2)); };

var currentStat = (getUrlVars()["stat"]) ? getUrlVars()["stat"] : 0;
var currentFilename = config.currentFilename + "?stat=" + currentStat;

var marginLeft = 135;
//var queryAsyncUrl = config.restHost + config.profileStatPath + config.queryAsyncPath;

// Object used for local storage of the user selections
//var pageData = {
//	availableChart: 0,
//}

function initPage() {
	// function from generic.js, variable from config file
	initHeaderAndFilters(headerAndFilters);
	
	$("#content")
		.append(
			$("<div>")
				.attr("id", "friendlier-names-field")
				.append(
					$("<input>")
						.attr("id", "friendlier-names")
						.attr("type", "checkbox")
						.attr("disabled", true)
				)
				.append(
					$("<label>")
						.attr("for", "friendlier-names")
						.attr("title", "Check to Switch to Friedlier Names")
						.text("Friendlier Names")
				)
		);
		
	$("#content-body")
		.append(
			$("<div>").attr("id", pieChartId)
		)
		.append(
			$("<div>").attr("id", barChartId)
		);
		
	initSvg(pieChartId);
	initSvg(barChartId);
		
	/*
	// Disable the start date
	$("#date-from")
		.attr("disabled", true)
		.addClass("disabled");
	// Disable the builds
	$("#builds")
		.attr("disabled", true)
		.addClass("disabled");
	*/
	
	//var localData = retrieveLocalObject(config.currentFilename);
	//pageData = (localData) ? localData : pageData;
	
	var currentA = $("#navigation a[href$='" + currentFilename + "']");
	currentA.addClass("active");
	
	var currentUl = currentA.parent().parent();
	currentUl.prev().addClass("active");
	currentUl.prev().parent().addClass("expanded");
	
	var topUl = currentUl.parent().parent();
	if (topUl.css("display") == "none") {
		topUl.prev().addClass("active");
		topUl.prev().parent().addClass("expanded");
		topUl.slideToggle();
	}
	
	updateTitle();
	
	/*
	var currentUl = $("#navigation a.active[href$='" + currentFilename + "']:first").next();
	
	// Populate the chart drop down menu from the config file variables
	$.each(reportOptions.availableCharts, function(i, availableChart) {
		currentUl.append(
			$("<li />").append(
				$("<a />")
					//.addClass(function() {if (pageData && pageData.availableChart == i) return "active"; })
					.addClass(function() {return (i==0) ? "active" : ""; })
					.text(availableChart.name)
					.attr("href", i)
					.attr("title", availableChart.name)
					.click(function(e) {
						e.preventDefault();
						
						$(this).parent().parent().find("a").removeClass("active");
						$(this).addClass("active");
						
						//pageData.availableChart = parseInt($(this).attr("href"));
						//storeLocalObject(config.currentFilename, pageData);
						
						generateCharts();
					})
			)
		);
	});
	*/
	
	if (reportOptions.availableCharts.length > 1)
		currentUl.slideToggle();
		
	//$("#nav-ul a.active").next().slideToggle();
		
	//if (reportOptions.availableCharts[parseInt(currentUl.find("a.active").attr("href"))].isWeaponStat) {
	if (reportOptions.availableCharts[parseInt(currentStat)].isWeaponStat) {
		populateWeaponNamesMap();
		marginLeft = 180;
		
		$("#friendlier-names").attr("disabled", false);
		$("#friendlier-names").prop("checked", true);
		$("#friendlier-names").click(function() {
			generateCharts();
		});
	}
	
	// Post header filter addition 
	$("#filter").click(function() {
		generateCharts();
	});

	//updateChartHeight();
	generateCharts();
}

/*
function updateChartHeight() {
	// Adjust the height of the content automatically
	$("#content").height($(window).height() - $("#header").height() - 40); // 20 is the padding top/bottom
}
*/
	
function generateCharts() {
	//var selectedChart = availableCharts[parseInt($("select#available-charts-options").val())];
	//var selectedChart = availableCharts[parseInt($("#nav-ul a.active").next().find("a.active").attr("href"))];
	
	
	//var currentUl = $("#navigation a.active[href$='" + config.currentFilename + "']:first").next();
	//var selectedChart = reportOptions.availableCharts[parseInt(currentUl.find("a.active").attr("href"))];
	
	selectedChart = reportOptions.availableCharts[currentStat];
	
	//toggleGameTypeOptions(selectedChart);
	var gameTypes = [];
	
	if (!$("select#game-types").val() && !selectedChart.singleVsMulti)
		$("select#game-types option").each(function() {
			gameTypes.push($(this).val());
		});
	else
		gameTypes = $("select#game-types").val();
	//console.log(gameTypes);
	
	var character = ($("#character").val()) ? $("#character").val() : null;
	
	if (selectedChart.hideStartDate){
		$("#date-from").addClass("hidden");
		$("#date-from").parent().addClass("hidden");
	}
	else {
		$("#date-from").removeClass("hidden");
		$("#date-from").parent().removeClass("hidden");
	}
	
	//if (selectedChart.isWeaponStat)
	//	selectedChart.types = Object.keys(weaponNamesMap).sort();
	
	if (!selectedChart.divided) { // In case of requesting Combined or Separate Profile Stats	

		var pValuesArray = [];
		// sort the types alphabetically
		// selectedChart.types.sort() 
		$.each(selectedChart.types, function(i, selectedChartType) {
			var finaleStatNames;

			finalStatNames = constructStatNames(selectedChart, selectedChartType, gameTypes, character);
			
			// get the social club header filtering parameter values, headerAndFilters.headerType comes from local conf
			var pValues = config.headerOptions[headerAndFilters.headerType].getParamValues();
			if (!pValues)
				return;
			// Add the extra Profile stats param values
			pValues.Pairs["StatNames"] = finalStatNames.join(",");
			pValues.Pairs["BucketSize"] = selectedChart.bucketSize;
		
			pValuesArray.push(pValues);
		}); //end of $.each() loop
		if (pValuesArray.length == 0)
			return;
		
		var req = new ReportRequest(null, "json", null, config.restHost + config.reportsQueryAsync);
		
		var endpointObject = {
			restUrl: config.restHost + reportOptions.restEndpoint,
			restAsyncUrl: config.restHost + reportOptions.restEndpointAsync + pValuesArray[0].ForceUrlSuffix,
			pValues: pValuesArray,
		}
		
		if (!pValuesArray[0].Pairs.hasOwnProperty("StartDate")) {
			$("#date-from").addClass("hidden");
			$("#date-from").parent().addClass("hidden");
		}
		
		req.sendMultipleAsyncRequest([endpointObject], handleCombinedStatRespone);
		
		//queryMultipleAsyncProcesses(queryAsyncUrl, monitoredProcesses, handleCombinedStatRespone);
		
	} // end of if (!divided)
	else { 
		// Code to execute when the divided flag is set, requests the fraction of two profile stats
		var combinedStatNamesA = constructStatNames(selectedChart, selectedChart.types[0], gameTypes, character);
		var combinedStatNamesB = constructStatNames(selectedChart, selectedChart.types[1], gameTypes, character);
		
		// get the social club header filtering parameter values, headerAndFilters.headerType comes from local conf
		var pValues = config.headerOptions[headerAndFilters.headerType].getParamValues();
		if (!pValues)
			return;
		// Add the extra Profile stats param values
		pValues.Pairs["NumeratorStatNames"] = combinedStatNamesA.join(",");
		pValues.Pairs["DenominatorStatNames"] = combinedStatNamesB.join(",");
		pValues.Pairs["BucketSize"] = selectedChart.bucketSize;
		
		var req = new ReportRequest(config.restHost + config.profileStatsDividedDiff,
				"json",
				config.restHost + config.profileStatsDividedDiffAsync + pValues.ForceUrlSuffix,
				config.restHost + config.reportsQueryAsync);
		
		req.sendSingleAsyncRequest(pValues, handleDividedStatResponse);
	}
		
}

function handleCombinedStatRespone(monitoredProcesses) {
	//var selectedChart = availableCharts[parseInt($("select#available-charts-options").val())];
	//var selectedChart = availableCharts[parseInt($("#nav-ul a.active").next().find("a.active").attr("href"))];
	
	//var currentUl = $("#navigation a.active[href$='" + config.currentFilename + "']:first").next();
	//var selectedChart = reportOptions.availableCharts[parseInt(currentUl.find("a.active").attr("href"))];
	
	selectedChart = reportOptions.availableCharts[currentStat];

	var chartData = [];
	
	//console.log(monitoredProcesses[0]);
	$.each(selectedChart.types, function(i, selectedChartType) {
		//if (response == config.asyncRequestFailTxt)
		//	return;
		
		if (selectedChart.types.length != 1) {
			var response = monitoredProcesses[0][i].response[0];
			
			var total;
			if (selectedChart.convertToKm)
				total = Number(response.Total)/1000.0; // convert from metres to kilometres 
			else if (selectedChart.convertToHours)
				total = Number(response.Total)/config.anHourInMillisecs; // convert from millisecs to hours
			else 
				total = Number(response.Total);
			
			if (selectedChart.isAverage) {
				total = (Number(response.YValue)) ? (total / Number(response.YValue)) : 0;
				//console.log(response.YValue);
			}
			
			var name = selectedChartType;
			/*
			if (selectedChart.singleVsMulti) {
				if (selectedChartType.charAt(0) == singlePrefix.charAt(0))
					name = $("select#game-types option:eq(0)").val();
				else if (selectedChartType.charAt(0) == multiPrefix.charAt(0))
					name = $("select#game-types option:eq(1)").val();
			}
			*/
			if (selectedChart.isWeaponStat) {
				// If there are matched rest service object with game and friendly names use that
				if (weaponNamesMap.hasOwnProperty(selectedChartType)) {
					name = selectedChart.getName(weaponNamesMap[selectedChartType]);
				}
				else // Otherwise revert to the profile stat name
					name = selectedChartType;
			}
			else if (selectedChart.altNames) {
				name = selectedChart.altNames[i];
			}
		
			chartData.push({
				Name: name,
				Value: total,
			});
			
		} // end of (if length > 1)
		else {
			var response = monitoredProcesses[0][i].response;
			
			$.each(response, function(i, item) {
				var name;
				var value = Number(item.YValue);
							
				if (selectedChart.convertToHours) { // Total Playing Time chart
					// 	Convert the label names from milliseconds to hours
					/*
					name = item.Bucket.split("-")
						.map(function(d) {return (Number(d) / config.anHourInMillisecs)})
						.join("-") 
						+ (" (hours)");
					*/
					name = [Number(item.BucketMin) / config.anHourInMillisecs, Number(item.BucketMax) / config.anHourInMillisecs]
						.join("-") 
						+ (" (hours)");
				}
				else if (selectedChart.addPercentageLabel) { // Percentage Chart
					/*
					var name = item.Bucket;
					if (selectedChart.multiplyToPercentage) {
						name = name.split("-")
							.map(function(d) {
								return (Number(d) * selectedChart.multiplyToPercentage)
							})
							.join("-");
					}
					
					// 	Convert the label names from decimal to percentages
					var lowerRange = name.split("-")[0];
					name = ((lowerRange == 100) ? lowerRange : name) + " %";
					*/
					if (selectedChart.multiplyToPercentage) {
						name = [Number(item.BucketMin) * selectedChart.multiplyToPercentage,
						        Number(item.BucketMax) * selectedChart.multiplyToPercentage]
							.join("-");
					}
					
					name = ((Number(item.BucketMin) * selectedChart.multiplyToPercentage == 100)
								? Number(item.BucketMin) * selectedChart.multiplyToPercentage 
								: name)
							+ " %";
				}
				else if (selectedChart.altNames) {
					// replace the bucket names with the given alt ones
					// The altNames id should come from the buckets lower range
					var altId = Number(item.BucketMin);
					
					if ((altId !== "undefined") && (selectedChart.altNames.length > altId))
						name = selectedChart.altNames[altId];
					else {
						rangeWarningFlag = true;
						return;
					}
					
					//name = ((altId !== "undefined") && (selectedChart.altNames.length > altId)) ? 
					//		selectedChart.altNames[altId] : item.Bucket;
				}
				else if (selectedChart.showOnlyLowerRange) {
					
					var lowerValue = Number(item.BucketMin);
					
					// If the results have to be in specific value ranges
					if (selectedChart.validRange 
							&& (lowerValue < selectedChart.validRange[0] || lowerValue > selectedChart.validRange[1])) {
						rangeWarningFlag = true;
						return;
					}
					else
						name = lowerValue;
				}
				else
					name = item.Bucket;
			
				chartData.push({
					Name: name,
					Value: value
				});
				
			});
			
		}
		
	}); // end of each
	
	//hideProgressbar();
	drawCharts(chartData, selectedChart);
}

function handleDividedStatResponse(response) {
	//var selectedChart = availableCharts[parseInt($("select#available-charts-options").val())];
	//var selectedChart = availableCharts[parseInt($("#nav-ul a.active").next().find("a.active").attr("href"))];
	
	//var currentUl = $("#navigation a.active[href$='" + config.currentFilename + "']:first").next();
	//var selectedChart = reportOptions.availableCharts[parseInt(currentUl.find("a.active").attr("href"))];
	selectedChart = reportOptions.availableCharts[currentStat];

	var chartData = [];
	
	//console.log(response);
	if (response != config.asyncRequestFailTxt) {
				
		$.each(response, function(i, item) {
			var value = Number(item.YValue);
		
			
			var name;
			if (selectedChart.perHour) { // Metric Per Hour Chart
				// 	Convert the label names from milliseconds to hours

				/*
				var bucketNames = item.Bucket.split(/-/);		
			
				if (bucketNames.length > 2)		// In case of more than one "-", the numbers are very small decimals (i.e 1.2E-10)
					bucketNames = item.Bucket.split(/-(?=\d\D)/);  // so match only the "-" which is followed by a '\d\D' (i.e '2.') 
			
				//console.log(item.Bucket);
				//console.log(bucketNames);
			
				name = bucketNames
					.map(function(d) {
						return (Number(d) * config.anHourInMillisecs).toFixed(1);
					})
					.join(" - ");
				*/
				name = [(Number(item.BucketMin) * config.anHourInMillisecs).toFixed(1),
				        (Number(item.BucketMax) * config.anHourInMillisecs).toFixed(1)]
					.join(" - ");
			}
			else
				name = item.Bucket; 
			
			chartData.push({
				Name: name,
				Value: value
			});
		
		});
		
	}
	
	//hideProgressbar();
	drawCharts(chartData, selectedChart);
}

function drawCharts(chartData, selectedChart) {
	//console.log(chartData);
	
	var chartValuesSum = chartData.reduce(function(accumulator, current) {
		return accumulator + ((current.Value) ? current.Value : 0)}, 0
	);
	if (chartValuesSum == 0) {
		Sexy.alert(config.noDataText);
		cleanGraph(pieChartId);
		cleanGraph(barChartId);
		return;
	}
	
	$("#content-description").empty();
	if (rangeWarningFlag) {
		$("#content-description").html(rangeWarningText);
		rangeWarningFlag = false;
	}
	else
		$("#content-description").html(selectedChart.description);
	//updateChartHeight();
	
	//var datum = [{values: chartData, color: config.chartColour1}];
	chartData.sort(function (a, b) {return (a.Value >= b.Value) ? -1 : 1} )
	var datum = [{values: chartData}];
	
	drawPiechart(datum, selectedChart);

} // end of generateChart()

function drawPiechart(datum, selectedChart) {
		
	nv.addGraph({
		generate: function() {
			var chart = nv.models.pieChart()
				.x(function(d) { return d.Name; })
				.y(function(d) { return d.Value; })
				.showLegend(false)
				.showLabels(true)
				.donut(true)
				.donutLabelsOutside(true);

			chart.tooltipContent(function(key, y, e, graph) { 
				var sum = d3.sum(graph.container.__data__[0].values, function(d) {return d.Value});
				// 	Use e.value instead of y, y is a formated string and parsing to number fails
				var percentage = ((e.value/sum)*100).toFixed(2);
			
				// 	need to get that realtime, otherwise the pieachart tooltip vars are not being updated
				//var thisChart = 
				//	availableCharts[parseInt($("#nav-ul a.active").next().find("a.active").attr("href"))];
				//var currentUl = $("#navigation a.active[href$='" + config.currentFilename + "']:first").next();
				//var thisChart = reportOptions.availableCharts[parseInt(currentUl.find("a.active").attr("href"))];
				var thisChart = reportOptions.availableCharts[currentStat];
				
				/*
				return "<h3>" + key + "</h3>"
               		+ "<p>" +  y + " " + thisChart.units + " - " + percentage + "%</p>";
               	*/
				var tooltipValue, tooltipSum;
				
				if (thisChart.units == "hours") {
					tooltipValue = formatSecsWithDays(e.value*config.anHourInSecs);
					tooltipSum = formatSecsWithDays(sum*config.anHourInSecs);
				}
				else {
					tooltipValue = (commasFixed(e.value, 4) + " " + thisChart.units);
					tooltipSum = (commasFixed2(sum, 4) + " " + thisChart.units);
				}
				
				return "<h3>" + key + "</h3>"
						+ "<p>" +  tooltipValue 
						+ " - " + percentage + "%" + "<br />" 
						+ " (of " + tooltipSum + ")" + "</p>";
			});
		
			d3.select("#" + pieChartId + " svg")
				.datum(datum)
				.transition()
					.duration(config.transitionDuration)
				.call(chart);
			 		
			nv.utils.windowResize(chart.update);
			//nv.utils.windowResize(updateChartHeight);
			//nv.utils.windowResize(function() { decorateKeys(pieChartId); });
			nv.utils.windowResize(function() {
				drawDonutLabel(pieChartId, selectedChart.name);
				decorateKeys(pieChartId); 
			});
	 	
			return chart;
		},
		callback: function() {
			drawDonutLabel(pieChartId, selectedChart.name);
			
			decorateKeys(pieChartId);
			
			d3.select("#" + pieChartId + " svg").selectAll(".nv-slice").each(function(d, i) {
				//colours.push(d3.select(this).attr("fill"));
				datum[0].values[i]["Colour"] = d3.select(this).attr("fill");
			});
			
			drawBarchart(datum, selectedChart)
		},
	});
	//$("#piechart legend").text(pieChartLegend + selectedChart.name);
}

function drawBarchart(datum, selectedChart) {
	
	
	var graphHeight = (barHeight * datum[0].values.length); // pixels
	var containerHeight = $("#content-body").height();

	if (graphHeight < containerHeight) {
		$("#" + barChartId).css("height", containerHeight);
		$("#" + barChartId + " svg").css("height", containerHeight);
	}
	else {
		$("#" + barChartId).css("height", graphHeight);
		$("#" + barChartId + " svg").css("height", graphHeight);
	}
			
	if (selectedChart.orderDescBarchart)
		datum[0].values.sort(function(a, b) { return (Number(a.Name) > Number(b.Name)) ? -1 : 1});
	
	nv.addGraph({
		generate: function() {
			var chart = nv.models.multiBarHorizontalChart()
				.x(function(d) { return d.Name; })
				.y(function(d) { return d.Value; })
				.margin({top: 20, right: 20, bottom: 50, left: marginLeft})
				.showValues(true)
				.tooltips(false)
				.showControls(false)
				.showLegend(false);

			chart.yAxis
				.axisLabel(selectedChart.label)
				.tickFormat(d3.format(".02f"));
			
			d3.select("#" + barChartId + " svg")
				.datum(datum)
				.transition()
					.duration(config.transitionDuration)
				.call(chart);
			 
			nv.utils.windowResize(chart.update);
			//nv.utils.windowResize(updateChartHeight);
			 
			return chart;
		},
		callback: function() {
			matchColours(datum, barChartId)
		}
	});
	//$("#barchart legend").text(barChartLegend + selectedChart.name);
}

function matchColours(datum, barChartId) {
	
	/*
	var colours = [];
	d3.select("#" + piechartID + " svg").selectAll(".nv-slice").each(function(d, i) {
		colours.push(d3.select(this).attr("fill"));
		//console.log(d3.select(this).attr("fill"));
	});
	*/
	
	d3.select("#" + barChartId + " svg").selectAll(".nv-bar").each(function(d, i) {
		d3.select(this).attr("fill", datum[0].values[i].Colour);
	});
	
}

function drawDonutLabel(elementID, labelText) {
	var svg = d3.select("#" + elementID + " svg");
	
	svg.selectAll(".donut-label").remove();

	svg.append("svg:text")
		.attr("class", "donut-label")
    	.attr("x", $("#" + elementID).width() / 2)
    	.attr("y", $("#" + elementID).height() / 2)
    	.attr("text-anchor", "middle")
    	.attr("stroke", 5)
    	.text(labelText);
}

function decorateKeys(elementID) {
	$(".nv-legend rect").remove();
	
	var legend = d3.select("#" + elementID + " svg")
				.select("g.nv-legend g");
	
	if (!legend[0][0])
		return;
		
	var bbox = legend[0][0].getBBox();
	var margin = 5;
	
	legend.append("svg:rect")
		.attr("x", bbox.x - margin)
		.attr("y", bbox.y - margin)
		.attr("width", bbox.width + 2*margin)
		.attr("height", bbox.height + 2*margin)
		.attr("rx", margin)
		.attr("ry", margin)
		.attr("pointer-events", "none");
}

function constructStatNames(selectedChart, selectedChartType, gameTypes, character) { 
	var singleStatNames = [],
		multiStatNames = [],
		finalStatNames = [];
		
	if (character) {
		var charStat;
		if (character < singleLength) {
			if (selectedChart.isWeaponStat)
				charStat = singlePrefix + character + "_" + selectedChartType + selectedChart.requestSubString;
			else
				charStat = singlePrefix + character + selectedChart.requestSubString + selectedChartType;
		}
		else {
			if (selectedChart.isWeaponStat)
				charStat = multiPrefix + (character-singleLength) + "_" + selectedChartType + selectedChart.requestSubString;
			else
				charStat = multiPrefix + (character-singleLength) + selectedChart.requestSubString + selectedChartType;
		}
		finalStatNames.push(charStat);
	}
	else if (!selectedChart.singleMetric) {
		for (var i=0; i<singleLength; i++) {
			if (selectedChart.isWeaponStat) // Weapon profile stats have different name patterns
				singleStatNames.push(singlePrefix + i + "_" + selectedChartType + selectedChart.requestSubString);
			else
				singleStatNames.push(singlePrefix + i + selectedChart.requestSubString + selectedChartType);
		}
		for (var i=0; i<multiLength; i++) {
			if (selectedChart.isWeaponStat) // Weapon profile stats have different name patterns
				multiStatNames.push(multiPrefix + i + "_" + selectedChartType + selectedChart.requestSubString);
			else
				multiStatNames.push(multiPrefix + i + selectedChart.requestSubString + selectedChartType);
		}
		
		$.each(gameTypes, function(i, gameType) {
			if (gameType == config.gameTypes[0] && !selectedChart.multiOnly)
				finalStatNames = finalStatNames.concat(singleStatNames);
			if (gameType == config.gameTypes[1] && !selectedChart.singleOnly)
				finalStatNames = finalStatNames.concat(multiStatNames);
		});
	}
	else {
		finalStatNames.push(selectedChartType);
	}
	
	return finalStatNames;
}

function toggleGameTypeOptions(selectedChart) {
	/*
	if (selectedChart.singleOnly || selectedChart.multiOnly || selectedChart.singleMetric) {
		$("#game-types-field select")
			.attr("disabled", true)
			.addClass("disabled");
	}
	else {
		$("#game-types-field select")
			.attr("disabled", false)
			.removeClass("disabled");
	}
	*/
}


function populateWeaponNamesMap() {
	weaponNamesMap = getWeaponStatnames();
	
	//var weaponNamePrefix = "WEAPON_";
		
	/*
	//block();
	$.ajax({
		url: config.restHost + config.weaponsAll,
		type: "GET",
		data: {},
		dataType: "xml",
		async: false,
		success: function(xml, textStatus, jqXHR) {
			$(xml).find("Weapon").each(function() {
				var gameName = $(this).find("Name").text().toUpperCase(),
					statName = $(this).find("StatName").text().toUpperCase(),
					friendlyName = $(this).find("FriendlyName").text();
				
				if (statName && !weaponNamesMap.hasOwnProperty(statName)) {
					weaponNamesMap[statName] = {
						Name: gameName.replace(weaponNamePrefix, ""),
						//Name: gameName,
						FriendlyName: friendlyName,
					};
				}
				
			});
			
		},
		error: function (xhr, ajaxOptions, thrownError){
			console.error(this.url + "\n" + ajaxOptions + " " + xhr.status + " " + thrownError );
		},
		complete: function() {
			//unBlock();
		}
	});
	*/

}
//End of convertXml group of functions