<#	
	.NOTES
	JJ's XMR-CAST_XMR HashRate Monitor and Restart Tool
	
	
	*** IMPORTANT NOTE ***: If the script cannot kill the miner it will stop and wait for input.
							Otherwise it would invoke the miner over and over until the PC ran out of memory.
							In testing I have not seen it fail to kill the miner but I need to account for it.

	Requirements:	Elevated privilege (Run as Administrator)
					Enable Powershell scripts to run.

	
	Usage:	Powershell.exe -ExecutionPolicy Bypass -File JJs_HashMonitor.ps1
	
	Future enhancements under consideration:	SMS/email alerts
												Move settings out of the script and into a simple
												txt file to make it easier to manage them.

	
#>

######################################################################################
#  !! Scroll down to "USER VARIABLES SECTION"
#  !! There are variables you want to review/modify for your setup
######################################################################################
$ver = "3"
######################################################################################
#################DO NOT MODIFY ANYTHING IN  THE ELEVATION SECTION ####################
############################## BEGIN ELEVATION #######################################
# If you can't Elevate you're going to have a bad time...
# Get the ID and security principal of the current user account
$myWindowsID=[System.Security.Principal.WindowsIdentity]::GetCurrent()
$myWindowsPrincipal=new-object System.Security.Principal.WindowsPrincipal($myWindowsID)
 
# Get the security principal for the Administrator role
$adminRole=[System.Security.Principal.WindowsBuiltInRole]::Administrator
 
# Check to see if we are currently running "as Administrator"
if ($myWindowsPrincipal.IsInRole($adminRole))
   {
   # We are running "as Administrator" - so change the title and background color to indicate this
   $Host.UI.RawUI.WindowTitle = "JJ's XMR-CAST_XMR HashRate Monitor and Restart Tool v $ver"
   $Host.UI.RawUI.BackgroundColor = "DarkBlue"
   clear-host
   }
else
   {
   # We are not running "as Administrator" - so relaunch as administrator
   
   # Create a new process object that starts PowerShell
   $newProcess = new-object System.Diagnostics.ProcessStartInfo "PowerShell";
   
   # Specify the current script path and name as a parameter
   $newProcess.Arguments = $myInvocation.MyCommand.Definition;
   
   # Indicate that the process should be elevated
   $newProcess.Verb = "runas";
   
   # Start the new process
   [System.Diagnostics.Process]::Start($newProcess) | Out-Null;
   
   # Exit from the current, unelevated, process
   exit
   }
 
Clear-Host
Write-Host "Starting the Hash Monitor Script..."

Push-Location $PSScriptRoot
######################################################################################
################# DO NOT MODIFY ANYTHING IN THE ELEVATION SECTION ####################
################################ END ELEVATION #######################################


############# STATIC Variables - DO NOT CHANGE ##########################
$ScriptDir = Split-Path $MyInvocation.MyCommand.Path -Parent
$ScriptName = $MyInvocation.MyCommand.Name
$global:runDays = $null
$global:runHours = $null
$global:runMinutes = $null
$global:web = New-Object System.Net.WebClient
$global:maxhash = 0
$global:currHash = 0
$vidTool = @()
########## END STATIC Variables - MAKE NO CHANGES ABOVE THIS LINE #######

######################################################################################
########################### USER VARIABLES SECTION ###################################
######################################################################################

#########################################################################
# Set the REQUIRED variables for your Mining Configuration
#########################################################################
# Read this section carefully or you may end up overclocking your video
# card when you don't want to!! YOU HAVE BEEN WARNED
#########################################################################
$Logfile = "Cast_Restart_$(get-date -f yyyy-MM-dd).log"	# Log what we do, delete or REMARK if you don't want logging
$global:CAST_XMRexe = "cast_xmr-vega.exe"	# The miner. Expects to be in same folder as this script
$global:CAST_XMRcmdline = "-S mine.xmrpool.net:7777 -u 'YOUR_WALLET_ADDRESS.YOUR_WORKER_NAME' -p x -O 1 -G 0,1,2,3,4,5,6,7 -R -I 7 --fastswitch"	
# CAST_XMR arguments. Not required, REMARK out if not needed
$CAST_XMRIP = '127.0.0.1'	# IP or hostname of the machine running CAST_XMR (ALWAYS LOCAL) Remote start/restart of the miner is UNSUPPORTED.
							# !! DON'T FORGET TO ENABLE THE WEBSERVER IN YOUR CONFIG FILE !!
