# Copyright © 2012, Microsoft Corporation. All rights reserved.

	
# this function should be included in TS_Main.ps1
function CreateUniqueGlobalFile(){
	 Set-PSVersionTable
	if ($PSVersionTable.PSVersion -lt '2.0') 
	{ 
		# if powershell version is less than 2.0
		$guid = [system.guid]::newguid()

		# for each resolver logging, does not contain the data of prior resolver
		$global:filename = $env:temp + "\" + $guid.tostring()

		# for keeping the list of all the resolver that ran
		$global:resolverRan = $env:temp + "\" + [system.guid]::newguid().tostring()

		$global:resolverFail =  $env:temp + "\" + [system.guid]::newguid().tostring()

	}else{
		$global:filename = $env:temp + "\" + [guid]::NewGuid().GUID
		$global:resolverRan =  $env:temp + "\" + [guid]::NewGuid().GUID
		$global:resolverFail =  $env:temp + "\" + [guid]::NewGuid().GUID
	}

	
}



# fail the resolver, $reason could be string also and other .net Exception objects too
# usage : resolverFail nameofPack instanceid reasonofFailure
# if there is no instance id then, resolverFail $null reasonofFailure
function resolverFail($id,$iid=$null,$reason=$null){
	($id+","+$iid)  >> $global:resolverFail

	if($reason -ne $null){
		throw $reason
	}
}

# this function should be included in TS_Main.ps1, sometimes creating GUID gives problem in Powershell 1.0
function CreateUniqueGlobalFileName([string]$filename){
	 # Set-PSVersionTable
	
	$global:rc_verifiedHtable = @{}
	$global:rc_parametersHtable = @{}

	$global:rc_verifiedHtableXML =  $env:temp + "\"+$filename+"RC_VF.xml"
	$global:rc_parametersHtableXML =  $env:temp + "\"+$filename+"RC_Param.xml"

	$global:filename = $env:temp + "\$filename" 
	$global:resolverRan =  $env:temp + "\$filename"+"_resolverRan"
	$global:resolverFail =  $env:temp + "\$filename" + "_resolverFail"

	if(test-path ($global:resolverRan)){
		del $global:resolverRan
		"rootcause0123," > $global:resolverRan
	}

	if(test-path ($global:filename)){
		del $global:filename
	}

	if(test-path ($global:resolverFail)){
		del $global:resolverFail
	}
}

# must be used with conjuction of function CreateUniqueGlobalFileName
# this function is to save the state of the rootcause
function set-stateOFRootCause{
	 param([string]$res ,
				[string]$instanceid = $null,
                [bool]$detected = $false,
                [hashtable]$params = $null) 
				
 				# Write-Host ("rootcause and instance id :"+$res+$instanceid)
				
				if($instanceid){
					
				}else{
					$instanceid = $null
				}
				
				if($params){
					if($params.count -eq 0){
						$params = $null
					}
				}else{
					$params =  $null
				}
				
				
                if( ( ($null -eq $instanceid ) -or ("" -eq $instanceid.trim() ) )  -and ( ($null -eq $params) ) ){ # if both parameters and instance id is null
                                # store the result
                                $res = "RC_"+$res

                                if($global:rc_verifiedHtable["$res"] -eq $null){
                                                $global:rc_verifiedHtable.add("$res",$detected)
                                }else{
                                                $global:rc_verifiedHtable["$res"] = $detected
                                }
                                
                }elseif( ($null -eq $instanceid) -or ("" -eq $instanceid.trim() ) ){ # if only instance id is null
                                # store the result
                                $res = "RC_"+$res

                                if($global:rc_verifiedHtable["$res"] -eq $null){
                                                $global:rc_verifiedHtable.add("$res",$detected)
                                }else{
                                                $global:rc_verifiedHtable["$res"] = $detected
                                }
 
                                # store the parameters
                                if($global:rc_parametersHtable["$res"] -eq $null){
                                                $global:rc_parametersHtable.add("$res",$params)
                                }else{
                                                $global:rc_parametersHtable["$res"] = $params
                                }
 
                }elseif( ($null -eq $params) ){ #if only parameters is null
                                # store the result
        $res = "RC_"+$res+","+$instanceid

                                if($global:rc_verifiedHtable["$res"] -eq $null){
                                                $global:rc_verifiedHtable.add("$res",$detected)
                                }else{
                                                $global:rc_verifiedHtable["$res"] = $detected
                                } 
                                
 
                }else{ # if both parameter and instance id is not null
                                # store the result
        $res = "RC_"+$res+","+$instanceid

                                if($global:rc_verifiedHtable["$res"] -eq $null){
                                                $global:rc_verifiedHtable.add("$res",$detected)
                                }else{
                                                $global:rc_verifiedHtable["$res"] = $detected
                                }
 
                                # store the parameters
                                if($global:rc_parametersHtable["$res"] -eq $null){
                                                $global:rc_parametersHtable.add("$res",$params)
                                }else{
                                                $global:rc_parametersHtable["$res"] = $params
                                }              
 
                }
 
  
                
                $f = $global:rc_verifiedHtableXML
				write-HashTable2File ($global:rc_verifiedHtable) ($f+".txt")
			

				
				$f = $global:rc_parametersHtableXML 
				write-HashTable2File ($global:rc_parametersHtable) ($f+".txt")
}


