$RAM = Get-WMIObject Win32_PhysicalMemory | Select DeviceLocator, Manufacturer, Model, Capacity, Speed, PartNumber, SerialNumber ; ForEach ($DIMM in $RAM) {$DIMM.Capacity = [string]($DIMM.Capacity / 1GB) ; $DIMM.Capacity = [decimal]::round($DIMM.Capacity) ; $DIMM.Capacity = ([string]($DIMM.Capacity)) + ' GB'} ; $RAM

/*
Todo:
Uninstall: (Get-WmiObject -Class Win32_Product -Filter "IdentifyingNumber = '{7B5AF017-C01E-49A0-B454-1200F0A94D86}'").Uninstall()
Stop/Start Service:
Stop Process:
*/
SC.util.includeStyleSheet(extensionContext.baseUrl + 'Style.css');
		
SC.event.addGlobalHandler(SC.event.QueryCommandButtons, function (eventArgs) {
	switch (eventArgs.area) {
		case 'HostDetailTabListMore':
			eventArgs.buttonDefinitions.push(
				{commandName: 'Select', commandArgument: 'Processes', text: 'Processes'},
				{commandName: 'Select', commandArgument: 'Software', text: 'Software'},
				{commandName: 'Select', commandArgument: 'EventLog', text: 'Events'},
				{commandName: 'Select', commandArgument: 'Services', text: 'Services'},
				{commandName: 'Select', commandArgument: 'RAM', text: 'Ram Slots'},
				{commandName: 'Select', commandArgument: 'RAM2', text: 'Ram'},
				{commandName: 'Select', commandArgument: 'HDD', text: 'HDD'},
				{commandName: 'Select', commandArgument: 'HDD2', text: 'LDM'},
				{commandName: 'Select', commandArgument: 'BIOS', text: 'BIOS'}
			);
			break;
		case 'ProcessesButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'Processes', text: 'Refresh Processes'});
			break;
		case 'SoftwareButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'Software', text: 'Refresh Installed Software'});
			break;
		case 'EventLogButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'EventLog', text: 'Refresh Recent Events'});
			break;
		case 'ServicesButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'Services', text: 'Refresh Services'});
			break;
		case 'RAMButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'RAM', text: 'Refresh Ram Information'});
			break;
		case 'RAM2Buttons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'RAM2', text: 'Refresh Ram Information'});
			break;
		case 'HDDButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'HDD', text: 'Refresh HDD Information'});
			break;
		case 'HDD2Buttons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'HDD2', text: 'Refresh Logical Disk Information'});
			break;
		case 'BIOSButtons':eventArgs.buttonDefinitions.push({commandName: 'GetInfo', commandArgument: 'HDD2', text: 'Refresh BIOS Information'});
			break;
	}
});

SC.event.addGlobalHandler(SC.event.PreRender, function (eventArgs) {
	SC.command.queryAndAddCommandButtons($('detailTabList'), 'HostDetailTabListMore');
});

SC.event.addGlobalHandler(SC.event.InitializeTab, function (eventArgs) {
	if (isMyTab(eventArgs.tabName))	{
		SC.command.queryAndAddCommandButtons($('detailTabContent'), eventArgs.tabName + 'Buttons');
		SC.ui.addElement($('detailTabContent'), 'DIV', {id: 'lastUpdateContainer'});
		SC.ui.addElement($('detailTabContent'), 'DIV', {id: 'dataContainer'});
		SC.ui.addElement($('detailTabContent'), 'TABLE', {id: 'dataTable'});
	}
});

SC.event.addGlobalHandler(SC.event.RefreshTab, function (eventArgs) {
	if (isMyTab(eventArgs.tabName)) {
		SC.ui.clear($('dataContainer'));
		SC.ui.clear($('lastUpdateContainer'));
		SC.ui.clear($('dataTable'));
		
		SC.ui.findDescendent(
			eventArgs.container, 
			function(e) { 
				return e._commandName == 'GetInfo'; 
			})._commandArgument = { 
				type: eventArgs.tabName, 
				operatingSystemName: eventArgs.session.GuestOperatingSystemName 
			};
			
		displayDiagnosticInformation(
			getLatestDiagnosticEvent(
				eventArgs.sessionDetails, 
				eventArgs.tabName
				), eventArgs.sessionDetails.BaseTime
			);
			
	}
});