$CAST_XMRPort = '7777'		# Port CAST_XMR is listening on

##### Start Video Card Management Tools Definitions
# These will be executed in order prior to the miner
# Create as many as needed
#### Vid Tool 1
#$vidTool += 'OverdriveNTool.exe -r0 -r1 -r2 -r3 -r4 -r5 -r6 -r7 -p0Vega0 -p1Vega1 -p2Vega0 -p3Vega0 -p4Vega0 -p5Vega0 -p6Vega0 -p7Vega0'	
										# Expects to be in same folder as this script
										# Delete or REMARK if you don't want use it
#### Vid Tool 2
#$vidTool += '[X]'	# Expects to be in same folder as this script
									    # Delete or REMARK if you don't want use it
#### Vid Tool 3
#$vidTool += '[X]'	# Expects to be in same folder as this script
									    # Delete or REMARK if you don't want use it
#### Vid Tool 4
#$vidTool += '[X]'	# Expects to be in same folder as this script
									    # Delete or REMARK if you don't want use it
#### Vid Tool 5
#$vidTool += '[X]'	# Expects to be in same folder as this script
									    # Delete or REMARK if you don't want use it
#### Vid Tool 6
#$vidTool += '[X]'	# Expects to be in same folder as this script
									    # Delete or REMARK if you don't want use it
##### End VidTools
$global:Url = "http://$CAST_XMRIP`:$CAST_XMRPort" # <-- DO NOT CHANGE THIS !!
#########################################################################
# Set drop trigger and startup timeout
#########################################################################
$hdiff = 1000000			# This is the drop in total hash rate where we
#						trigger a restart (Starting HASHRATE-$hdiff)
#
$timeout = 90			# (STARTUP ONLY)How long to wait for CAST_XMR to
#						return a hashrate before we fail out and
#						restart. There is no limiter on the number of restarts.
#						Press CTRL-C to EXIT
#						
$CAST_XMRstable = 90		# How long to wait for the hashrate to stabilize.
#
$global:vegaHash = 15000000	# Minimum vega hash rate before we also trigger
#						a restart
#########################################################################
###################### END USER DEFINED VARIABLES #######################
#################### MAKE NO CHANGES BELOW THIS LINE ####################

#####  BEGIN FUNCTIONS #####

function call-self 
{
	Start-Process -FilePath "C:\WINDOWS\system32\WindowsPowerShell\v1.0\Powershell.exe" -ArgumentList $ScriptDir\$ScriptName -WorkingDirectory $ScriptDir -NoNewWindow
	EXIT
}

Function log-Write
{
	Param ([string]$logstring)
	If ($Logfile)
	{
		Add-content $Logfile -value $logstring
	}
}

function reset-VegaDriver {
	###################################
	##### Reset Video Card driver #####
	##### No error checking
	Write-host "Resetting Driver..."
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Running Driver Reset")
	$d = Get-PnpDevice| where {$_.friendlyname -like 'Radeon RX Vega'}
	$d  | Disable-PnpDevice -ErrorAction Ignore -Confirm:$false | Out-Null
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Video driver disabled")
	Write-host -fore Green "Video driver disabled"
	# Wait 5 seconds
	Start-Sleep -s 5
	$d  | Enable-PnpDevice -ErrorAction Ignore -Confirm:$false | Out-Null
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Video driver enabled")
	Write-host -fore Green "Video driver enabled"
	# Wait 5 seconds
	Start-Sleep -s 10
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Video driver reset completed")
}

Function Run-Tools ($app)
{
	foreach ($item in $app)
	{
		$prog = ($item -split "\s", 2)
		if (Test-Path $prog[0])
		{
			Write-host -fore Green "Starting " $prog[0]
			$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
			log-Write ("$timeStamp	Starting $item ")
			If ($prog[1]) {
				Start-Process -FilePath $prog[0] -ArgumentList $prog[1] | Out-Null
			}
			Else
			{
			Start-Process -FilePath $prog[0] | Out-Null
			}
		Start-Sleep -s 1
		}
		Else
		{
		Write-Host -fore Red $prog[0] NOT found. This is not fatal. Continuing...
		}
	}
}