function write-HashTable2File([hashtable]$h,$f,$overWrite = $true){
	if( (Test-Path $f) -and $overWrite){
		del $f -Force
	}
	
	
	
	if( (Test-Path $f) -eq $false){
		"" > $f
		foreach($k in $h.keys){
			($k+":"+$h[$k]) >> $f
		}
	}
}


function update-DiagRootCausesecondTime($filename){
	$global:rc_verifiedHtableXML =  $env:temp + "\"+$filename+"RC_VF.xml"
	$global:rc_parametersHtableXML =  $env:temp + "\"+$filename+"RC_Param.xml"

	$rcs = cat ($global:rc_verifiedHtableXML+".txt")

	foreach($rc in $rcs){
		$rc1 = [string]$rc
		$rc1 = $rc1.split(':')
		$rc2 = $rc1[0]
		if($rc2.indexof(",") -gt -1){
			$rc2 = $rc2.split(",")
			update-diagrootcause -id ($rc2[0].trim()) -iid ($rc2[1].trim()) -detected ($($rc[1]))
			
		}
	}
}


# function to be placed in every verfier
# usage example : for "RC_WUGenError" ,  if (checkResolver "WUGenError") { return }
#				for "RC_WUGenError" and instance id "Ax123" , if(checkResolver "WUGenError" "Ax123") { return }
#				for "RC_WUGenError" and parameter "Px123" , if(checkResolver "WUGenError" $null "Px123") { return }
#				for "RC_WUGenError" and instance id "Ax123" and parameter "Px123" , if(checkResolver "WUGenError" "Ax123" "Px123") { return }
# as you know here Px123 must be hashtable
# put this line at the top of the verifier after the include statements

function checkResolver {
	 param([string]$res ,
	 [string]$instanceid = $null,
	 [hashtable]$params = $null) 

	

	$resRunning = ""
	if(test-path  $global:filename){
		$resRunning = cat $global:filename
	}

	$alreadyRan = ""
	if(test-path  $global:resolverRan){
		$alreadyRan = cat $global:resolverRan
	}

	$resFailed = $null

	if(test-path $global:resolverFail){
		$resFailed = cat $global:resolverFail
	}

	$detected = $true

	$returnFromFailed = $true;
	
	

	#check for failed resolvers
	if($resfailed -ne $null){
	foreach($f in $resFailed){
		
		$str = $f.split(',')
		
		$res = $str[0]

		if($str[1] -eq ""){
			$instanceid = $null
		}

		if( ($null -eq $instanceid) -and ($null -eq $params) ){ # if both parameters and instance id is null

		
			update-diagrootcause -id "RC_$res" -detected $true
		
		}elseif( ($null -eq $instanceid) ){ # if only instance id is null
	
			update-diagrootcause -id "RC_$res" -detected $true -parameter $params

		}elseif( ($null -eq $params) ){ #if only parameters is null
		
			if("$res,$instanceid" -eq $f){
				update-diagrootcause -id "RC_$res" -detected $true -iid $instanceid 
				
			}else{
				$returnFromFailed = $false
			}

		}else{ # if both parameter and instance id is not null
		
			if("$res,$instanceid" -eq $f){
				update-diagrootcause -id "RC_$res" -detected $true -iid $instanceid -parameter $params 
			}else{
				$returnFromFailed = $false
			}

		}

		if($returnFromFailed) { return $true }
	}
	}
	
	
	# since all the verifiers runs after each resolver is ran, we are keeping the list of which resolvers ran already
	foreach($ran in $alreadyRan){
		$ran=[string] $ran
		$tallyString = $res + "," + $instanceid
	
		if( ($ran.length -eq $tallyString.length) -and ($tallystring.indexof($ran) -eq 0) ){
			return $false
		}
	
	}

	

	
	

		# check whether the current resolver is of current verifier
		


		if( ($resRunning[0] -eq $res) -and ($resRunning[1] -eq $instanceid) ){
		
			return $false

		}elseif( ( ($null -eq $instanceid) -or ("" -eq $instanceid.trim() ) ) -and ( ($null -eq $params)  ) ){ # if both parameters and instance id is null
	
			# for some strange reason even if $instanceid is set to null it somehow gets initialized to empty string,
			# so in this section checking for empty string
			update-diagrootcause -id "RC_$res" -detected $true
		
		}elseif( ($null -eq $instanceid) ){ # if only instance id is null
			
			update-diagrootcause -id "RC_$res" -detected $true -parameter $params

		}elseif( ($null -eq $params) ){ #if only parameters is null
			 
			 
			 [string]$instanceid = [string]$instanceid

		

			update-diagrootcause -id "RC_$res" -detected $true -iid $instanceid 

		}else{ # if both parameter and instance id is not null

			 [string]$res = [string]$res
			 [string]$instanceid = [string]$instanceid


			
			update-diagrootcause -id "RC_$res" -detected $true -iid $instanceid -parameter $params 

		}

	return $detected
}