SC.event.addGlobalHandler(SC.event.ExecuteCommand, function (eventArgs) {
	switch (eventArgs.commandName){
		case 'GetInfo':
			window.addEventToSessions(
				window.getSessionGroupUrlPart()[0], 
				SC.types.SessionType.Access,
				[window.getSessionUrlPart()], 
				SC.types.SessionEventType.QueuedCommand, 
				null,
				getInputCommand(
					eventArgs.commandArgument.type, 
					eventArgs.commandArgument.operatingSystemName
					),
				false,
				false,
				true
			);
			break;
	}
});

function getInputCommand(diagnosticType, operatingSystem) {
	var headers = getHeaders(operatingSystem);
	headers.DiagnosticType = diagnosticType;
	var commandText = getDiagnosticCommandText(headers);
	
	var emptyLinePrefix = '';
	
	if (headers.Processor == 'sh') 
		emptyLinePrefix = 'echo ';
	else{
		emptyLinePrefix = 'echo ""';
		commandText = "$Host.UI.RawUI.BufferSize = New-Object Management.Automation.Host.Size (500, 25)" + "\n" + commandText;
	}
	
	return  "#!" + headers.shaBang + "\n" +
		"#maxlength=100000" + "\n" +
		"#timeout=90000" + "\n" +
		headers.modifier + "DIAGNOSTIC-RESPONSE/1" + headers.delimiter  + "\n" +
		headers.modifier + "DiagnosticType: " + headers.DiagnosticType + headers.delimiter  + "\n" +
		headers.modifier + "ContentType: " + headers.ContentType + headers.delimiter  + "\n" +
		emptyLinePrefix + "\n" + commandText;
}

function getHeaders(operatingSystem) {
	if (operatingSystem.indexOf("Windows") >= 0 || operatingSystem.indexOf("Server") >= 0) 
		return { Processor: "ps", Interface: "powershell", ContentType: "xml", shaBang: "ps", modifier: "echo \"", delimiter: '\"' };
	else if(operatingSystem.indexOf("Linux") >= 0)
		return { Processor: "sh", Interface: "linux", ContentType: "text", shaBang: "sh",  modifier: "echo ", delimiter: ''};
	else if (operatingSystem.indexOf("Mac") >= 0)
		return { Processor: "sh", Interface: "osx", ContentType: "text", shaBang: "sh", modifier: "echo ", delimiter: ''};
}

function isMyTab(tabName) {
	switch (tabName) {
		case 'Processes':
		case 'Software':
		case 'EventLog':
		case 'RAM':
		case 'RAM2':
		case 'HDD':
		case 'HDD2':
		case 'BIOS':
		case 'Services':
			return true;
		default:
			return false;
	}
}

function isDiagnosticContent(eventData) {
	return eventData.startsWith("DIAGNOSTIC-RESPONSE/1");
}

function getLatestDiagnosticEvent(sessionDetails, diagnosticEventType) {
	return sessionDetails.Connections
			.map(function(c) { return c.Events; })
			.reduce(function(outputArray, events) { Array.prototype.push.apply(outputArray, events); return outputArray; }, [])
			.filter(function(e) { 
				return e.EventType === SC.types.SessionEventType.RanCommand &&
					isDiagnosticContent(e.Data) &&
					parseDataHeaders(e.Data).DiagnosticType.trim() == diagnosticEventType;
			})
			.sort(function (x, y) { return x.Time - y.Time; })
			[0];
}