function start-Mining
{
	#####  Start CAST_XMR  #####
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Starting CAST_XMR...")
	If (Test-Path $global:CAST_XMRexe)
	{
		Write-Host "Starting CAST_XMR..."
		If ($CAST_XMRcmdline)
		{
			Start-Process -FilePath $ScriptDir\$CAST_XMRexe -ArgumentList $CAST_XMRcmdline -WindowStyle Minimized
		}
		Else
		{
			Start-Process -FilePath $ScriptDir\$CAST_XMRexe
		}
	}
	Else
	{
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		log-Write ("$timeStamp	$global:CAST_XMRexe NOT FOUND.. EXITING")
		Clear-Host
		Write-Host -fore Red `n`n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		Write-Host -fore Red "         $global:CAST_XMRexe NOT found. "
        Write-Host -fore Red "   Can't do much without the miner now can you!"
		Write-Host -fore Red "          Now exploding... buh bye!"
		Write-Host -fore Red !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		Write-Host -NoNewLine "Press any key to continue..."
		$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
		Exit
	}
}

Function chk-CAST_XMR($global:Url) {
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Waiting for CAST_XMR HTTP daemon to start")
	Write-host "Waiting for CAST_XMR HTTP daemon to start"
	
	$flag = "False"
	$web = New-Object System.Net.WebClient
    $TimeStart = Get-Date -format HH:mm:ss
    $timer = $timeout
	DO {
		Try {
			$result = $web.DownloadString($global:Url)
			$flag = "True"
			}
		Catch {
            $timeEnd = Get-Date -format HH:mm:ss
            $timeDiff = (New-TimeSpan -Start $timeStart -End (Get-Date -format HH:mm:ss)).TotalSeconds
            If ($timeDiff -lt $timeout)
			{
				Write-host -fore Red "CAST_XMR not ready... Waiting up to $timer seconds."
				Write-host -fore Red "Press CTRL-C to EXIT NOW"
			}
            If ($timeDiff -gt $timeout)
            {
                $timeout = 0
            }
			Start-Sleep -s 10
            $timer = $timer - 10
			}
		} While (($timeout -gt 1) -And ($flag -eq "False"))
	If ($flag -eq "True")
	{
		Clear-Host
		Write-host -fore Green "`n`n`n## CAST_XMR HTTP daemon has started ##`n"
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		log-Write ("$timeStamp	CAST_XMR started successfully")
		
	}
	ElseIf ($flag -eq "False")
	{
		Clear-Host
		Write-host -fore Red "`n`n`n!! Timed out waiting for CAST_XMR HTTP daemon to start !!`n"
		start-sleep -s 10
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		log-Write ("$timeStamp	Timed out waiting for CAST_XMR HTTP daemon to start")
		Start-Sleep -s 10
		#Write-Host -NoNewLine "Press any key to EXIT..."
		#$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
		call-Self
		EXIT
	}
	Else
	{
		Clear-Host
		Write-host -fore Red "`n`n`n*** Unknown failure (Daemon failed to start?)... EXITING ***`n"
		start-sleep -s 10
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		log-Write ("$timeStamp	Unknown failure starting CAST_XMR (Daemon failed to start?)")
		Start-Sleep -s 10
		#Write-Host -NoNewLine "Press any key to EXIT..."
		#$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
		call-Self
		EXIT
	}
	
}