# function to be placed in every resolver
# usage example : for "RC_WUGenError" ,  runningResolver "WUGenError"
#				: for "RC_WUGenError" and instance id "Ax1234" , runningResolver "WUGenError" "Ax1234"

function runningResolver {

	 param($resolverName ,
	 $instanceid = $null)

	($resolvername) > $global:filename

	if($null -ne $instanceid){
		$instanceid >> $global:filename
	}else{
		"" >> $global:filename
	}

	ResolverRan ($resolverName) ($instanceid)
}


# private funtion to keep the list of which resolver ran already
# already called in another function, no need to call this from anywhere in the pack
function ResolverRan {

	 param($resolverName ,
	 $instanceid = $null)

	
	($resolvername+","+$instanceid) >> $global:resolverRan

}


# function to create helper variable if the computer needs restart
# must be placed in TS_Main.ps1
function CreateRebootFlag(){
	$global:RebootFlag = $false
}

# sets the reboot flag
# usage : must be placed on verifiers
# must be tied with some logic
function Set-RebootFlag ($boolValue=$false){
	$global:RebootFlag = $boolValue
}


# function to be placed in Resolvers, so if restart needed then resolver fails
function check-RebootFlag($showRestart=$false,$restartname="",$restartdesc=""){
	if($global:RebootFlag){
		# Throw [system.IndexOutOfRangeException]  

		if($showRestart){
			 $params = @{}
			 $params.add("FixVerNAME","$restartname")
			 $params.add("FixVerDESC","$restartdesc")
			 # get-diaginput "INT_Restart" -parameter $params
		}
		# Throw [system.NullReferenceException]  
	}

	
}


function fileExists($path1){
	return ([system.IO.file]::Exists($path1))
}