function parseDataHeaders(eventData) {
	var currentIndex = 0;
	var headers = {};
	var isStatusLine = true;
	
	while (true) {
		var nextNewLineIndex = eventData.indexOf('\n', currentIndex);
		
		if (isStatusLine) {
			isStatusLine = false;
		} else if (nextNewLineIndex == currentIndex + 2 || nextNewLineIndex < 0) {
			break;
		} else {
			var lineParts = eventData.substring(currentIndex, nextNewLineIndex).split(': ');
			headers[lineParts[0]] = lineParts[1];
		}
		currentIndex = nextNewLineIndex + 1;
	}
	return headers;
}

function displayDiagnosticInformation(latestDiagnosticEvent, baseTime) {
	var headers = parseDataHeaders(latestDiagnosticEvent.Data);
	
	if (headers.ContentType.trim() == 'xml')
		displayDataXml(getEventDataXml(latestDiagnosticEvent.Data));
	else
		displayDataText(getEventDataText(latestDiagnosticEvent.Data));
		
	
	$('lastUpdateContainer').innerHTML = "Last Updated: " + new Date(latestDiagnosticEvent.Time + baseTime);
//	var d = new Date();
//	$('lastUpdateContainer').innerHTML = "Last Updated: " + timeDifference(d.getTime(),new Date(latestDiagnosticEvent.Time + baseTime));
}

function getEventDataXml(eventData) {
	return parseXml(eventData.substring(eventData.indexOf('<?xml'), eventData.length));
}

function displayDataXml(xml) {
	var x = xml.getElementsByTagName("Object");
	var iterationLength = 0;
	
	try {
		iterationLength = x[0].children.length;
	} catch(error) {
		iterationLength = x[0].childNodes.length;
	}
	
	//because IE/Edge are dumb
	if (isUsingInternetExplorerOrEdge())
	{
		for (j = 0; j < iterationLength; j++)
		{
			var child = x[0].childNodes[j];
	    	if (child.nodeType !== 1) continue;
	    
			SC.ui.addElement($('dataTable'), 'th', {id: 'dataTableHeader', innerHTML: x[0].childNodes[j].attributes.Name.nodeValue});
		}
		
		for (i = 0; i < x.length; i++) 
		{
			SC.ui.addElement($('dataTable'), 'tr', {id: 'dataRow' + i});
			
			for (j = 0; j < x[i].childNodes.length; j++)
			{
				var childX = x[i].childNodes[j];
	    		if (childX.nodeType !== 1) continue;
				SC.ui.addElement($('dataRow' + i), 'td', {id: 'dataTableData', innerHTML: x[i].childNodes[j].textContent});
			}
		}
	}
	else
	{
		for (j = 0; j < x[0].children.length; j++)
		{
			if (x[0].children[j].attributes.Name.nodeValue == "Description")
			SC.ui.addElement($('dataTable'), 'th', {id: 'dataTableHeader', innerHTML: '%Free'});
			else
			SC.ui.addElement($('dataTable'), 'th', {id: 'dataTableHeader', innerHTML: x[0].children[j].attributes.Name.nodeValue});
			}
	
		for (i = 0; i < x.length; i++) 
		{
			SC.ui.addElement($('dataTable'), 'tr', {id: 'dataRow' + i});
			
			for (j = 0; j < x[i].children.length; j++)
			{
				SC.ui.addElement($('dataRow' + i), 'td', {id: 'dataTableData', innerHTML: x[i].children[j].innerHTML});
			}
		}
	}
}

function getEventDataText(eventData) {
	return parseText(
		eventData
			.split('\n')
			.splice(3, eventData.length)
			.join('\n')
		);
}

function displayDataText(eventData) {
	for (var category in eventData[0]) {
			SC.ui.addElement($('dataTable'), 'th', {id: 'dataTableHeader', innerHTML: category});
	}
	for (var i = 0; i < eventData.length; i++) {
		SC.ui.addElement($('dataTable'), 'tr', {id: 'dataRow' + i});
		for (var item in eventData[i]) {
			SC.ui.addElement($('dataRow' + i), 'td', {id: 'dataTableData', innerHTML: eventData[i][item]});
		}
	}
}