function starting-Hash
{
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Waiting for hash rate to stabilize")
	#Write-host -fore Green "Waiting for hash rate to stabilize"

    #$startTestHash = 1
    $currTestHash = 0

	# Wait x seconds for hash rate to stabilize
	while ($CAST_XMRstable -gt 0)
	{
		$data = $null
		$total = $null
		$data = @{}
		$total = @{}
		$rawdata = Invoke-WebRequest -UseBasicParsing -Uri $global:Url
		If ($rawdata)
		{
			$data = $rawdata | ConvertFrom-Json
			$rawtotal = $data.total_hash_rate
			$total = $rawtotal
			$currTestHash = $total
			If (!$startTestHash)
			{
				$startTestHash = $currTestHash
			}	

			Clear-Host
			If ($currTestHash)
			{
				Write-host -fore Green "`n`nCurrent Hash Rate: $currTestHash H/s"
			}
			Write-host -fore Green "`n`nWaiting $CAST_XMRstable seconds for hashrate to stabilize."
			Write-host -fore Green "Press CTRL-C to EXIT NOW"
			Start-Sleep -s 1
			$CAST_XMRstable = $CAST_XMRstable - 1
		}
    }
    If (!$currTestHash)
	{
		Clear-Host
		Write-host -fore Green `nCould not get hashrate... restarting
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		log-Write ("$timeStamp	Could not get hashrate... restarting")
		call-Self
		Exit
	}
	ElseIf ($currTestHash -gt $startTestHash)
	{
		$global:maxhash = $currTestHash
	}
	Else
    {
		$global:maxhash = $startTestHash
	}

    $global:currHash = $currTestHash
	$global:rTarget = ($global:maxhash - $hdiff)
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Hash rate stabilized")
	log-Write ("$timeStamp	Starting Hashrate: $global:maxhash H/s	Drop Target Hashrate: $global:rTarget H/s")
}

function current-Hash
{
	# Check our current hashrate against low target every 60 seconds
	Clear-Host
	Write-host -fore Green `nHash monitoring has begun.
	$timer = 0
	$runTime = 0
	$flag = "False"
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Hash monitoring has begun")

	DO
	{
	Try {
		$data = $null
		$total = $null
		$data = @{}
		$total = @{}
		Write-host -fore Green `nQuerying CAST_XMR...this can take a minute.
		$rawdata = Invoke-WebRequest -UseBasicParsing -Uri $global:Url
		$flag = "True"
		}
	Catch
		{
			Clear-Host
			Write-host -fore Red "`nWe seem to have lost connectivity to CAST_XMR"
			Write-host -fore Red "Restarting in 10 seconds"
			$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
			log-Write ("$timeStamp	Restarting - Lost connectivity to CAST_XMR")
			Start-Sleep -s 10
			kill-Process ($CAST_XMRexe)
			$flag = "False"
			#Break
		}
		If ($flag -eq "False")
		{
			Break
		}
		$data = $rawdata | ConvertFrom-Json
		$rawtotal = $data.total_hash_rate
		$total = $rawtotal
		$global:currHash = $total
		
		refresh-Screen
		
		Start-Sleep -s 15
		$timer = ($timer + 15)
		$runTime = ($timer)
	} while (($global:currHash -gt $global:vegaHash) -and ($global:currHash -gt $global:rTarget))
	# ($global:currVega -gt $global:vegaHash)
	# ($global:currHash -gt $global:rTarget)
	
	If ($flag -eq "True")
	{
		Clear-Host
		# Write-host -fore Red "`n`nHash rate dropped from $global:maxhash H/s to $global:currHash H/s"
		Write-host -fore Red "Vega56 hash rate: $global:currVega H/s is below $global:vegaHash H/s"
		Write-host -fore Red "`nRestarting in 10 seconds"
		$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
		$tFormat =  get-RunTime ($runTime)
		#log-Write ("$timeStamp	Restarting after $tFormat - Hash rate dropped from $global:maxhash H/s to $global:currHash H/s")
		log-Write ("$timeStamp	Restarting - Vega56 hash rate: $global:currVega H/s is below $global:vegaHash H/s")
		Start-Sleep -s 10
	}
}

function kill-Process ($CAST_XMRexe) {
	try
	{
		$prog = ($CAST_XMRexe -split "\.", 2)
		$prog = $prog[0]
		# get CAST_XMR process
		$CAST_XMRPROC = Get-Process $prog -ErrorAction SilentlyContinue
		if ($CAST_XMRPROC) {
			# try gracefully first
			$CAST_XMRPROC.CloseMainWindow() | Out-Null
			# kill after five seconds
			Sleep 5
			if (!$CAST_XMRPROC.HasExited) {
				$CAST_XMRPROC | Stop-Process -Force | Out-Null
			}
			if (!$CAST_XMRPROC.HasExited) {
				Write-host -fore Red "Failed to kill the process $prog"
				Write-host -fore Red "`nIf we don't stop here CAST_XMR would be invoked"
				Write-host -fore Red "`nover and over until the PC crashed."
				Write-host -fore Red "`n`n That would be very bad."
				Write-host -fore Red 'Press any key to EXIT...';
				$null = $Host.UI.RawUI.ReadKey('NoEcho,IncludeKeyDown');
				$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
				log-Write ("$timeStamp	Failed to kill $prog")
				EXIT
			}
			Else
			{
				Write-host -fore Green "Successfully killed the process $prog"
				$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
				log-Write ("$timeStamp	CAST_XMR closed successfully")
			}
		}
		Else
		{
			Write-host -fore Green "`n$prog process was not found"
			$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
			log-Write ("$timeStamp	$prog process was not found")
		}
	}
	Catch
	{
			Write-host -fore Red "Failed to kill the process $prog"
			Write-host -fore Red "`nIf we don't stop here CAST_XMR would be invoked"
			Write-host -fore Red "`nover and over until the PC crashed."
			Write-host -fore Red "`n`n That would be very bad."
			Write-host -fore Red 'Press any key to EXIT...';
			$null = $Host.UI.RawUI.ReadKey('NoEcho,IncludeKeyDown');
			$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
			log-Write ("$timeStamp	Failed to kill $prog")
			EXIT
	}
}

Function refresh-Screen
{
	Clear-Host
	$tFormat =  get-RunTime ($runTime)
	Write-Host "=================================================="
	Write-host -fore Green `nStarting Hash Rate:	$global:maxhash H/s 
	Write-host -fore Green `nRestart Target Hash Rate:	$global:rTarget H/s
	Write-host -fore Green `nCurrent Hash Rate: $global:currHash H/s
	Write-host -fore Green `nVega56 Hash Rate: $global:currVega H/s
	Write-host -fore Green `nMonitoring Uptime:	$tFormat `n
	Write-Host "=================================================="
}

function resize-Console ($Width,$Height)
{
	$targetWindow = (get-host).ui.rawui
	$windowSize = $targetWindow.windowsize
	$windowSize.height = $Height
	$windowSize.width = $Width
	$targetWindow.windowsize = $windowSize
	$bufferSize = $targetWindow.buffersize
	$bufferSize.height = $Height
	$bufferSize.width = $Width
	$targetWindow.buffersize = $bufferSize
}

function set-CAST_XMRVars
{
	Write-host -fore Green "Setting Env Variables for CAST_XMR"
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Setting Env Variables for CAST_XMR")

	[System.Environment]::SetEnvironmentVariable("GPU_FORCE_64BIT_PTR", "1", "User")
	[System.Environment]::SetEnvironmentVariable("GPU_MAX_HEAP_SIZE", "99", "User")
	[System.Environment]::SetEnvironmentVariable("GPU_MAX_ALLOC_PERCENT", "99", "User")
	[System.Environment]::SetEnvironmentVariable("GPU_SINGLE_ALLOC_PERCENT", "99", "User")
	
	Write-host -fore Green "Env Variables for CAST_XMR have been set"
	$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
	log-Write ("$timeStamp	Env Variables for CAST_XMR have been set")
}

function get-RunTime ($sec)
{
	$myTimeSpan = (new-timespan -seconds $sec)
	If ($sec -ge 3600 -And $sec -lt 86400)
	{ 
		$global:runHours = $myTimeSpan.Hours
		$global:runMinutes = $myTimeSpan.Minutes
		Return "$global:runHours Hours $global:runMinutes Min"
	}
	ElseIf ($sec -ge 86400)
	{
		$global:runDays = $myTimeSpan.Days
		$global:runHours = $myTimeSpan.Hours
		$global:runMinutes = $myTimeSpan.Minutes
		Return "$global:runDays Days $global:runHours Hours $global:runMinutes Min"
	}
	Elseif ($sec -ge 60 -And $sec -lt 3600)
	{
		$global:runMinutes = $myTimeSpan.Minutes
		Return "$global:runMinutes Min"
	}
	Elseif ($sec -lt 60)
	{
		Return "Less than 1 minute"
	}
}

##### END FUNCTIONS #####

##### MAIN - or The Fun Starts Here #####
$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
log-Write ("$timeStamp	Script Started")

resize-Console 50 16

kill-Process ($CAST_XMRexe)

reset-VegaDriver ($devID)

If ($vidTool) # If $vidTool is defined
{
	Run-Tools ($vidTool) # Run your tools
}

set-CAST_XMRVars # Set suggested environment variables

start-Mining # Start mining software

chk-CAST_XMR($global:Url) # Wait for CAST_XMR to return a hash rate

starting-Hash # Get the starting hash rate

current-Hash # Gather the current hash rate every 60 seconds until it drops beneath the threshold

$timeStamp = "{0:yyyy-MM-dd_HH:mm}" -f (Get-Date)
log-Write ("$timeStamp	Script Ended")

call-Self # Restart the script

##### The End of the World as we know it #####
EXIT