# to check whether TS is running or Detecting Additional Problems, only works if the pack is run as elevated
function isRunningDetectingAdditionalProblems($packName = "already.txt"){
	
	# drop a file in the current folder so that it can be checked later
	"once" > ".\$packName"



	$p1 = dir ($env:windir+"\Temp") |  Sort-Object LastWriteTime -descending # sorting the items of directory in descending order
	$p1 = $p1 |  where { $_.Mode -match "d" } # search for directories only, cause we aren’t interested in files

	# only works if the pack is run as elevated
	$dir1 = (($env:windir+"\Temp")+"\"+$p1[0].Name)
	$dir2 = (($env:windir+"\Temp")+"\"+$p1[1].Name)

	if( (test-path "$dir1\$packName") -and (test-path "$dir2\$packName") ){
		# check if 2 files are present or not, if the both files are present then its a load back
		return $true
	}
	
	return $false
	
}

# second load of the troubleshooter, needs a filename to be given as parameter
# example :-
# if(ispostback "wuPack1"){
# do what you need for detecting additional changes	
# } else {
# do what needs for 1st run of rootcauses
# }
function isPostBack($packName){
	return (isRunningDetectingAdditionalProblems ($packName) )
}


# second load of the troubleshooter, needs a filename to be given as parameter
# example :-
# if(ispostbackOnWin8 "wuPack1"){
# do what you need for detecting additional changes	
# } else {
# do what needs for 1st run of rootcauses
# }
function ispostbackOnWin8($packName){
	[string] $path1 = (Get-Location -PSProvider FileSystem).ProviderPath
	[string] $path1 = $path1 + "\$packName"
	if(test-path $path1){
		# del $path1 -force
		# the file is already so this must be detecting additional problem
		return $true
	}
	"once" > $path1 
	return $false
}

# call off the script that checks whether the pack running or not
function calloff(){
	$true > "$env:temp\calloff"
}

#copy necessary files to the temporary folder
function copyFilesToTemp($fileArray){
	foreach($f in $fileArray){
		copy "$f" ("$env:temp\$f")
	}
}


#block the script, until the pack is either finished or cancelled
function block(){
	
	$p1 = dir ($env:windir+"\Temp") |  Sort-Object LastWriteTime -descending # sorting the items of directory in descending order
	$p1 = $p1 |  where { $_.Mode -match "d" } # search for directories only, cause we aren’t interested in files

	 # take the latest directory
	$dir1 = "not null"
	while( $dir1 -ne $null ){
		$dir1 = dir (($env:windir+"\Temp")+"\"+$p1[0].Name)
		"directory there"
	}

	if(test-path ("$env:temp\calloff")){
		del "$env:temp\calloff"
		
		exit
	}
}


# function to run powershell window without black splash, not used anywhere till now, its not working properly
function runInvisibleWindowPowershell($args){
	
	$runthis = "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"

	
	$args = [string] $args
	
	$procStartInfo = New-Object System.Diagnostics.ProcessStartInfo($runthis,$args)

	$procStartInfo.RedirectStandardOutput = $true;
    $procStartInfo.UseShellExecute = $true;
               
    $procStartInfo.CreateNoWindow = $false;

	$proc = new-object System.Diagnostics.Process
	$proc.StartInfo = $procStartInfo;
    $proc.Start();
}



# this function "callthis1st" must be called as shown below in TS_Main file

# if(isRunningDetectingAdditionalProblems){
#	calloff (this function is used to cancel the execution of "runaftercancel" file)
#	returnBackExecPolicy (this function sets back the execution policy to the state before the pack was run)
# }else{
#	callthis1st (this sets the execution policy to "remotesigned"
#	runAfterCancelProcess ("RunThisAfterCancel.ps1") ($filesToCopy) {this function runsThisAfterCancel.ps1 after the cancel button is hit}
# }

# this function sets powershell execution policy to remote signed
function callthis1st(){
	
	# $execPolicy = get-executionpolicy

	$runthis = "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"
	[System.Diagnostics.Process]::Start($runthis," get-executionpolicy > $env:temp\execPolicy.txt")

	

	$execPolicy = cat "$env:temp\execPolicy.txt"
	$execPolicy = [string] $execPolicy
	$execPolicy = $execPolicy.Trim()

	


	if( ($execPolicy -ieq "remotesigned") -or ($execPolicy -ieq "unrestricted") ){
		
	}else{

		[System.Diagnostics.Process]::Start($runthis," set-executionpolicy unrestricted -force")

	}

	
}


# this is the main function that tells powershell which file to run after cancel is hit, see "callthis1st" usage example to see how to use this function
# $RunThisfileAfterPack -> give the path of a file that you need to run after cancel is hit in the pack
# $fileArrayNeededToBeCopied -> supply the array of file paths that helps the previous file to run properly, files which are included in the above file must be given here 
function runAfterCancelProcess($RunThisfileAfterPack,$fileArrayNeededToBeCopied,$paramForRunThisFileAfterPack=$null){
	
	copyFilesToTemp $fileArrayNeededToBeCopied

	$args = " -nologo -windowstyle minimized -file $env:temp\$RunThisfileAfterPack"
	
	
	$runthis = "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"
	[System.Diagnostics.Process]::Start($runthis," set-executionpolicy unrestricted -force")

	sleep 2

	[System.Diagnostics.Process]::Start($runthis," -nologo -windowstyle minimized -file $env:temp\$RunThisfileAfterPack")
}





# change execution policy to previous state , just a prototype don't use this function for production
function returnBackExecPolicy(){
	$execPolicy = cat "$env:temp\execPolicy.txt"
	$execPolicy = [string] $execPolicy 
	$runthis = "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe"


	[System.Diagnostics.Process]::Start($runthis,"  set-executionpolicy $execPolicy -force; ")

	
}