function parseXml(xml) {
   var dom = null;
   if (window.DOMParser) {
      try { 
         dom = (new DOMParser()).parseFromString(xml, "text/xml"); 
      } 
      catch (e) { dom = null; }
   }
   else if (window.ActiveXObject) {
      try {
         dom = new ActiveXObject('Microsoft.XMLDOM');
         dom.async = false;
         if (!dom.loadXML(xml)) // parse error ..
            window.alert(dom.parseError.reason + dom.parseError.srcText);
      } 
      catch (e) { dom = null; }
   }
   else
      alert("cannot parse xml string!");
   return dom;
}

function parseText (data) {
	var lines=data.split('\n');
	var result = [];
 	
 	var headers=lines[1].split(',');
 
	for(var i=3;i<lines.length;i++){
		var obj = {};
		var currentline=lines[i].split(",");
 
		for(var j=0;j<headers.length;j++){
			obj[headers[j]] = currentline[j];
		}
		result.push(obj);
	}
	return result; 
}

function isUsingInternetExplorerOrEdge() {
	var ua = window.navigator.userAgent;
	var msie = ua.indexOf("Trident");
	
	if (ua.indexOf("Trident") > 0 || ua.indexOf("Edge") > 0)
		return true;
	else
		return false;
}

//ripped directly from http://stackoverflow.com/questions/6108819/javascript-timestamp-to-relative-time-eg-2-seconds-ago-one-week-ago-etc-best
function timeDifference(current, previous) {
    var msPerMinute = 60 * 1000;
    var msPerHour = msPerMinute * 60;
    var msPerDay = msPerHour * 24;
    var msPerMonth = msPerDay * 30;
    var msPerYear = msPerDay * 365;

    var elapsed = current - previous;

    if (elapsed < msPerMinute) 
         return Math.abs(Math.round(elapsed/1000)) + ' seconds ago';   
    else if (elapsed < msPerHour) 
         return Math.round(elapsed/msPerMinute) + ' minutes ago';   
    else if (elapsed < msPerDay ) 
         return Math.round(elapsed/msPerHour ) + ' hours ago';   
    else if (elapsed < msPerMonth) 
        return 'approximately ' + Math.round(elapsed/msPerDay) + ' days ago';   
    else if (elapsed < msPerYear) 
        return 'approximately ' + Math.round(elapsed/msPerMonth) + ' months ago';   
    else 
        return 'approximately ' + Math.round(elapsed/msPerYear ) + ' years ago';   
}

function getDiagnosticCommandText(headers) {
	switch (headers.Processor + '/' + headers.Interface + '/' + headers.ContentType + '/' + headers.DiagnosticType)
	{
		
		case "ps/powershell/xml/Processes": return "Get-Process | select ProcessName, Id, NPM, PM, WS, VM | Sort ProcessName | ConvertTo-Xml -As Stream";
		case "ps/powershell/xml/EventLog": return "Get-EventLog system -newest 100 | Select TimeWritten, EntryType, Source, Message | Sort TimeWritten -Descending | ConvertTo-Xml -As Stream";
		case "ps/powershell/xml/Services": return "Get-Service | select displayName, Name, Status | Sort DisplayName  | ConvertTo-Xml -As Stream";
		case "ps/powershell/xml/Software": return "Get-WmiObject -Class Win32_Product | Select Name, Vendor, Version, IdentifyingNumber | Sort Name | ConvertTo-Xml -As Stream";
		case "ps/powershell/xml/RAM": return "Get-WmiObject -Class win32_PhysicalMemoryArray | select MemoryDevices | sort MemoryDevices | ConvertTo-Xml -As Stream";
		case "ps/powershell/xml/RAM2": return "$RAM = Get-WMIObject Win32_PhysicalMemory | Select Tag, Manufacturer, Model, Capacity, Speed, SerialNumber ; ForEach ($DIMM in $RAM) {$DIMM.Capacity = [string]($DIMM.Capacity / 1GB) ; $DIMM.Capacity = [decimal]::round($DIMM.Capacity) ; $DIMM.Capacity = ([string]($DIMM.Capacity)) + ' GB'} ; $RAM | ConvertTo-Xml -As StreaM";
		case "ps/powershell/xml/HDD": return "$HDD = Get-WMIObject win32_diskdrive | Select Caption,name,serialnumber,size ; ForEach ($HD in $HDD) {$HD.Size = [string]($HD.Size / 1GB) ; $HD.Size = [decimal]::round($HD.Size) ; $HD.Size = ([string]($HD.Size)) + ' GB'} ; $HDD| ConvertTo-Xml -As StreaM";
		case "ps/powershell/xml/HDD2": return "$HDD = Get-WMIObject Win32_logicaldisk |?{$_.drivetype -eq 3} | select deviceid,VolumeName,Size,FreeSpace,Description,filesystem; ForEach ($HD in $HDD) { $HD.Size = [string]($HD.Size / 1GB) ; $HD.Size = [decimal]::round($HD.Size) ; $HD.FreeSpace = [string]($HD.FreeSpace / 1GB) ; $HD.FreeSpace = [decimal]::round($HD.FreeSpace) ; $HD.Description =[string]( [decimal]::round(($HD.FreeSpace/$HD.Size) * 100)) + '%' ; $HD.Size = ([string]($HD.Size)) + ' GB' ; $HD.FreeSpace = ([string]($HD.FreeSpace)) + ' GB'}; $HDD| ConvertTo-Xml -As StreaM";
		case "ps/powershell/xml/BIOS": return "Get-WMIObject Win32_ComputerSystem | select Manufacturer,Model,Status,BootupState | Sort Manufacturer | ConvertTo-Xml -As Stream";
		
		case "sh/linux/text/Processes": return "ps -eo \"%U,%p,%x,%C,%c\"";
		case "sh/linux/text/EventLog": return "echo " + headers.DiagnosticType + " ; dmesg -T | tail -25";
		case "sh/linux/text/Services": return "echo " + headers.DiagnosticType + " ; ls /etc/init.d";
		case "sh/linux/text/Software": return "echo " + headers.DiagnosticType + " ; dpkg --get-selections";
		
		case "sh/osx/text/Processes": return "ps -eo \"pid,%cpu,command\"";
		case "sh/osx/text/EventLog": return "echo " + headers.DiagnosticType + " ; syslog -C";
		case "sh/osx/text/Services": return "echo " + headers.DiagnosticType + " ; launchctl list";
		case "sh/osx/text/Software": return "echo " + headers.DiagnosticType + " ; ls /Applications";
    	default: throw "unknown os";
	}
}

#detailTabContent.Processes, 
#detailTabContent.Software, 
#detailTabContent.Services,
#detailTabContent.RAM,
#detailTabContent.RAM2,
#detailTabContent.HDD,
#detailTabContent.HDD2,
#detailTabContent.BIOS,
#detailTabContent.EventLog {
	text-align:center;
}

#detailTabContent.Processes > table, 
#detailTabContent.Software > table, 
#detailTabContent.Services > table,
#detailTabContent.RAM > table,
#detailTabContent.RAM2 > table,
#detailTabContent.HDD > table,
#detailTabContent.HDD2 > table,
#detailTabContent.BIOS > table,
#detailTabContent.EventLog > table {
	text-align:left;
	max-width:100%;
	margin-left: auto; 
	margin-right: auto;
}


#detailTabContent.Processes > table {
	table-layout:fixed;
}

#diagnosticButton{
	width:100%;
}

#dataTableHeader, #dataTableData{
	border:1px solid #b4b4b4;
	padding:3px;
}

case "ps/powershell/xml/EventLog": return "Get-EventLog Application -newest " + getValidEventLogCount() + " | Select TimeWritten, EntryType, Source, Message | Sort TimeWritten -Descending | ConvertTo-Xml -As Stream";

case "ps/powershell/xml/EventLog": return "Get-EventLog Application -newest -EntryType Error " + getValidEventLogCount() + " | Select TimeWritten, EntryType, Source, Message | Sort TimeWritten -Descending | ConvertTo-Xml -As Stream";