PSChiaPlotter

1.0.54

PSChiaPlotter.psm1

enum KSize{
    K32 = 32
    K33 = 33
    K34 = 34
    K35 = 35
}

class MaximizedKSize {
    [KSize]$KSize
    [int]$MaxPlots
    [Decimal]$RemainingBytes
    [Decimal]$KSizeBytes
    [int64]$TotalBytes

    static [Decimal]$K35 = 884.1 * 1gb
    static [Decimal]$K34 = 429.8 * 1gb
    static [Decimal]$K33 = 208.8 * 1gb
    static [Decimal]$K32 = 101.4 * 1gb

    MaximizedKSize(
        [KSize]$KSize,
        [int64]$TotalBytes
    ){
        $this.KSize = $Ksize
        $this.TotalBytes = $TotalBytes

        $this.KSizeBytes = switch ($this.KSize){
            "K35" {[MaximizedKSize]::K35}
            "K34" {[MaximizedKSize]::K34}
            "K33" {[MaximizedKSize]::K33}
            "K32" {[MaximizedKSize]::K32}
        }
        $this.MaxPlots = [math]::Floor([decimal]($this.TotalBytes / $this.KSizeBytes))
        $this.RemainingBytes = $Totalbytes - (([math]::Floor([decimal]($this.TotalBytes / $this.KSizeBytes))) * $this.KSizeBytes)
    }
}
class OptimizedKPlots {
    [int]$K35
    [int]$K34
    [int]$K33
    [int]$K32
    [decimal]$RemainingBytes
    [double]$RemainingGB

    OptimizedKPlots (
        [int]$K35,
        [int]$K34,
        [int]$K33,
        [int64]$Totalbytes
    ){
        $sizeremaining = $TotalBytes - (($K35 * [MaximizedKSize]::K35) + ($K34 * [MaximizedKSize]::K34) + ($K33 * [MaximizedKSize]::K33))
        $k32max = Get-MaxKSize -Totalbytes $sizeremaining -KSize "K32"
        $this.K35 = $K35
        $this.K34 = $K34
        $this.K33 = $K33
        $this.K32 = $k32max.MaxPlots
        $this.RemainingBytes = $k32max.RemainingBytes
        $this.RemainingGB = [math]::Round($k32max.RemainingBytes / 1gb,2)
    }
}
function ConvertTo-FriendlyTimeSpan {
    [CmdletBinding()]
    param(
        [int32]$Seconds
    )

    $TimeSpan = New-TimeSpan -Seconds $Seconds
    switch ($TimeSpan){
        {$_.Days -ge 1} {return "$([math]::Round($TimeSpan.TotalDays,2)) days";break}
        {$_.Hours -ge 1} {return "$([math]::Round($TimeSpan.TotalHours,2)) hrs";break}
        {$_.Minutes -ge 1} {return "$([math]::Round($TimeSpan.TotalMinutes,2)) mins";break}
        {$_.seconds -ge 1} {return "$([math]::Round($TimeSpan.TotalSeconds,2)) sec";break}
    }
}
function Get-ChiaHarvesterActivity {
    [CmdletBinding()]
    param(
        [string[]]$DebugLogFilePath = (Get-ChildItem -Path "$([System.Environment]::GetFolderPath("User"))\.chia\mainnet\log" -filter "debug.log*").FullName,
        [switch]$Summary
    )
    $chiaharvesterlog = "([0-9:.\-T]*) harvester (?:src|chia).harvester.harvester(?:\s?): INFO\s*([0-9]*) plots were eligible for farming ([a-z0-9.]*) Found ([0-9]*) proofs. Time: ([0-9.]*) s. Total ([0-9]*) plots"
    foreach ($logfile in $DebugLogFilePath){
        try{
            $SummaryLog = New-Object 'System.Collections.Generic.List[System.Object]'
            Get-Content -Path $logfile | foreach-object {
                switch -Regex ($_){
                    $chiaharvesterlog {
                        $harvesterActivity = [pscustomobject]@{
                            PSTypeName = "PSChiaPlotter.ChiaHarvesterActivity"
                            Time = [datetime]::parse($Matches[1])
                            EligiblePlots = $Matches[2]
                            LookUpTime = [double]$Matches[5]
                            ProofsFound = $Matches[4]
                            TotalPlots = $Matches[6]
                            FilterRatio = 0
                        } #psobject
                        try { #Prevent the divide by zero error message
                            $harvesterActivity.FilterRatio = $Matches[2] / $Matches[6]
                        } catch { }
                        if (-not$Summary){
                            $harvesterActivity
                        }
                        else{
                            $SummaryLog.Add($harvesterActivity)
                        }
                    }
                } #switch
            } #foreach line
            if ($Summary.IsPresent -and $SummaryLog.Count -ne 0){
                Write-Information "Computing Summary for $logfile"
                if ([System.Environment]::OSVersion.Platform -eq "Win32NT"){
                    $FirstandLast = $SummaryLog | Sort-Object Time -Descending | Select-Object -First 1 -Last 1 | Sort-Object -Descending
                    $RunTime = $FirstandLast[1].Time - $FirstandLast[0].Time
                    if ($RunTime.TotalMinutes -lt 0){$RunTime = $FirstandLast[0].Time - $FirstandLast[1].Time}
                    if ($RunTime.TotalMinutes -ne 0){$ChallengesPerMinute = $SummaryLog.Count / $RunTime.TotalMinutes}
                }
                else{
                    Write-Warning "Unable to calculate average challenges per min on linux due the timestamps missing the date portion."
                }
                [PSCustomObject]@{
                    PSTypeName = "PSChiaPlotter.ChiaHarvesterSummary"
                    RunTime = $RunTime
                    TotalEligiblePlots = ($SummaryLog | Measure-Object EligiblePlots -Sum).Sum
                    BestLookUpTime = ($SummaryLog | Measure-Object LookUpTime -Minimum).Minimum
                    WorstLookUpTime = ($SummaryLog | Measure-Object LookUpTime -Maximum).Maximum
                    AverageLookUpTime = ($SummaryLog | Measure-Object LookUpTime -Average).Average
                    ProofsFound = ($SummaryLog | Measure-Object -Property ProofsFound -Sum).Sum
                    FilterRatio = ($SummaryLog | Measure-Object -Property FilterRatio -Average).Average
                    ChallengesPerMinute = $ChallengesPerMinute
                }
            }
        }
        catch{
            $PSCmdlet.WriteError($_)
        }
    } #foreach
}
function Get-ChiaKPlotCombination{
    [CmdletBinding(DefaultParameterSetName = "DriveLetter")]
    param(
        [Parameter(ParameterSetName="FreeSpace")]
        [int64[]]$FreeSpace,
        [Parameter(ParameterSetName="DriveLetter")]
        [string[]]$DriveLetter = (Get-Volume).DriveLetter
    )

    if ($PSCmdlet.ParameterSetName -eq "FreeSpace"){
        foreach ($space in $FreeSpace){
            $Max = Get-MaxKSize -TotalBytes $space
            $AllCombos = Get-OptimizedKSizePlotNumbers $Max | sort RemainingBytes
            $AllCombos | Add-Member -MemberType NoteProperty -Name "StartingFreeSpace" -Value $space
            $AllCombos
        }
    }
    elseif ($PSCmdlet.ParameterSetName -eq "DriveLetter"){
        foreach ($letter in $DriveLetter){
            $Drive = Get-Volume -DriveLetter $letter
            $Max = Get-MaxKSize -TotalBytes $Drive.SizeRemaining
            $AllCombos = Get-OptimizedKSizePlotNumbers $Max | sort RemainingBytes
            $AllCombos | Add-Member -NotePropertyMembers @{
                DriveLetter = $letter
                FriendlyName = $Drive.FileSystemLabel
            }
            $AllCombos | foreach {$_.psobject.TypeNames.Insert(0,"PSChiaPlotter.KSizeCombination")}
            $AllCombos
        }
    }
}
function Get-ChiaMaxParallelCount {
    [CmdletBinding()]
    param(
        [Parameter()]
        [ValidateRange(1,128)]
        [int]$ThreadCount = 2,
        [Parameter()]
        [ValidateRange(1, [int]::MaxValue)]
        [int]$BufferMiB = 3390
    )

    if (!$PSBoundParameters.ContainsKey("ThreadCount") -and !$PSBoundParameters.ContainsKey("BufferMiB")){
        Write-Warning "All calculations based on plotting k32 plot size only. SSD TB suggestion rounded up to the nearest TB."
    }
    else{
        Write-Warning "SSD TB suggestion rounded up to the nearest TB."
    }
    $Processor = Get-CimInstance -ClassName Win32_Processor
    $Threads = ($Processor | measure -Property ThreadCount -Sum).Sum
    $MaxParallelCountCPU = [math]::Floor($Threads / $ThreadCount)
    #1mb = 1048576 bytes
    $RAM = (Get-CimInstance -ClassName Win32_PhysicalMemory | measure -Property Capacity -Sum).Sum / 1mb
    $MaxParallelCountRAM = [Math]::Floor([decimal]($RAM / $BufferMiB))

    $SystemDisk = Get-CimInstance -Namespace ROOT/Microsoft/Windows/Storage -ClassName MSFT_Disk -Filter "IsSystem=True"
    $SSDs = Get-CimInstance -Namespace root/microsoft/windows/storage -ClassName MSFT_PhysicalDisk -Filter "MediaType=4" #4 -eq SSD
    $SSDs = $SSDs | where UniqueId -ne $SystemDisk.UniqueId | select 
    $One_TB = 1000000000000
    $One_GB = 1000000000
    $TotalSSDspace = ($SSDs | measure -Property Size -Sum).Sum
    $SSD_Count = ($SSDs | Measure-Object).Count
    if ($SSD_Count -eq 0){
        Write-Warning "No non-system SSD found, therefore Current_MaxParallelPlots will be 0. (Ignore if using mutiple HDDs)"
    }

    if ($Threads -gt ($Processor.NumberOfCores * 2)){
        Write-Warning "Threads may actually only be half what is reported and therefore all calculations are off."
    }

    $SSD_MAX = [math]::Floor([decimal]($TotalSSDspace / (256.6 * $One_GB)))

    if ($MaxParallelCountCPU -le $MaxParallelCountRAM){
        $MAXCount = $MaxParallelCountCPU
        $BottleNeck = "CPU"        
    }
    else{
        $MAXCount = $MaxParallelCountRAM
        $BottleNeck = "RAM"        
    }
    $Suggested_SSD_TB = [math]::Ceiling([decimal](256.6 * $MAXCount) / 1000)

    if ($SSD_MAX -le $MAXCount){
        $CurrentMax = $SSD_MAX
        $BottleNeck = "SSD"
    }
    else{
        $CurrentMax = $MAXCount
    }

    $Suggested_SSD_TB = [math]::Ceiling([decimal](256.6 * $MAXCount) / 1000)

    [PSCustomObject]@{
        ThreadCount = $ThreadCount
        Buffer = $BufferMiB
        CPUTotalThreads = $Threads
        CPUCores = ($Processor | Measure -Property NumberOfCores -Sum).Sum
        NumberOfProcessors = ($Processor | measure).Count
        TotalRAM_MiB = $RAM
        BottleNeck = $BottleNeck
        Current_SSD_SPACE_TB = [math]::Round(($TotalSSDspace / $One_TB),2)
        Current_SSD_Count = $SSD_Count
        Suggested_SSD_SPACE_TB = $Suggested_SSD_TB
        Current_MaxParallelPlots = $CurrentMax
        Potential_MAXParallelPlots = $MAXCount
    }
}
function Get-ChiaPlotProgress {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidateScript({Test-Path -Path $_})]
        [string]$LogPath,
        [switch]$MadMax
    )

    if ([System.IO.Directory]::Exists($LogPath)){
        Write-Error "You provided a directory path and not a file path to the log file" -ErrorAction Stop
    }

    #base code from https://github.com/swar/Swar-Chia-Plot-Manager/blob/7287eef4796dbfa4cc009086c6502d19f0706f3e/config.yaml.default
    if ($MadMax){
        $phase1_line_end = 8
        $phase2_line_end = 22
        $phase3_line_end = 36
        $phase4_line_end = 41
        $copyfile_line_end = 44
        $phase1_weight = 43
        $phase2_weight = 25
        $phase3_weight = 25
        $phase4_weight = 5
        $copyphase_weight = 2  
    }
    else{
        $phase1_line_end = 801
        $phase2_line_end = 834
        $phase3_line_end = 2474
        $phase4_line_end = 2620
        $copyfile_line_end = 2627
        $phase1_weight = 33
        $phase2_weight = 20
        $phase3_weight = 42
        $phase4_weight = 3
        $copyphase_weight = 2  
    }

    $LogItem = Get-Item -Path $LogPath
    $StartTime = $LogItem.CreationTime
    $EndTime = Get-Date
    $ElaspedTime = New-TimeSpan -Start $StartTime -End $EndTime

    $LogFile = Get-Content -Path $LogPath
    if ($MadMax){
        $plotId = $LogFile | Select-String -SimpleMatch "Plot Name: " | ForEach-Object {$_ -split "-" | Select-Object -Last 1}
        $SkipLines = 14
        if ($null -ne ($LogFile | Select-String -SimpleMatch 'Number of Buckets P3+P4')){
            $SkipLines++
        }
        $line_count = ($LogFile | Select-Object -Skip $SkipLines | Measure-Object).Count
    }
    else{
        $plotId = $LogFile | Select-String -SimpleMatch "ID: " | ForEach-Object {$_.ToString().Split(" ")[1]}
        $line_count = $LogFile.Count
    }

    $plotProgressObject = [PSCustomObject]@{
        Progress = 0
        Phase = "Phase 1"
        ElaspedTime = $ElaspedTime
        EST_TimeRemaining = New-TimeSpan
        PlotId = $plotId
        Phase1Progess = 0
        Phase2Progess = 0
        Phase3Progess = 0
        Phase4Progess = 0
        CopyProgess = 0
    }

    if ($line_count -ge $phase1_line_end){
        $plotProgressObject.Phase1Progess = 100
        $plotProgressObject.Progress += $phase1_weight
    }
    else{
        $Phase1Progess = ($line_count / $phase1_line_end)
        if ($Phase1Progess -eq 0){
            $Phase1Progess = .01
        }
        $plotProgressObject.Phase1Progess = [math]::Round(($Phase1Progess * 100),2)
        $plotProgressObject.Progress += $phase1_weight * $Phase1Progess
        $plotProgressObject.Phase = "Phase 1"
        $Est_TimeRemaining = ($ElaspedTime.TotalSeconds * 100) / $plotProgressObject.Progress
        $plotProgressObject.EST_TimeRemaining = New-TimeSpan -Seconds ($Est_TimeRemaining - $ElaspedTime.TotalSeconds)

        return $plotProgressObject
    }
    if ($line_count -ge $phase2_line_end){
        $plotProgressObject.Phase2Progess = 100
        $plotProgressObject.Progress += $phase2_weight
    }
    else{
        $phase2Progress = ($line_count - $phase1_line_end) / ($phase2_line_end - $phase1_line_end)
        $plotProgressObject.Phase2Progess = [math]::Round(($phase2Progress * 100),2)
        $plotProgressObject.Progress += $phase2_weight * $phase2Progress
        $plotProgressObject.Phase = "Phase 2"

        $Est_TimeRemaining = ($ElaspedTime.TotalSeconds * 100) / $plotProgressObject.Progress
        $plotProgressObject.EST_TimeRemaining = New-TimeSpan -Seconds ($Est_TimeRemaining - $ElaspedTime.TotalSeconds)

        return $plotProgressObject
    }
    if ($line_count -ge $phase3_line_end){
        $plotProgressObject.Phase3Progess = 100
        $plotProgressObject.Progress += $phase3_weight
    }
    else{
        $phase3Progess = ($line_count - $phase2_line_end) / ($phase3_line_end - $phase2_line_end)
        $plotProgressObject.Phase3Progess = [math]::Round(($phase3Progess * 100),2)
        $plotProgressObject.Progress += $phase3_weight * $phase3Progess
        $plotProgressObject.Phase = "Phase 3"

        $Est_TimeRemaining = ($ElaspedTime.TotalSeconds * 100) / $plotProgressObject.Progress
        $plotProgressObject.EST_TimeRemaining = New-TimeSpan -Seconds ($Est_TimeRemaining - $ElaspedTime.TotalSeconds)
        return $plotProgressObject
    }
    if ($line_count -ge $phase4_line_end){
        $plotProgressObject.Phase4Progess = 100
        $plotProgressObject.Progress += $phase4_weight
    }
    else{
        $phase4Progess = ($line_count - $phase3_line_end) / ($phase4_line_end - $phase3_line_end)
        $plotProgressObject.Phase4Progess = [math]::Round(($phase4Progess * 100),2)
        $plotProgressObject.Progress += $phase4_weight * $phase4Progess
        $plotProgressObject.Phase = "Phase 4"
        
        $Est_TimeRemaining = ($ElaspedTime.TotalSeconds * 100) / $plotProgressObject.Progress
        $plotProgressObject.EST_TimeRemaining = New-TimeSpan -Seconds ($Est_TimeRemaining - $ElaspedTime.TotalSeconds)

        return $plotProgressObject
    }
    if ($line_count -lt $copyfile_line_end){
        $Est_TimeRemaining = ($ElaspedTime.TotalSeconds * 100) / $plotProgressObject.Progress
        $plotProgressObject.EST_TimeRemaining = New-TimeSpan -Seconds ($Est_TimeRemaining - $ElaspedTime.TotalSeconds)
        $plotProgressObject.Phase = "Copying"

        return $plotProgressObject
    }
    $plotProgressObject.Progress += $copyphase_weight
    $plotProgressObject.CopyProgess = 100
    $plotProgressObject.Phase = "Complete"
    $plotProgressObject.ElaspedTime = New-TimeSpan -Start $StartTime -End $LogItem.LastWriteTime
    $plotProgressObject.EST_TimeRemaining = 0
    return $plotProgressObject
}
function Get-ChiaPlottingStatistic {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline,ValueFromPipelineByPropertyName)]
        [string[]]$Path = (Get-ChildItem -Path $env:USERPROFILE\.chia\mainnet\plotter\ | sort CreationTime -Descending).FullName
    )

    Process{
        foreach ($log in $path){
            if (Test-Path $log){
                $Content = Get-Content -Path $log
                $FirstLine = $Content | Select-Object -First 1
                if ($FirstLine -like "Multi-threaded pipelined*"){
                    #Madmax log file
                    foreach ($madmaxline in $Content){
                        switch -Wildcard ($madmaxline){
                            "Plot Name:*" {
                                $PlotID = $madmaxline.Split("-") | Select-Object -Last 1
                                $PlotSize = ($madmaxline.Split("-") | Select-Object -Skip 1 -First 1).TrimStart('k')
                            }
                            "*Threads:*" {$ThreadCount = $madmaxline -split ": " | Select-Object -Last 1}
                            "Phase 1*" {$Phase_1 = $madmaxline.Split(' ')[3]}
                            "Phase 2*" {$Phase_2 = $madmaxline.Split(' ')[3]}
                            "Phase 3*" {$Phase_3 = $madmaxline.Split(' ')[3]}
                            "Phase 4*" {$Phase_4 = $madmaxline.Split(' ')[3]}
                            "Total*" {$TotalTime = $madmaxline.Split(' ')[5]}
                            "Copy*" {$CopyTime = $madmaxline.Split(',')[1].Split(' ')[2]}
                            "Working Directory:*" {$TempDrive = ($madmaxline -split ": " | Select-Object -Last 1).Trim().Split('\') | select -First 1}
                            "Working Directory 2:*" {$SecondTempDir = ($madmaxline -split ": " | Select-Object -Last 1).Split('\') | select -First 1}
                            "Final Directory:*" {$FinalDrive = ($madmaxline -split ": " | Select-Object -Last 1).Split('\') | select -First 1}
                            default {Write-Information "Could not match line: $line"}
                        }
                    } #foreach
                    $BufferSize = 0
                }
                else{
                    #OG log file
                    $ImportantLines = @("ID: ","Time for phase","Total time","Plot size","Buffer size","threads of stripe","Copy time","Copied final file from","Starting plotting progress into temporary dirs")
                    $ContentLines = $Content | Select-String -SimpleMatch $ImportantLines | ForEach-Object {$_.ToString()}
                    foreach ($line in $ContentLines){
                        switch -Wildcard ($line){
                            "ID: *" {$PlotID = $line.Split(' ') | select -Skip 1 -First 1}
                            "Plot size*" {$PlotSize = $line.split(' ') | select -Skip 3} #using select for these since indexing will error if empty
                            "Buffer Size*" {$BufferSize = ($line.Split(' ') | select -Skip 3).split("M") | select -First 1}
                            "*threads*" {$ThreadCount = $line.split(' ') | select -First 1 -Skip 1}
                            "*phase 1*" {$Phase_1 = $line.Split(' ') | select -First 1 -Skip 5}
                            "*phase 2*" {$Phase_2 = $line.Split(' ') | select -First 1 -Skip 5}
                            "*phase 3*" {$Phase_3 = $line.Split(' ') | select -First 1 -Skip 5}
                            "*phase 4*" {$phase_4 = $line.Split(' ') | select -First 1 -Skip 5}
                            "Total time*" {$TotalTime = $line.Split(' ') | select -First 1 -Skip 3}
                            "Copy time*" {$CopyTime = $line.Split(' ') | select -First 1 -Skip 3}
                            "Starting plotting progress into temporary dirs*" {$TempDrive = ($line.Split(' ') | select -First 1 -Skip 6).Split('\') | select -First 1 }
                            "Copied final file from*" {$FinalDrive = ($line.Split(' ') | select -First 1 -Skip 6).Split('\').Replace('"', '') | select -First 1}
                            default {Write-Information "Could not match line: $line"}
                        }
                    } #foreach
                    $SecondTempDir = $null
                } #if/else

                [PSCustomObject]@{
                    PSTypeName = "PSChiaPlotter.ChiaPlottingStatistic"
                    PlotId = $PlotID
                    KSize = $PlotSize
                    "RAM(MiB)" = $BufferSize
                    Threads = $ThreadCount
                    "Phase_1_sec" = [int]$Phase_1
                    "Phase_2_sec" = [int]$Phase_2
                    "Phase_3_sec" = [int]$Phase_3
                    "Phase_4_sec" = [int]$phase_4
                    "TotalTime_sec" = [int]$TotalTime
                    "CopyTime_sec" = [int]$CopyTime
                    "PlotAndCopyTime_sec" = ([int]$CopyTime + [int]$TotalTime)
                    "Time_Started" = (Get-Item -Path $log).CreationTime 
                    "Temp_drive" = $TempDrive
                    "Final_drive" = $FinalDrive
                    "SecondTemp_Directory" = $SecondTempDir
                }
                Clear-Variable -Name "PlotID","PlotSize","BufferSize","ThreadCount","Phase_1","Phase_2","Phase_3","Phase_4","TotalTime","CopyTime","FinalDrive","TempDrive","FirstLine","SecondTempDir" -ErrorAction SilentlyContinue
            }
        }
    }
}
function Get-ChiaProcessCounter{
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [int[]]$ChiaPID
    )

    foreach ($ID in $ChiaPID){
        $QueryString += "OR IDProcess=$ID "
    }

    $Performance = Get-CimInstance -Query "Select workingSetPrivate,PercentProcessorTime,IDProcess FROM Win32_PerfFormattedData_PerfProc_Process WHERE NAME='_Total' $QueryString"
    $TotalCPU = $Performance | where {$_.Name -eq '_Total'}
    $ChiaProcesses = $Performance | where {$_.Name -ne '_Total'}
    foreach ($process in $ChiaProcesses){
        if ($process.PercentProcessorTime -ne 0){
            $CPUPer = ($process.PercentProcessorTime / $TotalCPU.PercentProcessorTime) * 100
            $RoundedCPU = [math]::Round($CPUPer,2)
        }
        else{$CPUPer = 0}

        [PSCustomObject]@{
            ChiaPID = $process.IDProcess
            CPUPercent = $RoundedCPU
        }
    }
}
function Get-ChiaRAMInfo {
    [CmdletBinding()]
    param(
    )

    Begin{

    } #Begin

    Process{
    
        $Array = Get-CimInstance -Class Win32_PhysicalMemoryArray
        $CurrentRAM = Get-CimInstance -Class Win32_PhysicalMemory

        [PSCustomObject]@{
            PSTypeName = "PSChiaPlotter.RAMInfo"
            ComputerName = $ENV:COMPUTERNAME
            SlotsInUse = ($CurrentRAM | Measure).Count
            SlotsFree = $Array.MemoryDevices - ($CurrentRAM | Measure).Count
            CurrentSize_GB = (($CurrentRAM).Capacity | Measure -Sum).Sum / 1gb
            MaxSize_GB = $Array.MaxCapacityEx / 1mb
            PartNumber = ($CurrentRAM.PartNumber | Select -Unique | foreach {$_.Trim()})
            Manufacturer = ($CurrentRAM.Manufacturer | Select -Unique | foreach {$_.Trim()})
            TotalSlots = $Array.MemoryDevices
            RAMDevices = $CurrentRAM
        }
    } #Process
}
function New-TestPlotWatcher {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline,ValueFromPipelineByPropertyName)]
        [ValidateScript({Test-Path -Path $_ -PathType Container})]
        [string]$Path
    )

    Process{
        $Watcher = [System.IO.FileSystemWatcher]::new($Path,"*.plot")
        $Watcher.EnableRaisingEvents = $true
        $Watcher.IncludeSubdirectories = $false

        $Action = {
            $PlotPath = $Event.SourceEventArgs.FullPath
            if ($PlotPath.EndsWith(".plot")){
                $ParentDirectory = Split-Path -Path $PlotPath -Parent
                $CSVPath = Join-Path $ParentDirectory -ChildPath "PlotsCheck.csv"
                Test-ChiaPlot -Path $PlotPath | Export-Csv -Path $CSVPath -NoTypeInformation -Append
            }
        }
        Register-ObjectEvent -InputObject $Watcher -Action $Action -EventName Renamed -SourceIdentifier "$Path-Watcher"
    }
}
function Show-ChiaPlottingStatistic{
    [CmdletBinding()]
    param(
        [ValidateNotNullOrEmpty()]
        [string[]]$LogPath
    )

    $LogStats = Get-ChiaPlottingStatistic -Path $Logpath
    $newlogstats = foreach ($stat in $LogStats){
        try{
            $phase1 = New-TimeSpan -Seconds $stat.Phase_1_sec
            $phase2 = New-TimeSpan -Seconds $stat.Phase_2_sec
            $phase3 = New-TimeSpan -Seconds $stat.Phase_3_sec
            $phase4 = New-TimeSpan -Seconds $stat.Phase_4_sec
            $totaltime = New-TimeSpan -Seconds $stat.TotalTime_sec
            $copyTime = New-TimeSpan -Seconds $stat.CopyTime_sec
            $copyandplot = New-TimeSpan -Seconds $stat.PlotAndCopyTime_sec

            if ($stat.PlotId){
                $stat | Add-Member -NotePropertyMembers @{
                    Phase_1 = $phase1
                    Phase_2 = $phase2
                    Phase_3 = $phase3
                    Phase_4 = $phase4
                    PlotTime = $totaltime
                    CopyPhase = $copyTime
                    PlotAndCopy = $copyandplot
                }
                $stat
            }
        }
        catch{
            Write-Information "Unable to add time span properties"
        }
    }

    if ($logPath.Count -eq 1){
        $WPF = Join-Path -Path $MyInvocation.MyCommand.Module.ModuleBase -ChildPath "WPFWindows"
        $XAMLPath = Join-Path -Path $WPF -ChildPath ChiaLogStats.xaml
        $ChiaLogWindow = Import-Xaml -Path $XAMLPath
        $ChiaLogWindow.DataContext = $newlogstats
        $ChiaLogWindow.ShowDialog() | Out-Null
    }
    else{
        $WPF = Join-Path -Path $MyInvocation.MyCommand.Module.ModuleBase -ChildPath "WPFWindows"
        $XAMLPath = Join-Path -Path $WPF -ChildPath ChiaLogStatsGrid.xaml
        $ChiaLogWindow = Import-Xaml -Path $XAMLPath
        $DataGrid = $ChiaLogWindow.FindName("DataGrid")
        $DataGrid.ItemsSource = $newlogstats
        $ChiaLogWindow.ShowDialog() | Out-Null
    }
}
function Show-PSChiaPlotter {
    [CmdletBinding()]
    param(
        [switch]$DebugWithNotepad,
        [Parameter(DontShow)]
        [switch]$NoNewWindow,
        [Parameter(DontShow)]
        [int]$Threads = [int]$ENV:NUMBER_OF_PROCESSORS
    )
    Add-Type -AssemblyName PresentationFramework

    $PSChiaPlotterFolderPath = "$ENV:LOCALAPPDATA\PSChiaPlotter"
    if (-not(Test-Path -Path $PSChiaPlotterFolderPath)){
        New-Item -Path $PSChiaPlotterFolderPath -ItemType Directory | Out-Null
    }

    if (-not$PSBoundParameters.ContainsKey("Threads")){
        $Threads = [int]$ENV:NUMBER_OF_PROCESSORS
        if ($Threads -eq 0){
            Write-Warning "Unable to grab the CPU thread count... please enter the thread count below"
            $Respnose = Read-Host -Prompt "How many CPU Threads does this system have?"
            foreach ($char in $Respnose.ToCharArray()){
                if (-not[char]::IsNumber($char)){
                    Write-Warning "You didn't enter in a number..."
                    return
                }
            } #foreach
            $Threads = [int]$Respnose
            if (([int]$Threads -le 0)){
                Write-Warning "You didn't enter in a number above 0... exiting"
                return
            }
        }
    }

    $PSChiaPlotterFolderPath = Join-Path -Path $ENV:LOCALAPPDATA -ChildPath 'PSChiaPlotter\Logs'
    $LogName = (Get-Date -Format yyyyMMdd) + '_debug.log'
    $LogPath = Join-Path -Path $PSChiaPlotterFolderPath -ChildPath $LogName
    if (-not$NoNewWindow.IsPresent){
        $parameters = @{
            FilePath = "powershell.exe"
            ArgumentList = "-NoExit -NoProfile -STA -Command Show-PSChiaPlotter -NoNewWindow -Threads $Threads"
            WindowStyle = "Hidden"
            RedirectStandardOutput = $LogPath
        }
        Start-Process @parameters
        return
    }
    #Start-Transcript -Path $LogPath | Out-Null

    $Global:UIHash = [hashtable]::Synchronized(@{})
    $Global:DataHash = [hashtable]::Synchronized(@{})
    $Global:ScriptsHash = [hashtable]::Synchronized(@{})
    $InitialSessionState = [System.Management.Automation.Runspaces.InitialSessionState]::CreateDefault()
    $UISync = [System.Management.Automation.Runspaces.SessionStateVariableEntry]::new("UIHash", $UIHash, $Null)
    $DataSync = [System.Management.Automation.Runspaces.SessionStateVariableEntry]::new("DataHash", $DataHash, $Null)
    $ScriptsSync = [System.Management.Automation.Runspaces.SessionStateVariableEntry]::new("ScriptsHash", $ScriptsHash, $Null)
    $InitialSessionState.Variables.Add($UISync)
    $InitialSessionState.Variables.Add($DataSync)
    $InitialSessionState.Variables.Add($ScriptsSync)

    $MaxThreads = ([int]$Threads + 5)
    $RunspacePool = [runspacefactory]::CreateRunspacePool(1,$MaxThreads,$InitialSessionState,$Host)
    $RunspacePool.ApartmentState = "STA"
    $RunspacePool.ThreadOptions = "ReuseThread"
    $RunspacePool.open()

    #DataHash Adding Properties
    $DataHash.ModuleRoot = $MyInvocation.MyCommand.Module.ModuleBase
    $DataHash.PrivateFunctions = Join-Path -Path $DataHash.ModuleRoot -ChildPath "Private"
    $DataHash.WPF = Join-Path -Path $DataHash.ModuleRoot -ChildPath "WPFWindows"
    $DataHash.Classes = Join-Path -Path $DataHash.ModuleRoot -ChildPath "Classes"
    $DataHash.Runspaces = New-Object System.Collections.Generic.List[System.Object]
    $DataHash.HelpFiles = Join-Path -Path $DataHash.ModuleRoot -ChildPath "HelpFiles"
    #DEBUG SWITCH
    $DataHash.Debug = $DebugWithNotepad.IsPresent
    $DataHash.LogPath = $LogPath

    $ScriptsHash.RunspacePool = $RunspacePool

    #Import required assemblies and private functions
    Get-childItem -Path $DataHash.PrivateFunctions -File | ForEach-Object {Import-Module $_.FullName}
    #Get-childItem -Path $DataHash.Assemblies -File | ForEach-Object {Add-Type -Path $_.FullName}

    
    #$QueueRunspace = New-ChiaQueueRunspace
    #$QueueRunspace.Runspacepool = $RunspacePool
    #$ScriptsHash.QueueRunspace = $QueueRunspace

    #Create UI Thread
    $UIRunspace = New-UIRunspace
    $UIRunspace.RunspacePool = $RunspacePool
    $DataHash.UIRunspace = $UIRunspace
    $DataHash.UIHandle = $UIRunspace.BeginInvoke()
    $Date = Get-Date -Format "[yyyy-MM-dd.HH:mm:ss]"
    Write-Host "[INFO]-$Date-Staring PSChiaPlotter GUI - PID = $($PID)"

    $UIHash.NewWindow = $true
    $UIHash.PowershellPID = $PID

    $RunspacePoolEvent = Register-ObjectEvent -InputObject $DataHash.UIRunspace -EventName InvocationStateChanged -Action {
        $NewState = $Event.Sender.InvocationStateInfo.State
        #Get-childItem -Path $DataHash.PrivateFunctions -File | ForEach-Object {Import-Module $_.FullName}
        #for some reason importing the private functions is not working...
        $Date = Get-Date -Format "[yyyy-MM-dd.HH:mm:ss]"
        if ($NewState -eq "Completed"){
            try{
                $ScriptsHash.RunspacePool.Close()
                $ScriptsHash.RunspacePool.Dispose()
                if ($UIHash.NewWindow){
                    
                    $Message = "PSChiaPlotter has been closed... Stopping Powershell process with PID of $($UIHash.PowershellPID)"
                    Write-Host "[INFO]-$Date-$Message"
                    Stop-Process -Id $UIHash.PowershellPID -Force
                }
            }
            catch{
                $Date = Get-Date -Format "[yyyy-MM-dd.HH:mm:ss]"
                $Message = "PSChiaPlotter has been closed... unable to stop powershell process with PID of $($UIHash.PowershellPID)"
                Write-Host "[WARNING]-$Date-$WARNING-$Message"
                Write-Host "[ERROR]-$Date-$($_.InvocationInfo.ScriptLineNumber)-$($_.Exception.Message)"
            }
        }
        else{
            #do nothing
        }
    }
}
<#
.SYNOPSIS
    This will display your harvesters lookup times in graphical heatmap.
.DESCRIPTION
    This function will display harvesters lookup times in graphcial heatmap by scaling the seconds to an RGB color and creating a color block with that color.
     
    The number of eligible proofs are placed inside the color block and proof found block will be blue.
     
    A summary is also generated and placed in the title of powershell window. The function will continue to look at the log file and update the heatmap with new harvester activities as they come in.
.EXAMPLE
    PS C:\> Start-ChiaHarvesterWatcher
     
    |1| | | | |2| | | |....
    | | |2|1|3| | | |1|....
 
    This will create the default heat map. With good time showing up as bright green and transitions to yellow then orange then red as the get closer to or above 5 seconds.
.EXAMPLE
    PS C:\> Start-ChiaHarvesterWatcher -DarkMode
 
    |1| | | | |2| | | |....
    | | |2|1|3| | | |1|....
 
    This will create a dark mode version of the heatmap that goes from gray (closer to 0 seconds) to yellow/orange/red as it gets clsoer to 5 seconds.
.EXAMPLE
    PS C:\>Start-ChiaHarvesterWatcher -MaxLookUpSeconds 2 -NoWalls
 
    1 11 2 3 ...
      21 1 3 1 ...
     
    This example will have lookup times close to 0 still be bright green, but the color transitions faster to red since the MaxLookUpSeconds is set to 2.
    Nowall switch takes away the | between color blocks.
.INPUTS
    Inputs (if any)
.OUTPUTS
    Output (if any)
.NOTES
    Requires Chia log levels to be set to INFO.
#>
function Start-ChiaHarvesterWatcher {
    [CmdletBinding()]
    param(
        [string]$DebugLogFilePath = (Get-ChildItem -Path "$ENV:USERPROFILE\.chia\mainnet\log" -filter "debug.log").FullName,
        [ValidateRange(0,1000)]
        [double]$MaxLookUpSeconds = 5,
        [Parameter()]
        [ValidateScript({[System.IO.Directory]::Exists((Split-Path -Path $_ -Parent))})]
        [string]$ExportCSVPath,
        [switch]$DarkMode,
        [switch]$NoWalls
    )

    if ($PSBoundParameters.ContainsKey("ExportCSVPath")){
        if (-not($ExportCSVPath.EndsWith('.csv'))){
            Write-Warning "Export CSV Path does not end with .csv, please provide a valid CSV path and run the command again... exiting."
            return
        }
    }

    $chiaharvesterlog = "([0-9:.\-T]*) harvester chia.harvester.harvester: INFO\s*([0-9]*) plots were eligible for farming ([a-z0-9.]*) Found ([0-9]*) proofs. Time: ([0-9.]*) s. Total ([0-9]*) plots"
    $BestSpeed = 1000
    $WorstSpeed = 0
    $Over1Seconds = 0
    $Over5Seconds = 0
    $Over30Seconds = 0
    $TotalAttempts = 0
    $TotalFilterRatio = 0
    $TotalLookupTime = 0
    $proofsFound = 0

    Get-Content -Path $DebugLogFilePath -Wait | foreach-object {
        switch -Regex ($_){
            $chiaharvesterlog {
                $harvesterActivity = [pscustomobject]@{
                    Time = [datetime]::parse($Matches[1])
                    EligiblePlots = [int]$Matches[2]
                    LookUpTime = [double]$Matches[5]
                    ProofsFound = [int]$Matches[4]
                    TotalPlots = [int]$Matches[6]
                    FilterRatio = 0
                } #psobject
                try { #Prevent the divide by zero error message
                    $harvesterActivity.FilterRatio = $Matches[2] / $Matches[6]
                } catch { }
                $TotalAttempts++
                switch ($harvesterActivity.LookUpTime) {
                    {$_ -lt $BestSpeed} {$BestSpeed = $_}
                    {$_ -gt $WorstSpeed} {$WorstSpeed = $_}
                    {$_ -ge 1} {$Over1Seconds++}
                    {$_ -ge 5} {$Over5Seconds++}
                    {$_ -ge 30} {$Over30Seconds++}
                }
                if ($PSBoundParameters.ContainsKey("ExportCSVPath")){
                    $harvesterActivity | Export-Csv -Path $ExportCSVPath -Append
                }
                $proofsFound += $harvesterActivity.ProofsFound
                $TotalLookupTime += $harvesterActivity.LookUpTime
                $AverageSpeed = [math]::Round(($TotalLookupTime / $TotalAttempts),5)
                $TotalFilterRatio += $harvesterActivity.FilterRatio
                $newRatio = [math]::Round(($TotalFilterRatio / $TotalAttempts),5)
                $eligibleplots = " "
                if ($harvesterActivity.EligiblePlots -gt 0){
                    $eligibleplots = $harvesterActivity.EligiblePlots
                }
                $host.UI.RawUI.WindowTitle = "Total Attempts: $TotalAttempts || LookUp Time - Best: $BestSpeed , Worst: $WorstSpeed , Avg: $AverageSpeed || Over 1 Sec:$Over1Seconds, Over 5 Sec: $Over5Seconds, Over 30 Sec: $Over30Seconds || FilterRatio: $newRatio || Proofs Found: $proofsFound || Last Look up Time: $($harvesterActivity.LookUpTime)"

                $RGB = [math]::Round((255 * $harvesterActivity.LookUpTime) / $MaxLookUpSeconds)
                $RGBText = @{
                    bRed = ([math]::Min($RGB,255))
                    bGreen = ([math]::max([math]::Min(255,(510 - $RGB)),0))
                    UnderLine = $true
                    Text = "$eligibleplots|"
                    NoNewLine = $true
                }

                if ($DarkMode){
                    if ($harvesterActivity.LookUpTime -le $MaxLookUpSeconds){
                            $RGBText["bred"] = [math]::Min(($RGB / 2)+20,255)
                            $RGBText["bgreen"] = [math]::Min(($RGB / 2)+20,255)
                            $RGBText["bblue"] = 20
                    }
                } #Darkmode
                if ($NoWalls){
                    $RGBText["UnderLine"] = $false
                    $RGBText["Text"] = $eligibleplots
                } #NoWalls
                if ($harvesterActivity.ProofsFound){
                    $RGBText["bred"] = 0
                    $RGBText["bgreen"] = 0
                    $RGBText["bblue"] = 255
                } #if proofs found

                Write-RGBText @RGBText
            } #chia activity
        } #switch
    } #foreach
}
function Start-ChiaParallelPlotting {
    param(
        [ValidateRange(1,128)]
        [int]$ParallelCount = 1,

        [ValidateRange(0,[int]::MaxValue)]
        [Alias("Delay")]
        [int]$DelayInSeconds = 3600,

        [int]$PlotsPerQueue = 1,
        [ValidateRange(3390,[int]::MaxValue)]
        [int]$Buffer = 3390,
        [ValidateRange(1,128)]
        [int]$Threads = 2,

        [Parameter(Mandatory)]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$TempDirectoryPath,
        [Parameter(Mandatory)]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$FinalDirectoryPath,

        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$LogDirectoryPath = "$ENV:USERPROFILE\.chia\mainnet\plotter",

        [Parameter()]
        [string]$FarmerPublicKey,

        [Parameter()]
        [string]$PoolPublicKey,

        [Parameter()]
        [ValidateRange(1,[int]::MaxValue)]
        [int]$Buckets,

        [Parameter()]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$SecondTempDirectoryPath,

        [switch]$DisableBitfield,
        [switch]$ExcludeFinalDirectory,

        [switch]$NoExit,

        [ValidateNotNullOrEmpty()]
        [string]$WindowTitle
    )

    $AdditionalParameters = ""
    if ($PSBoundParameters.ContainsKey("WindowTitle")){
        $AdditionalParameters += " -WindowTitle $WindowTitle"
    }
    if ($PSBoundParameters.ContainsKey("FarmerPublicKey")){
        $AdditionalParameters += " -FarmerPublicKey $FarmerPublicKey"
    }
    if ($PSBoundParameters.ContainsKey("PoolPublicKey")){
        $AdditionalParameters += " -PoolPublicKey $PoolPublicKey"
    }
    if ($PSBoundParameters.ContainsKey("Buckets")){
        $AdditionalParameters += " -Buckets $Buckets"
    }
    if ($PSBoundParameters.ContainsKey("SecondTempDirectoryPath")){
        $AdditionalParameters += " -SecondTempDirectoryPath '$SecondTempDirectoryPath'"
    }
    if ($DisableBitfield){
        $AdditionalParameters += " -DisableBitfield"
    }
    if ($ExcludeFinalDirectory){
        $AdditionalParameters += " -ExcludeFinalDirectory"
    }

    for ($Queue = 1; $Queue -le $ParallelCount;$Queue++){
        if ($NoExit){
            $NoExitFlag = "-NoExit"
        }
        $ChiaArguments = "-TotalPlots $plotsperQueue -Buffer $Buffer -Threads $Threads -TempDirectoryPath '$TempDirectoryPath' -FinalDirectoryPath '$FinalDirectoryPath' -LogDirectoryPath '$LogDirectoryPath' -QueueName Queue_$Queue $AdditionalParameters"
        $processParam = @{
            FilePath = "powershell.exe"
            ArgumentList = "$NoExitFlag -Command Start-ChiaPlotting $ChiaArguments"
        }
        Start-Process @processParam
        if ($Queue -lt $ParallelCount){
            Start-Sleep -Seconds $DelayInSeconds
        }
    } #for
}
function Start-ChiaPlotting {
    [CmdletBinding()]
    param(
        [ValidateSet(25,32,33,34,35)]
        [int]$KSize = 32,
    
        [ValidateRange(1,5000)]
        [int]$TotalPlots = 1,
    
        [int]$Buffer,

        [ValidateRange(1,256)]
        [int]$Threads = 2,

        [switch]$DisableBitfield,
        [switch]$ExcludeFinalDirectory,
    
        [Parameter(Mandatory)]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$TempDirectoryPath,

        [Parameter()]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$SecondTempDirectoryPath,

        [Parameter(Mandatory)]
        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$FinalDirectoryPath,

        [Parameter()]
        [string]$FarmerPublicKey,

        [Parameter()]
        [string]$PoolPublicKey,

        [Parameter()]
        [ValidateRange(1,[int]::MaxValue)]
        [int]$Buckets,

        [ValidateScript({[System.IO.Directory]::Exists($_)})]
        [string]$LogDirectoryPath = "$ENV:USERPROFILE\.chia\mainnet\plotter",

        [switch]$NewWindow,

        [string]$QueueName = "Default_Queue",

        [string]$WindowTitle,

        [switch]$ValidatePlot
    )

    if (-not$PSBoundParameters.ContainsKey("Buffer")){
        switch ($KSize){
            32 {$Buffer = 3390}
            33 {$Buffer = 7400}
            34 {$Buffer = 14800}
            35 {$Buffer = 29600}
        }
        Write-Information "Buffer set to: $Buffer"
    }

    if ($PSBoundParameters.ContainsKey("WindowTitle")){
        $WindowTitle = $WindowTitle + " |"
    }

    $E = if ($DisableBitfield){"-e"}
    $X = if ($ExcludeFinalDirectory){"-x"}

    #remove any trailing '\' since chia.exe hates them
    $TempDirectoryPath = $TempDirectoryPath.TrimEnd('\')
    $FinalDirectoryPath = $FinalDirectoryPath.TrimEnd('\')

    #path to chia.exe
    $ChiaPath = (Get-Item -Path "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon\chia.exe").FullName
    $ChiaArguments = "plots create -k $KSize -b $Buffer -r $Threads -t `"$TempDirectoryPath`" -d `"$FinalDirectoryPath`" $E $X"

    if ($KSize -eq 25){
        $ChiaArguments += " --override-k"
    }


    if ($PSBoundParameters.ContainsKey("SecondTempDirectoryPath")){
        $SecondTempDirectoryPath = $SecondTempDirectoryPath.TrimEnd('\')
        $ChiaArguments += " -2 $SecondTempDirectoryPath"
        Write-Information "Added 2nd Temp Dir to Chia ArguementList"
    }
    if ($PSBoundParameters.ContainsKey("FarmerPublicKey")){
        $ChiaArguments += " -f $FarmerPublicKey"
    }
    if ($PSBoundParameters.ContainsKey("PoolPublicKey")){
        $ChiaArguments += " -p $PoolPublicKey"
    }

    if ($PSBoundParameters.ContainsKey("Buckets")){
        $ChiaArguments += " -u $Buckets"
    }

    if ($ChiaPath){
        Write-Information "Chia path exists, starting the plotting process"
        if (!$NewWindow){
            for ($plotNumber = 1;$plotNumber -le $TotalPlots;$plotNumber++){
                try{
                    $LogPath = Join-Path $LogDirectoryPath ((Get-Date -Format yyyy_MM_dd_hh-mm-ss-tt_) + "plotlog-" + $plotNumber + ".log")
                    $PlottingParam = @{
                        FilePath = $ChiaPath
                        ArgumentList = $ChiaArguments
                        RedirectStandardOutput = $LogPath
                        NoNewWindow = $true
                    }
                    $chiaProcess = Start-Process @PlottingParam -PassThru
                    $host.ui.RawUI.WindowTitle = "$WindowTitle $QueueName - Plot $plotNumber out of $TotalPlots | Chia Process Id - $($chiaProcess.id)"

                    #Have noticed that giving the process a second to start before checking the logs works better
                    Start-Sleep 1
                
                    while (!$chiaProcess.HasExited){
                        try{
                            $progress = Get-ChiaPlotProgress -LogPath $LogPath -ErrorAction Stop
                            $plotid = $progress.PlotId
                            #write-progress will fail if secondsremaining is less than 0...
                            $secondsRemaining = $progress.EST_TimeRemaining.TotalSeconds
                            if ($progress.EST_TimeRemaining.TotalSeconds -le 0){
                                $secondsRemaining = 0
                            }
                            Write-Progress -Activity "Queue $($QueueName): Plot $plotNumber out of $TotalPlots" -Status "$($progress.phase) - $($progress.Progress)%" -PercentComplete $progress.progress -SecondsRemaining $secondsRemaining
                            Start-Sleep 5
                        }
                        catch{
                            Write-Progress -Activity "Queue $($QueueName): Plot $plotNumber out of $TotalPlots" -Status "WARNING! PROGRESS UPDATES HAS FAILED! $($progress.phase) - $($progress.Progress)%" -PercentComplete $progress.progress -SecondsRemaining $secondsRemaining
                            Start-Sleep 30
                        }
                    } #while
                    if ($chiaProcess.ExitCode -ne 0){
                        Get-ChildItem -Path $TempDirectoryPath -Filter "*$plotid*.tmp" | Remove-Item -Force
                    }
                    if ($ValidatePlot){
                        Test-ChiaPlot -Filter $plotid
                    }
                }
                catch{
                    $PSCmdlet.WriteError($_)
                }
            } #for
        } #if noNewWindow
        else{
            $ChiaArguments += " -n $TotalPlots"
            $PlottingParam = @{
                FilePath = $ChiaPath
                ArgumentList = $ChiaArguments
                RedirectStandardOutput = $LogPath
            }
            $PlottingProcess = Start-Process @PlottingParam -PassThru
            [PSCustomObject]@{
                KSize = $KSize
                Buffer = $Buffer
                Threads = $Threads
                PID = $PlottingProcess.Id
                StartTime = $PlottingProcess.StartTime
                TempDir = $TempDirectoryPath
                FinalDir = $FinalDirectoryPath
                TempDir2 = $SecondTempDirectoryPath
                LogPath = $LogPath
                TotalPlotCount = $TotalPlots
                BitfieldEnabled = !$DisableBitfield.IsPresent
                ExcludeFinalDir = $ExcludeFinalDirectory.IsPresent
            }
            Write-Information "Plotting started, PID = $PID"
        } # else
    } #if chia path exits
}
function Test-ChiaPlot {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipelineByPropertyName,ValueFromPipeline)]
        [Alias("FilePath","FullName","Filter")]
        [ValidateNotNullOrEmpty()]
        [string[]]$Path,
        [ALias("n")]
        [int]$Challenges = 30
    )

    Begin{
        $ChiaPath = (Get-Item -Path "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon").FullName
        if ($ENV:Path.Split(";") -notcontains $ChiaPath){
            $ENV:Path += ";$ChiaPath"
        }
        $Proofs = "Proofs ([0-9]*) / ([0-9]*), ([0-9.]*)"
        $Testing = "Testing plot"
        $ErrorString = "ERROR"
    }

    Process{
        foreach ($plotpath in $Path){
            chia.exe plots check -n $Challenges -g $plotpath 2>&1 | Select-String -SimpleMatch "Proofs","Error","Testing" | foreach {
                switch -Regex ($_){
                    $Proofs {
                        $PlotObject.ProofsFound = $Matches[1] -as [int]
                        $PlotObject.Ratio = $Matches[3] -as [double]
                        $PlotObject
                        break
                    }
                    $Testing {
                        $PlotPath = ($_ -split "Testing plot ")[1].split(' ')[0]
                        $Leaf = Split-Path -Path $PlotPath -Leaf
                        $KSize = $Leaf -split "plot-k" -split "-" | Select-Object -First 1 -Skip 1
                        $PlotId = ($Leaf -split "-" | select -Last 1).Split(".")[0]
                        $PlotObject = [PSCustomObject]@{
                            PSTypeName = "PSChiaPlotter.PlotTest"
                            Path = $PlotPath
                            ProofsFound = 0
                            Challenges = $Challenges
                            Ratio = 0.0
                            KSize = $KSize
                            PlotId = $PlotId
                            Errors = New-Object System.Collections.Generic.List[string]
                        }
                        break
                    }
                    $ErrorString {
                        $PlotObject.Errors.Add($_.ToString())
                        break
                    }
                } #switch
            } #foreach line
        } #foreach
    } #process
}
function Test-ChiaPlotParallel {
    [CmdletBinding()]
    param(
        [Parameter()]
        [Alias("FilePath","FullName")]
        [ValidateNotNullOrEmpty()]
        [string[]]$Path,
        [ValidateRange(1,256)]
        [int]$Threads =  1,
        [ALias("n")]
        [int]$Challenges = 30
    )

    Begin{
        $ChiaPath = (Get-Item -Path "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon").FullName
        if ($ENV:Path.Split(";") -notcontains $ChiaPath){
            $ENV:Path += ";$ChiaPath"
        }
        $SessionState = [System.Management.Automation.Runspaces.InitialSessionState]::CreateDefault()
        $RunspacePool = [runspacefactory]::CreateRunspacePool(1,$Threads,$SessionState,$Host)
        $RunspacePool.ApartmentState = "STA"
        $RunspacePool.ThreadOptions = "ReuseThread"
        $RunspacePool.Open()
        $Jobs = New-Object System.Collections.Generic.List[Object]
        $TotalPlots = $Path.Count
    } #Begin

    Process{
        foreach ($plotpath in $Path){
            Write-Information "Adding runspace for $plot"
            $Parameters = @{
                PlotPath = $plotpath
                Challenges = $Challenges
                ChiaPath = $ChiaPath
            }
            $CheckPlotScript = [powershell]::Create().AddScript({
                Param (
                    $PlotPath,
                    $Challenges,
                    $ChiaPath
                )
                $Leaf = Split-Path -Path $PlotPath -Leaf
                $KSize = $Leaf -split "plot-k" -split "-" | Select-Object -First 1 -Skip 1
                $PlotId = ($Leaf -split "-" | select -Last 1).Split(".")[0]
                $PlotObject = [PSCustomObject]@{
                    PSTypeName = "PSChiaPlotter.PlotTest"
                    Path = $PlotPath
                    PlotsFound = 0
                    ProofsFound = 0
                    Challenges = $Challenges
                    Ratio = 0.0
                    PlotSize = 0.0
                    LoadTime = 0.0
                    KSize = $KSize
                    PlotId = $PlotId
                    Errors = New-Object System.Collections.Generic.List[string]
                }
                
                $Proofs = "Proofs ([0-9]*) / ([0-9]*), ([0-9.]*)"
                $ValidPlot = "Found 1 valid plots"
                $InvalidPlot = "1 invalid plots found"
                $LoadedPlot = "Loaded a total of ([0-9]) plots of size ([0-9.]*) TiB, in ([0-9.]*) seconds"
                $ErrorString = "ERROR"

                if (Test-Path -Path $PlotPath -PathType Leaf){
                    $Results = chia.exe plots check -n $Challenges -g $PlotPath 2>&1 | Select-String -SimpleMatch "Proofs","Error","Found","Loaded"
                    foreach ($line in $Results){
                        switch -Regex ($line){
                            $Proofs {
                                $PlotObject.ProofsFound = $Matches[1] -as [int]
                                $PlotObject.Ratio = $Matches[3] -as [double]
                                break;
                            }
                            $ValidPlot {
                                $PlotObject.Valid = $true
                            }
                            $InvalidPlot {
                                $PlotObject.Valid = $false
                            }
                            $LoadedPlot {
                                $PlotObject.PlotsFound = $Matches[1] -as [int]
                                $PlotObject.PlotSize = $Matches[2] -as [double]
                                $PlotObject.LoadTime = $Matches[3] -as [double]
                            }
                            $ErrorString {
                                $PlotObject.Errors.Add($line.ToString())
                            }
                        }
                    }
                    $PlotObject
                }
            }).AddParameters($Parameters)
            $CheckPlotScript.RunspacePool = $RunspacePool
            $Handle = $CheckPlotScript.BeginInvoke()
            $temp = [PSCustomObject]@{
                PowerShell = $CheckPlotScript
                Handle = $Handle
            }
            [void]$jobs.Add($temp)
        } #foreach
    
        while ($jobs.handle.IsCompleted -contains $false){
            Write-Information "Returning objects and closing runspaces"
            $RemoveJobs = New-Object System.Collections.Generic.List[Object]
            $jobs | where {$_.handle.IsCompleted -eq $true} | foreach {
                $_.powershell.EndInvoke($_.handle)
                $_.PowerShell.Dispose()
                [void]$RemoveJobs.Add($_)
            }
            if ($RemoveJobs){
                foreach ($job in $RemoveJobs){
                    [void]$Jobs.Remove($job)
                }
            }
            $PercentComplete = [math]::Round(($TotalPlots - ($jobs | Measure-Object).Count) / $TotalPlots * 100,2)
            $ProgessParameters = @{
                Activity = "Running chia check on $TotalPlots plots"
                Status = "$($TotalPlots - ($jobs | Measure-Object).Count) / $TotalPlots Completed | $PercentComplete%" 
                PercentComplete = $PercentComplete
            }
            Write-Progress @ProgessParameters
        } #while
    } #process
    end{
        Write-Information "Closing Runspace Pool"
        $RunspacePool.close()
        $RunspacePool.Dispose()
    } #end
}
function Get-BestChiaFinalDrive {
    [CmdletBinding()]
    param(
        $ChiaVolumes,
        $ChiaJob,
        $ChiaQueue
    )
    $finalplotsize = $ChiaQueue.PlottingParameters.KSize.FinalSize

    $AllVolumes = Get-ChiaVolume
    foreach ($finalvol in $ChiaVolumes){
        $newVolumeInfo = $AllVolumes | where UniqueId -eq $finalvol.UniqueId
        $finalvol.FreeSpace = $newVolumeInfo.FreeSpace
        $MasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $finalvol.UniqueId
        $finalvol.PendingFinalRuns = $MasterVolume.PendingFinalRuns
    }
    if ($ChiaQueue.PlottingParameters.ReplotEnabled){
        foreach ($replotVolume in $ChiaVolumes){
            foreach ($oldDirectory in $replotVolume.OldPlotDirectories){
                try{
                    $oldplotcount = (Get-ChildItem -Path $oldDirectory.Path -Filter "plot-k$($oldDirectory.KSizeValue)*.plot" -File | Measure-Object).Count
                    $oldDirectory.PlotCount = $oldplotcount
                }
                catch{
                    $oldDirectory.PlotCount = 0
                    Write-PSChiaPlotterLog -LogType "ERROR" -ErrorObject $_
                }
            }
            $replotVolume.TotalReplotCount = ($replotVolume.OldPlotDirectories | Measure-Object -Property PlotCount -Sum).Sum
        }
        $AvailableVolumes = $ChiaVolumes | where TotalReplotCount -gt 0 | sort -Property @{Expression = {$_.PendingFinalRuns.Count}; Descending = $false},@{Expression = "TotalReplotCount"; Descending = $True}
        return ($AvailableVolumes | Select-Object -First 1)
    }
    else{
        $sortedVolumes = $ChiaVolumes | Sort-Object -Property @{Expression = {$_.PendingFinalRuns.Count}; Descending = $false},@{Expression = "FreeSpace"; Descending = $True}
        foreach ($volume in $sortedVolumes){
            if ((($volume.FreeSpace - ($Volume.PendingFinalRuns.Count * $finalplotsize)) -gt $finalplotsize) -or ($ChiaJob.DisableFreeSpaceCheck -eq $true)){
                    return $volume
            }
        }
    }
}
function Get-BestChiaTempDrive {
    [CmdletBinding()]
    param(
        $ChiaVolumes,
        $ChiaJob,
        $ChiaQueue
    )

    $requiredTempSize = $ChiaQueue.PlottingParameters.KSize.TempSize
    $finalplotsize = $ChiaQueue.PlottingParameters.KSize.FinalSize

    $AllVolumes = Get-ChiaVolume
    foreach ($tempvol in $ChiaVolumes){
        $newVolumeInfo = $AllVolumes | where UniqueId -eq $tempvol.UniqueId
        $tempvol.FreeSpace = $newVolumeInfo.FreeSpace
        $MasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $tempvol.UniqueId
        $tempvol.CurrentChiaRuns = $MasterVolume.CurrentChiaRuns
        $tempvol.PendingFinalRuns = $MasterVolume.PendingFinalRuns
    }
    $sortedVolumes = $ChiaVolumes | Sort-Object -Property @{Expression = {$_.CurrentChiaRuns.Count}; Descending = $false},@{Expression = "FreeSpace"; Descending = $True}
    foreach ($volume in $sortedVolumes){
        if ($ChiaJob.ChiaParameters.AlternativePlotterEnabled -eq $true){
            return $volume
        }
        elseif (($Volume.CurrentChiaRuns.Count -lt $volume.MaxConCurrentTempChiaRuns) -or ($ChiaJob.IgnoreMaxParallel)){
            if (($volume.FreeSpace - ($Volume.PendingFinalRuns.Count * $finalplotsize)) -gt $requiredTempSize -or ($ChiaJob.DisableFreeSpaceCheck -eq $true)){
                return $volume
            }
        }
    } #foreach
}
function Get-ChiaTempSize{
    [CmdletBinding()]
    param(
        $DirectoryPath,
        $PlotId
    )
    try{
        if ($PlotId -ne $null){
            try{
                #this will actually get the size on disk
                $tepmSize = (Get-ChildItem -Path $DirectoryPath -Filter "*$plotid*.tmp" | foreach {[Disk.Size]::SizeOnDisk($_.FullName)} | measure -Sum).Sum
                return [math]::Round($tepmSize / 1gb)
            }
            catch{
                $tepmSize = (Get-ChildItem -Path $DirectoryPath -Filter "*$plotid*.tmp" | Measure-Object -Property Length -Sum).Sum
                return [math]::Round($tepmSize / 1gb)
            }
        }
        else{
            return 0
        }
    }
    catch{
        return 0
    }
}
function Get-ChiaVolume {
    [CmdletBinding()]
    param()

    #grabbing all volumes, partitions, disks, and physicaldisks at once since it has proven to be faster
    $AllVolumes = Get-Volume
    #filter out all paritions not are not accessible to the file system
    $AllPartitions = Get-Partition | Where {$_.AccessPaths.Count -gt 1}
    $AllDisks = Get-Disk
    $AllphysicalDisk = Get-PhysicalDisk

    foreach ($volume in $AllVolumes){
        try{
            $partition = $AllPartitions | where AccessPaths -Contains "$($volume.UniqueId)"
            $disk = $AllDisks | where DiskNumber -eq $partition.DiskNumber
            $physicalDisk = $AllphysicalDisk | where DeviceId -eq $disk.DiskNumber
            if ($physicalDisk -ne $null){
                $MediaType = $physicalDisk.MediaType
            }
            else{
                $MediaType = "Unknown"
            }

            $Label = $volume.FileSystemLabel
            if ([string]::IsNullOrEmpty($volume.FileSystemLabel)){
                $Label = "N/A"
            }
            $DriveLetter = $volume.DriveLetter
            if (-not[char]::IsLetter($DriveLetter)){
                $DriveLetter = '?'
            }
            if ($partition){
                $DirectoryPaths = $partition.AccessPaths | where {$_ -ne $volume.UniqueId}
                $ChiaVolume = [PSChiaPlotter.ChiaVolume]::new($volume.UniqueId,$Label,$volume.Size,$volume.SizeRemaining)
                $ChiaVolume.BusType = $physicalDisk.BusType
                $ChiaVolume.MediaType = $MediaType
                $MaxTempCount = [math]::Floor([decimal]($volume.size / (239 * 1gb)))
                $ChiaVolume.MaxConCurrentTempChiaRuns = $MaxTempCount
                $ChiaVolume.DriveLetter = $DriveLetter
                $ChiaVolume.DirectoryPath = $DirectoryPaths | select -First 1
                $DirectoryPaths | foreach {$ChiaVolume.AccessPaths.Add($_)}
                $ChiaVolume
                Clear-Variable PhysicalDisk,Disk,Partition,MaxTempCount -ErrorAction SilentlyContinue
                $Log = @{
                    LogType = "INFO"
                    Message = "Chia Volume Found: Letter $($ChiaVolume.DriveLetter), UniqueId: $($ChiaVolume.UniqueID)"
                }
                Write-PSChiaPlotterLog @Log
            }
        }
        catch{
            Write-PSChiaPlotterLog -LogType "Warning" -Message "Unable to create a ChiaVolume from driveletter $($DriveLetter.DriveLetter)"
            Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        }
    } #volume

    $mappedDrives = Get-CimInstance -ClassName Win32_MappedLogicalDisk
    $BusType = "Network"
    $MediaType = "Unknown"
    foreach ($drive in $mappedDrives){
        try{
            if ([string]::IsNullOrEmpty($drive.ProviderName)){
                $Label = "N/A"
            }
            else{
                $Label = $drive.ProviderName
            }
            if (-not[string]::IsNullOrEmpty($drive.DeviceID)){
                $DriveLetter = $drive.DeviceID.TrimEnd(':')
                $ChiaVolume = [PSChiaPlotter.ChiaVolume]::new($drive.VolumeSerialNumber,$Label,$drive.Size,$drive.FreeSpace)
                $ChiaVolume.BusType = $BusType
                $ChiaVolume.MediaType = $MediaType
                $MaxTempCount = [math]::Floor([decimal]($drive.size / (239 * 1gb)))
                $ChiaVolume.MaxConCurrentTempChiaRuns = $MaxTempCount
                $ChiaVolume.DriveLetter = $DriveLetter
                $DirectoryPath = $DriveLetter + ':\'
                $ChiaVolume.DirectoryPath = $DirectoryPath
                $ChiaVolume.AccessPaths.Add($DirectoryPath)
                if (Test-Path $label){
                    $ChiaVolume.AccessPaths.Add($Label)
                }
                $ChiaVolume
                Clear-Variable DriveLetter -ErrorAction SilentlyContinue
                $Log = @{
                    LogType = "INFO"
                    Message = "Chia Volume Found: Letter $($ChiaVolume.DriveLetter), UniquieId: $($ChiaVolume.UniqueID)"
                }
                Write-PSChiaPlotterLog @Log
            }
        }
        catch{
            Write-PSChiaPlotterLog -LogType "Warning" -Message "Unable to create a ChiaVolume from driveletter $($DriveLetter.DriveLetter)"
            Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        }
    }
}
function Get-MaxKSize {
    [CmdletBinding()]
    param(
        [ValidateSet("K32","K33","K34","K35")]
        [string[]]$KSize = ("K32","K33","K34","K35"),

        [Parameter(Mandatory)]
        [int64]$TotalBytes
    )

    foreach ($size in $KSize){
        [MaximizedKSize]::new($size,$TotalBytes)
    } #foreach
}
function Get-OptimizedKSizePlotNumbers {
    [CmdletBinding()]
    param(
        [MaximizedKSize[]]$MaximizedKSize
    )

    foreach ($size in $MaximizedKSize){
        switch ($size.KSize){
            "K32" {
                [OptimizedKPlots]::new(0,0,0,$Size.TotalBytes)
            }

            "K33" {
                for ($K33Count = 1; $K33Count -le $size.MaxPlots; $K33Count++){
                    [OptimizedKPlots]::new(0,0,$K33Count,$Size.TotalBytes)
                } #for
            }
            "K34" {
                for ($K34Count = 1; $K34Count -le $size.maxplots; $K34Count++){
                    [OptimizedKPlots]::new(0,$K34Count,0,$Size.TotalBytes)

                    $k34sizeremaining = $Size.TotalBytes - ($K34Count * $size.KSizeBytes)
                    $K33Max = Get-MaxKSize -TotalBytes $k34sizeremaining -KSize "K33"
                    for ($k33 = 1; $k33 -le $k33max.MaxPlots; $k33++){
                        [OptimizedKPlots]::new(0,$K34Count,$k33,$Size.TotalBytes)
                    } #for 33
                } #for 34
            } #34

            "K35" {
                for ($k35count = 1; $k35count -le $size.maxplots; $k35count++){

                    [OptimizedKPlots]::new($k35count,0,0,$Size.TotalBytes)

                    $k35sizeremaining = $Size.TotalBytes - ($k35count * $size.KSizeBytes)
                    $k33max = Get-MaxKSize -Totalbytes $k35sizeremaining -KSize "K33"

                    for ($k33 = 1; $k33 -le $k33max.MaxPlots; $k33++){
                        [OptimizedKPlots]::new($k35count,0,$k33,$Size.TotalBytes)
                    } #for 33

                    $k34max = Get-MaxKSize -Totalbytes $k35sizeremaining -KSize "K34"
                    for ($k34 = 1; $k34 -le $k34max.maxplots; $k34++){
                        [OptimizedKPlots]::new($k35count,$k34,0,$Size.TotalBytes)

                        $sizeremaining = $Size.TotalBytes - (($k35count * $size.KSizeBytes) + ($k34 * $k34max.KSizeBytes))
                        $K33max = Get-MaxKSize -TotalBytes $sizeremaining -KSize "K33"

                        for ($k33 = 1;$k33 -le $k33max.maxplots; $k33++){
                            [OptimizedKPlots]::new($k35count,$k34,$k33,$Size.TotalBytes)
                        }
                    }
                }
            }
        } #switch
    } #foreach
}
function Import-Xaml {
    param(
        $PathToXAML
    )
    Add-Type -AssemblyName PresentationFramework
    Add-Type -AssemblyName System.Windows.Forms
    [xml]$xaml = Get-Content -Path $PathToXAML
    $manager = [System.Xml.XmlNamespaceManager]::new($xaml.NameTable)
    $manager.AddNamespace("x","http://schemas.microsoft.com/winfx/2006/xaml")
    $xamlReader = [System.Xml.XmlNodeReader]::new($xaml)
    [Windows.Markup.XamlReader]::Load($xamlReader)
}
function New-ChiaJobRunspace{
    param(
        [Parameter(Mandatory)]
        $Job
    )
    [powershell]::Create().AddScript{
        Param (
            $Job
        )
        $ErrorActionPreference = "Stop"
        Add-Type -AssemblyName PresentationFramework
        Add-Type -AssemblyName System.Windows.Forms

        #Import required assemblies and private functions
        Get-childItem -Path $DataHash.PrivateFunctions -File -Recurse | ForEach-Object {Import-Module $_.FullName}
        Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}

        for ($queue = 1; $queue -le $Job.QueueCount; $queue++){
            try{
                $newQueue = [PSChiaPlotter.ChiaQueue]::new($queue,$job.InitialChiaParameters,$job)
                $newQueue.Status = "Waiting"
                $DataHash.MainViewModel.AllQueues.Add($newQueue)
                $Job.Queues.Add($newQueue)
            }
            catch{
                Write-PSChiaPlotterLog -LogType "ERROR" -ErrorObject $_
                Show-Messagebox -Text $_.Exception.Message -Title "Job $($Job.JobNumber) - Runspace"
            }
        }

        try{
            for ($queue = 0;$queue -lt $Job.QueueCount;$queue++){
                if ($queue -eq 0){
                    sleep -Seconds ($Job.FirstDelay * 60)
                    $Job.Queues[$queue].IsBlocked = $false
                    $Job.Status = "Running"
                }

                $QueueRunspace = New-ChiaQueueRunspace -Queue $Job.Queues[$queue] -Job $Job
                $QueueRunspace.Runspacepool = $ScriptsHash.Runspacepool
                [void]$QueueRunspace.BeginInvoke()
                $DataHash.Runspaces.Add($QueueRunspace)
                if (($queue + 1) -ne $Job.QueueCount){
                    #plus 10 seconds for a min delay for data syncing insurance
                    Start-Sleep -Seconds ($Job.DelayInMinutes * 60 + 5)
                }
            }
        }
        catch{
            Write-PSChiaPlotterLog -LogType "ERROR" -ErrorObject $_
            Show-Messagebox -Text $_.Exception.Message -Title "Job $($Job.JobNumber) - Runspace" | Out-Null
        }
    }.AddParameters($PSBoundParameters)
}
function New-ChiaQueueRunspace {
    param(
        [Parameter(Mandatory)]
        $Queue,
        $Job
    )
    [powershell]::Create().AddScript{
        Param (
            $Job,
            $Queue
        )
        $ErrorActionPreference = "Stop"
        Add-Type -AssemblyName PresentationFramework
        Add-Type -AssemblyName System.Windows.Forms

        #Import required assemblies and private functions
        Get-childItem -Path $DataHash.PrivateFunctions -File -Recurse | ForEach-Object {Import-Module $_.FullName}
        Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}
        try{
            for ($runNumber = 1;Test-PlotCount $Job;$runNumber++){
                $ChiaProcess = $Null

                while ($Queue.IsBlocked -or $Queue.Pause){
                    if ($Queue.Quit){
                        break
                    }
                    if (Test-PlotCount $Job -BreakLoop){
                        break
                    }
                    if ($Queue.Pause){
                        $Queue.Status = "Paused"
                    }
                    else{
                        $Queue.Status = "Waiting"
                    }
                    Start-Sleep -Seconds 10
                }
                $Job.QueueLooping = $true;
                $Queue.IsBlocked = $false

                if ($Job.BasicPlotting){
                    $TempVolume = $Queue.PlottingParameters.BasicTempDirectory
                    $FinalVolume = $Queue.PlottingParameters.BasicFinalDirectory
                    if ($Queue.PlottingParameters.EnableBasicSecondTempDirectory){
                        $SecondTempVolume = [PSChiaPlotter.ChiaVolume]::new($Queue.PlottingParameters.BasicSecondTempDirectory)
                    }
                    $PhaseOneIsOpen = Test-PhaseOneIsOpen -ChiaJob $Job
                    while ($PhaseOneIsOpen -eq $false){
                        $Queue.Status = "Waiting - Phase 1 Limit"
                        if (Test-PlotCount $Job -BreakLoop){
                            break
                        }
                        if ($Queue.Quit){
                            break
                        }
                        Start-Sleep -Seconds 15
                        $PhaseOneIsOpen = Test-PhaseOneIsOpen -ChiaJob $Job
                    }
                }
                else{
                    #grab a volume that has enough space
                    Do {
                        Try{
                            if ($Queue.Quit){
                                break
                            }
                            if (Test-PlotCount $Job -BreakLoop){
                                break
                            }
                            Start-Sleep -Seconds 6
                            $PhaseOneIsOpen = Test-PhaseOneIsOpen -ChiaJob $Job
                            if (-not$PhaseOneIsOpen){
                                $Queue.Status = "Waiting - Phase 1 Limit"
                                Start-Sleep -Seconds 17
                                #do not need to check the drives if phase 1 is not open for another plot
                                continue
                            }

                            $TempVolume = Get-BestChiaTempDrive -ChiaVolumes $Job.TempVolumes -ChiaJob $Job -ChiaQueue $Queue
                            $FinalVolume = Get-BestChiaFinalDrive $Job.FinalVolumes -ChiaJob $Job -ChiaQueue $Queue
                            if ($TempVolume -eq $Null){
                                $Queue.Status = "Waiting on Temp Space"
                                Start-Sleep -Seconds 60
                            }
                            if ($FinalVolume -eq $Null){
                                $Queue.Status = "Waiting on Final Dir Space"
                                Start-Sleep -Seconds 60
                            }
                        }
                        catch{
                            $Queue.Status = "Failed To Grab Volume Info"
                            Write-Error -LogType "Error" -ErrorObject $_
                            Start-Sleep -Seconds 30
                        }
                    }
                    while ($TempVolume -eq $null -or $FinalVolume -eq $null -or $PhaseOneIsOpen -eq $false)
                } #else

                $Job.QueueLooping = $false
                $BlockedQueue = $Job.Queues | where {$_.IsBlocked -and !$_.Pause} | sort QueueNumber | select -First 1
                if ($BlockedQueue -ne $Null){
                    $BlockedQueue.IsBlocked = $false
                    $BlockedQueue = $null
                }
                if (Test-PlotCount $Job -BreakLoop){
                    break
                }
                if ($Queue.Quit){
                    break
                }

                $Queue.Status = "Running"
                $plottingParameters = [PSChiaPlotter.ChiaParameters]::New($Queue.PlottingParameters)
                $plottingParameters.TempVolume = $TempVolume
                $plottingParameters.FinalVolume = $FinalVolume
                if ($Job.BasicPlotting -and $Queue.PlottingParameters.EnableBasicSecondTempDirectory){
                    $plottingParameters.SecondTempVolume = $SecondTempVolume
                }
                $newRun = [PSChiaPlotter.ChiaRun]::new($Queue,$runNumber,$plottingParameters)
                if ($DataHash.Debug){
                    Start-GUIDebugRun -ChiaRun $newRun -ChiaQueue $Queue -ChiaJob $Job
                }
                else{
                    Start-GUIChiaPlotting -ChiaRun $newRun -ChiaQueue $Queue -ChiaJob $Job
                }

                $QueuesBlocked = ($Job.Queues | where {$_.IsBlocked -and !$_.pause} | Measure-Object).Count
                if ($QueuesBlocked -eq 0 -and $Job.QueueLooping -eq $false -and !$Queue.Pause){
                    $Queue.IsBlocked = $false
                }
                else{
                    $Queue.IsBlocked = $true
                }
                #sleep to give some time for updating
                sleep 2
            } #for
            $Queue.IsBlocked = $false

            $Queue.Status = "Finished"
            if ($Job.PlotInfinite -eq $true){
                $QueueFinishedCount = ($Job.Queues | where Status -ne "Finished" | Measure-Object).Count
                if ($QueueFinishedCount -eq 0){
                    $Job.Status = "Completed"
                }
            }
        }
        catch{
            Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
            Show-Messagebox -Text $_.Exception.Message -Title "Queue - $($Queue.QueueNumber)" | Out-Null
            if ($ChiaProcess){
                Show-Messagebox -Text "The Following Chia Process may be running and might need to killed - PID $($ChiaProcess.Id)" -Title "Queue" | Out-Null
            }
            $Queue.Status = "Failed"
        }
    }.AddParameters($PSBoundParameters)
}
function New-UIRunspace{
    [powershell]::Create().AddScript{
        $ErrorActionPreference = "Stop"
        Add-Type -AssemblyName PresentationFramework
        Add-Type -AssemblyName System.Windows.Forms
        #[System.Windows.Forms.MessageBox]::Show("Hello")
        #Import required assemblies and private functions
        
        Try{
            Get-childItem -Path $DataHash.PrivateFunctions -File -Recurse | ForEach-Object {Import-Module $_.FullName}
            Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}

            Import-Module -Name PSChiaPLotter
    
            $XAMLPath = Join-Path -Path $DataHash.WPF -ChildPath MainWindow.xaml
            $MainWindow = Import-Xaml -Path $XAMLPath

            #Assign GUI Controls To Variables
            $UIHash.MainWindow = $MainWindow

            #DataGrid
            $UIHash.Jobs_DataGrid = $MainWindow.FindName("Jobs_DataGrid")
            $UIHash.Queues_DataGrid = $MainWindow.FindName("Queues_DataGrid")
            $UIHash.Runs_DataGrid = $MainWindow.FindName("Runs_DataGrid")
            $UIHash.CompletedRuns_DataGrid = $MainWindow.FindName("CompletedRuns_DataGrid")

            #Buttons
            $UIHash.NewJob_Button = $MainWindow.FindName("AddJob_Button")
            $UIHash.QuitJob_Button = $MainWindow.FindName("QuitJob_Button")
            $UIHash.PauseAllQueues_Button = $MainWindow.FindName("PauseAllQueues_Button")
            $UIHash.OpenLog_Button = $MainWindow.FindName("OpenLogButton")
            $UIHash.Refreshdrives_Button = $MainWindow.FindName("RefreshdrivesButton")
            $UIHash.CheckForUpdate_Button = $MainWindow.FindName("CheckForUpateButton")
            $UIHash.PauseQueue_Button = $MainWindow.FindName("PauseQueue_Button")
            $UIHash.QuitQueue_Button = $MainWindow.FindName("QuitQueue_Button")
            $UIHash.AddPlotLogPath_Button = $MainWindow.FindName("AddPlotLogPath_Button")
            $UIHash.RemovePlotLogPath_Button = $MainWindow.FindName("RemovePlotLogPath_Button")
            $DataHash.RefreshingDrives = $false

            $DataHash.MainViewModel = [PSChiaPlotter.MainViewModel]::new()
            $DataHash.MainViewModel.Version = (Get-Module -Name PSChiaPlotter).Version.ToString()
            $DataHash.MainViewModel.LogPath = $DataHash.LogPath
            $DataHash.MainViewModel.LogLevel = "Error"

            $UIHash.MainWindow.DataContext = $DataHash.MainViewModel

            #TextBox
            $UIHash.AddPlotLog_TextBox = $MainWindow.FindName("AddPlotLog_TextBox")
            $UIHash.AddPlotLog_TextBox.Text = "$ENV:USERPROFILE\.chia\mainnet\plotter"

            #Listbox
            $UIHash.PlotLog_ListBox = $MainWindow.FindName("PlotLog_ListBox")

            #Add Master Copy of volumes to MainViewModel these are used to keep track of
            # all jobs that are running on the drives
            Get-ChiaVolume | ForEach-Object {
                $DataHash.MainViewModel.AllVolumes.Add($_)
            }

            #ButtonClick
            $UIHash.NewJob_Button.add_Click({
                try{
                    Invoke-NewJobButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.QuitJob_Button.Add_Click({
                try{
                    Invoke-QuitJobButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.QuitQueue_Button.Add_Click({
                try{
                    Invoke-QuitQueueButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.PauseQueue_Button.Add_Click({
                try{
                    Invoke-PauseQueueButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.PauseAllQueues_Button.Add_Click({
                try{
                    Invoke-PauseAllQueuesButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.Refreshdrives_Button.Add_Click({
                try{
                    if ($DataHash.RefreshingDrives){
                        Show-Messagebox -Text "A drive refresh is currently in progress" -Icon Information
                        return
                    }
                    $DataHash.RefreshingDrives = $true
                    Update-ChiaVolume -ErrorAction Stop
                    $DataHash.RefreshingDrives = $false
                }
                catch{
                    $DataHash.RefreshingDrives = $false
                    Show-Messagebox -Text $_.Exception.Message -Title "Refresh Drives" -Icon Error
                }
            })

            $UIHash.CheckForUpdate_Button.Add_Click({
                try{
                    Update-PSChiaPlotter
                }
                catch{
                    Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                    Show-Messagebox "Unable to check for updates... check logs for more info" | Out-Null
                }
            })

            $UIHash.OpenLog_Button.Add_Click({
                try{
                    Invoke-Item -Path $DataHash.MainViewModel.LogPath -ErrorAction Stop
                }
                catch{
                    Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                    Show-Messagebox "Unable to open log file, check the path '$($DataHash.MainViewModel.LogPath)'" | Out-Null
                }
            })

            $UIHash.AddPlotLogPath_Button.Add_Click({
                try{
                    Invoke-AddPlotLogDirectoryPathButtonClick -PlotLogDirPath $UIHash.AddPlotLog_TextBox.Text
                }
                catch{
                    Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                    Show-Messagebox "Unable to add log directory path!" -Icon Error | Out-Null
                }
            })

            $UIHash.RemovePlotLogPath_Button.Add_Click({
                try{
                    Invoke-RemovePlotLogDirectoryButtonClick
                }
                catch{
                    Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                    [void](Show-Messagebox "Unable to remove log directory path!" -Icon Error)
                }
            })

            #Datagrid Selection Change
            $UIHash.Queues_DataGrid.Add_SelectionChanged({
                try{
                    Invoke-QueueSelectionChange
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            })

            $UIHash.MainWindow.add_Closing({
                Get-childItem -Path $DataHash.PrivateFunctions -File | ForEach-Object {Import-Module $_.FullName}
                # end session and close runspace on window exit
                $DialogResult = Show-Messagebox -Text "Do you want to end all chia plotting processes?`n`nNote - PSChiaPlotter will NOT re-load these processes upon startup!" -Title "Warning!" -Icon Warning -Buttons YesNoCancel
                if ($DialogResult -eq [System.Windows.MessageBoxResult]::Cancel) {
                    $PSItem.Cancel = $true
                }
                elseif ($DialogResult -eq [System.Windows.MessageBoxResult]::Yes){
                    Stop-PSChiaPlotter -EndChiaProcess
                }
                else{
                    Stop-PSChiaPlotter
                }
            })

            $MainWindow.ShowDialog()


        }
        catch{
            $Message = "$($_.Exception.Message)"
            $Message += "`nLine # -$($_.InvocationInfo.ScriptLineNumber )"
            $Message += "`nLine - $($_.InvocationInfo.Line)"
            Show-Messagebox -Text $Message -Title "UI Runspace Error" -Icon Error
        }
    }
}
function Show-Messagebox {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Text,
        [string]$Title = "Message Box",
        [System.Windows.MessageBoxButton]$Buttons =[System.Windows.MessageBoxButton]::OK,
        [System.Windows.MessageBoxImage]$Icon = [System.Windows.MessageBoxImage]::None
    )

    [System.Windows.MessageBox]::Show($Text,$Title,$Buttons,$Icon)
}
function Start-GUIChiaPlotting {
    [CmdletBinding()]
    param(
        $ChiaRun,
        $ChiaQueue,
        $ChiaJob
    )

    try{
        #not really needed, but just wanted to make each parameter its own variable
        $PlottingParameters = $ChiaRun.PlottingParameters
        $KSize = $PlottingParameters.KSize.KSizeValue
        $Buffer = $PlottingParameters.RAM
        $Threads = $PlottingParameters.Threads
        $DisableBitfield = $PlottingParameters.DisableBitField
        $ExcludeFinalDirectory = $PlottingParameters.ExcludeFinalDirectory
        $TempDirectoryPath = $PlottingParameters.TempVolume.DirectoryPath
        $FinalDirectoryPath = $PlottingParameters.FinalVolume.DirectoryPath
        $LogDirectoryPath = $PlottingParameters.LogDirectory
        $SecondTempDirectoryPath = $PlottingParameters.SecondTempVolume.DirectoryPath
        $PoolPublicKey = $PlottingParameters.PoolPublicKey
        $FarmerPublicKey = $PlottingParameters.FarmerPublicKey
        $Buckets = $PlottingParameters.Buckets
        $PoolContractEnabled = $PlottingParameters.PoolContractEnabled
        $PoolContractAddress = $PlottingParameters.PoolContractAddress
        $ReplotEnabled = $PlottingParameters.ReplotEnabled
        $AlternativePlotterEnabled = $PlottingParameters.AlternativePlotterEnabled
        $AlternativePlotterPath = $PlottingParameters.AlternativePlotterPath
        $Phase3and4Buckets = $PlottingParameters.PhaseThreeFourBuckets
        $Phase3and4BucketsEnabled = $PlottingParameters.Phase3and4BucketsEnabled
        $PlotWhileCopy = $PlottingParameters.PlotWhileCopy
        
        #used for replotting
        $OldPlotDeleted = $false

        $E = if ($DisableBitfield){"-e"}
        $X = if ($ExcludeFinalDirectory){"-x"}

        if ($PlotWhileCopy -eq $true){
            if ($AlternativePlotterEnabled -eq $true){
                $FinalDirectoryPath = $TempDirectoryPath
            }
            else{
                if (-not[string]::IsNullOrWhiteSpace($SecondTempDirectoryPath)){
                    $FinalDirectoryPath = $SecondTempDirectoryPath
                }
                else{
                    $FinalDirectoryPath = $TempDirectoryPath
                }
            }
        }

        #remove any trailing '\' since chia.exe hates them
        $TempDirectoryPath = $TempDirectoryPath.TrimEnd(@('\','/'))
        $FinalDirectoryPath = $FinalDirectoryPath.TrimEnd(@('\','/'))

        #path to chia.exe or alternative plotter
        $ChiaPath = (Get-Item -Path "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon\chia.exe").FullName
        if ($AlternativePlotterEnabled -eq $true){
            $TempDirectoryPath = $TempDirectoryPath + '\'
            $FinalDirectoryPath = $FinalDirectoryPath + '\'

            $PlotterPath = $AlternativePlotterPath
            $ChiaArguments = "-u $Buckets -r $Threads -t $TempDirectoryPath -d $FinalDirectoryPath"
            if ($Phase3and4BucketsEnabled -eq $true){
                $ChiaArguments += " -v $Phase3and4Buckets"
            }
        }
        else{
            $PlotterPath = $ChiaPath
            $ChiaArguments = "plots create -k $KSize -b $Buffer -u $Buckets -r $Threads -t `"$TempDirectoryPath`" -d `"$FinalDirectoryPath`" $E $X"
        }

        if ($PoolContractEnabled){
            if (-not[string]::IsNullOrEmpty($PoolContractAddress)){
                $ChiaArguments += " -c $PoolContractAddress"
            }
        }
        elseif (-not[string]::IsNullOrWhiteSpace($PoolPublicKey)){
            $ChiaArguments += " -p $PoolPublicKey"
        }

        if (-not[string]::IsNullOrWhiteSpace($FarmerPublicKey)){
            $ChiaArguments += " -f $FarmerPublicKey"
        }

        if ($ChiaJob.BasicPlotting){
            if ($ChiaRun.PlottingParameters.EnableBasicSecondTempDirectory){
                if (-not[string]::IsNullOrWhiteSpace($SecondTempDirectoryPath)){
                    $SecondTempDirectoryPath = $SecondTempDirectoryPath.TrimEnd(@('\','/'))
                    if ($AlternativePlotterEnabled -eq $true){
                        $SecondTempDirectoryPath = $SecondTempDirectoryPath + '\'
                        $ChiaArguments += " -2 $SecondTempDirectoryPath" 
                    }
                    else{
                        $ChiaArguments += " -2 `"$SecondTempDirectoryPath`"" 
                    }
                }
            }
        }
        else{
            if (-not[string]::IsNullOrWhiteSpace($SecondTempDirectoryPath)){
                $SecondTempDirectoryPath = $SecondTempDirectoryPath.TrimEnd(@('\','/'))
                if ($AlternativePlotterEnabled -eq $true){
                    $SecondTempDirectoryPath = $SecondTempDirectoryPath + '\'
                    $ChiaArguments += " -2 $SecondTempDirectoryPath" 
                }
                else{
                    $ChiaArguments += " -2 `"$SecondTempDirectoryPath`"" 
                }
            }
        }
        if ($KSize -eq 25){
            $ChiaArguments += " --override-k"
        }

        if ($PlotterPath){
            Write-Information "Chia path exists, starting the plotting process"
            try{
                $LogPath = Join-Path $LogDirectoryPath ((Get-Date -Format yyyy_MM_dd_hh-mm-ss-tt_) + "plotlog-" + $ChiaQueue.QueueNumber + "-" + $ChiaRun.RunNumber + ".log")
                $ChiaRun.LogPath = $LogPath
                $PlottingParam = @{
                    FilePath = $PlotterPath
                    ArgumentList = $ChiaArguments
                    RedirectStandardOutput = $LogPath
                }
                $chiaProcess = Start-Process @PlottingParam -PassThru -WindowStyle Hidden


                #this is 100% require for th exit code to be seen by powershell when redirectingstandardoutput
                $handle = $chiaProcess.Handle

                $ChiaRun.ChiaProcess = $ChiaProcess
                $ChiaRun.ProcessId = $ChiaProcess.Id
                $ChiaJob.RunsInProgress.Add($ChiaRun)

                if (-not$ChiaJob.BasicPlotting){
                    $TempMasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $ChiaRun.PlottingParameters.TempVolume.UniqueId
                    $TempMasterVolume.CurrentChiaRuns.Add($ChiaRun)
                    $FinalMasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $ChiaRun.PlottingParameters.FinalVolume.UniqueId
                    $FinalMasterVolume.PendingFinalRuns.Add($ChiaRun)
                }

                $ChiaQueue.CurrentRun = $ChiaRun
                $DataHash.MainViewModel.CurrentRuns.Add($ChiaRun)
                $DataHash.MainViewModel.AllRuns.Add($ChiaRun)

                #Have noticed that giving the process a second to start before checking the logs works better
                Start-Sleep 1
            
                while (!$chiaProcess.HasExited){
                    try{
                        if ($AlternativePlotterEnabled -eq $true){
                            $progress = Get-ChiaPlotProgress -LogPath $LogPath -MadMax -ErrorAction Stop
                        }
                        else{
                            $progress = Get-ChiaPlotProgress -LogPath $LogPath -ErrorAction Stop
                        }
                        $plotid = $progress.PlotId
                        $ChiaRun.Progress = $progress.progress
                        $ChiaRun.PlotId = $plotid
                        $ChiaQueue.CurrentTime = [DateTime]::Now
                        $ChiaRun.CurrentTime = [DateTime]::Now
                        $ChiaRun.Phase = $progress.Phase
                        if ($progress.EST_TimeRemaining.TotalSeconds -le 0){
                            $ChiaRun.EstTimeRemaining = New-TimeSpan -Seconds 0
                        }
                        else{
                            $ChiaRun.EstTimeRemaining = $progress.EST_TimeRemaining
                        }
                        switch ($progress.Phase) {
                            "Phase 1" {$ChiaRun.CurrentPhaseProgress = $progress.Phase1Progess}
                            "Phase 2" {$ChiaRun.CurrentPhaseProgress = $progress.Phase2Progess}
                            "Phase 3" {$ChiaRun.CurrentPhaseProgress = $progress.Phase3Progess}
                            "Phase 4" {$ChiaRun.CurrentPhaseProgress = $progress.Phase4Progess}
                            "Copying" {$ChiaRun.CurrentPhaseProgress = $progress.CopyProgess}
                        }
                        if (($progress.Phase -eq "Phase 4" -or $progress.Phase -eq "Copying" -or $progress.Phase3Progess -gt 75) -and $ReplotEnabled -and -not$OldPlotDeleted){
                            $OldPlotDeleted = $true
                            $oldDirectories = $ChiaRun.PlottingParameters.FinalVolume.OldPlotDirectories.Path
                            $OldPlot = Get-ChildItem -Path $oldDirectories -Filter "plot-k$($KSize)*.plot" | Select-Object -First 1
                            if ($Null -ne $OldPlot){
                                $OldPlot | Remove-Item -Force
                            }
                        }
                        $ChiaRun.TempSize = Get-ChiaTempSize -DirectoryPath $TempDirectoryPath -PlotId $plotid
                        Start-Sleep (5 + $ChiaQueue.QueueNumber)
                    }
                    catch{
                        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                        Start-Sleep 30
                    }
                } #while

                if ($PlotWhileCopy -eq $true -and ($ChiaRun.ChiaProcess.ExitCode -eq 0)){
                    if (-not$ChiaJob.BasicPlotting){
                        Start-PlotCopyPhase -RunToCopy $ChiaRun -FinalVol $FinalMasterVolume -TempVol $TempMasterVolume
                    }
                    else{
                        Start-PlotCopyPhase -RunToCopy $ChiaRun
                    }
                    return #need to return so that the next plot can start
                }

                $ChiaJob.RunsInProgress.Remove($ChiaRun)
                $ChiaJob.CompletedRunCount++

                if (-not$ChiaJob.BasicPlotting){
                    $FinalMasterVolume.PendingFinalRuns.Remove($ChiaRun)
                    $TempMasterVolume.CurrentChiaRuns.Remove($ChiaRun)
                }
                $ChiaRun.ExitCode = $ChiaRun.ChiaPRocess.ExitCode
                #if this is null then an error will occur if we try to set this property
                if ($ChiaRun.ExitTime){
                    $ChiaRun.ExitTime = $ChiaProcess.ExitTime
                }

                if ($ChiaRun.ChiaProcess.ExitCode -ne 0){
                    $ChiaRun.Status = "Failed"
                    $ChiaQueue.FailedPlotCount++
                    $ChiaJob.FailedPlotCount++
                    $DataHash.MainViewModel.FailedRuns.Add($ChiaRun)
                    Start-Sleep -Seconds 1
                    Get-ChildItem -Path $TempDirectoryPath -Filter "*$plotid*.tmp" | foreach {
                        try{
                            Remove-Item -Path $_.FullName -Force -ErrorAction Stop
                        }
                        catch{
                            Show-Messagebox -Text $_.Exception.Message | Out-Null
                        }
                    }
                    if (-not[string]::IsNullOrWhiteSpace($SecondTempDirectoryPath)){
                        Get-ChildItem -Path $SecondTempDirectoryPath -Filter "*$plotid*.tmp" | foreach {
                            try{
                                Remove-Item -Path $_.FullName -Force -ErrorAction Stop
                            }
                            catch{
                                Show-Messagebox -Text $_.Exception.Message | Out-Null
                            }
                        } #foreach file
                    }
                }
                else{
                    $ChiaRun.Status = "Completed"
                    $ChiaJob.CompletedPlotCount++
                    $ChiaQueue.CompletedPlotCount++
                    $DataHash.MainViewModel.CompletedRuns.Add($ChiaRun)
                    $ChiaRun.CheckPlotPowershellCommand = "&'$ChiaPath' plots check -g $plotid"
                    Update-ChiaGUISummary -Success
                    if ($ChiaRun.PlottingParameters.AutoPlotCheckEnabled){
                        $PlotCheckResults = Test-ChiaPlot -Path $plotid -ErrorAction Continue
                        if ($Null -ne $PlotCheckResults){
                            $ChiaRun.PlotCheckRatio = [math]::Round($PlotCheckResults.Ratio,2)
                        }
                    } #if autoplotcheck
                }
                $ChiaQueue.CurrentRun = $null
                $DataHash.MainViewModel.CurrentRuns.Remove($ChiaRun)
            }
            catch{
                if (-not$DataHash.MainViewModel.FailedRuns.Contains($ChiaRun)){
                    $DataHash.MainViewModel.FailedRuns.Add($ChiaRun)
                }
                if ($DataHash.MainViewModel.CurrentRuns.Contains($ChiaRun)){
                    $DataHash.MainViewModel.CurrentRuns.Remove($ChiaRun)
                }
                if ($ChiaJob.RunsInProgress.Contains($ChiaRun)){
                    $ChiaJob.RunsInProgress.Remove($ChiaRun)
                }
                if (-not$ChiaJob.BasicPlotting){
                    if ($FinalMasterVolume){
                        if ($FinalMasterVolume.PendingFinalRuns.Contains($ChiaRun)){
                            $FinalMasterVolume.PendingFinalRuns.Remove($ChiaRun)
                        }
                    }
                }
                $PSCmdlet.WriteError($_)
            }
        } #if chia path exits
        else{
            $Message = "chia.exe was not found"
            $ErrorRecord = [System.Management.Automation.ErrorRecord]::new(
                    [System.IO.FileNotFoundException]::new($Message,"$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon\chia.exe"),
                    'ChiaPathInvalid',
                    [System.Management.Automation.ErrorCategory]::ObjectNotFound,
                    "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon\chia.exe"
                )
                $PSCmdlet.ThrowTerminatingError($ErrorRecord)
            $PSCmdlet.ThrowTerminatingError("Invalid Log Path Directory: $LogDirectoryPath")
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        $PSCmdlet.WriteError($_)
    }
}
function Start-GUIDebugRun{
    [CmdletBinding()]
    param(
        $ChiaRun,
        $ChiaQueue,
        $ChiaJob
    )
    try{
        $PlottingParameters = $ChiaRun.PlottingParameters
        $KSize = $PlottingParameters.KSize.KSizeValue
        $Buffer = $PlottingParameters.RAM
        $Threads = $PlottingParameters.Threads
        $DisableBitfield = $PlottingParameters.DisableBitField
        $ExcludeFinalDirectory = $PlottingParameters.ExcludeFinalDirectory
        $TempDirectoryPath = $PlottingParameters.TempVolume.DirectoryPath
        $FinalDirectoryPath = $PlottingParameters.FinalVolume.DirectoryPath
        $LogDirectoryPath = $PlottingParameters.LogDirectory
        $SecondTempDirecoryPath = $PlottingParameters.SecondTempVolume.DirectoryPath
    
        $E = if ($DisableBitfield){"-e"}
        $X = if ($ExcludeFinalDirectory){"-x"}
    
        if (Test-Path $LogDirectoryPath){
            $LogPath = Join-Path $LogDirectoryPath ((Get-Date -Format yyyy_MM_dd_hh-mm-ss-tt_) + "plotlog" + ".log")
        }
        $ChiaProcess = start-process -filepath notepad.exe -PassThru -RedirectStandardOutput $LogPath
        $handle = $ChiaProcess.Handle
        $ChiaRun.ChiaProcess = $ChiaProcess
        $ChiaRun.ProcessId = $ChiaProcess.Id
        $DataHash.MainViewModel.AllRuns.Add($ChiaRun)
        $ChiaJob.RunsInProgress.Add($ChiaRun)
        
        $TempMasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $ChiaRun.PlottingParameters.TempVolume.UniqueId
        $TempMasterVolume.CurrentChiaRuns.Add($ChiaRun)
        $FinalMasterVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $ChiaRun.PlottingParameters.FinalVolume.UniqueId
        $FinalMasterVolume.PendingFinalRuns.Add($ChiaRun)
    
        $ChiaQueue.CurrentRun = $ChiaRun
        $DataHash.MainViewModel.CurrentRuns.Add($ChiaRun)
        while (-not$ChiaProcess.HasExited){
            $ChiaQueue.CurrentTime = [DateTime]::Now
            $ChiaRun.CurrentTime = [DateTime]::Now
            $ChiaRun.Progress += 5
            sleep (10 + $ChiaQueue.QueueNumber)
        }

        $TempMasterVolume.CurrentChiaRuns.Remove($ChiaRun)
        $FinalMasterVolume.PendingFinalRuns.Remove($ChiaRun)
        $ChiaJob.RunsInProgress.Remove($ChiaRun)
        $ChiaJob.CompletedRunCount++

        $ChiaRun.ExitCode = $ChiaProcess.ExitCode
        if ($ChiaProcess.ExitTime -ne $null){
            $ChiaRun.ExitTime = $ChiaProcess.ExitTime
        }
        $ChiaRun.ExitTime = $ChiaProcess.ExitTime
        if ($ChiaProcess.ExitCode -eq 0){
            $ChiaRun.Status = "Completed"
            $ChiaJob.CompletedPlotCount++
            $ChiaQueue.CompletedPlotCount++
            $DataHash.MainViewModel.CompletedRuns.Add($ChiaRun)
            Update-ChiaGUISummary -Success
        }
        else{
            $ChiaRun.Status = "Failed"
            $ChiaJob.FailedPlotCount++
            $ChiaQueue.FailedPlotCount++
            $DataHash.MainViewModel.FailedRuns.Add($ChiaRun)
        }
        $DataHash.MainViewModel.CurrentRuns.Remove($ChiaRun)
    }
    catch{
        if (-not$DataHash.MainViewModel.FailedRuns.Contains($ChiaRun)){
            $DataHash.MainViewModel.FailedRuns.Add($ChiaRun)
        }
        if ($DataHash.MainViewModel.CurrentRuns.Contains($ChiaRun)){
            $DataHash.MainViewModel.CurrentRuns.Remove($ChiaRun)
        }
        if ($ChiaJob.RunsInProgress.Contains($ChiaRun)){
            $ChiaJob.RunsInProgress.Remove($ChiaRun)
        }
        if ($FinalMasterVolume){
            if ($FinalMasterVolume.PendingFinalRuns.Contains($ChiaRun)){
                $FinalMasterVolume.PendingFinalRuns.Remove($ChiaRun)
            }
        }
        $PSCmdlet.WriteError($_)
    }
}
function Start-PlotCopyPhase {
    [CmdletBinding()]
    param(
        $RunToCopy,
        $FinalVol,
        $TempVol
    )

    $StartCopyPhaseScript = [powershell]::Create().AddScript{
        Param (
            $RunToCopy,
            $FinalVol,
            $TempVol
        )
        $ErrorActionPreference = "Stop"
        Add-Type -AssemblyName PresentationFramework
        Add-Type -AssemblyName System.Windows.Forms

        #Import required assemblies and private functions
        Get-childItem -Path $DataHash.PrivateFunctions -File -Recurse | ForEach-Object {Import-Module $_.FullName}
        Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}
        try{
            $RunToCopy.Phase = "Copy"
            $RunToCopy.CurrentPhaseProgress = 0
            $RunToCopy.Progress = 98
            $ChiaPath = (Get-Item -Path "$ENV:LOCALAPPDATA\chia-blockchain\app-*\resources\app.asar.unpacked\daemon\chia.exe").FullName
            if ($RunToCopy.PlottingParameters.AlternativePlotterEnabled -eq $true){
                $tempFinalPath = $RunToCopy.PlottingParameters.TempVolume.DirectoryPath
            }
            else{
                if (-not[string]::IsNullOrEmpty($RunToCopy.PlottingParameters.SecondTempVolume.DirectoryPath)){
                    $tempFinalPath = $RunToCopy.PlottingParameters.SecondTempVolume.DirectoryPath
                }
                else{
                    $tempFinalPath = $RunToCopy.PlottingParameters.TempVolume.DirectoryPath
                }
            }
            $plotPath = Join-Path $tempFinalPath -ChildPath "*$($RunToCopy.PlotId)*"
            $PlotItem = Get-Item -Path $plotPath
            $newplotItem = Rename-Item -Path $PlotItem -NewName "$($PlotItem.Name).tmp" -Force -PassThru
            $MovedItem = Move-Item -Path $NewPlotItem.FullName -Destination $RunToCopy.PlottingParameters.FinalVolume.DirectoryPath -PassThru
            Rename-Item -Path $MovedItem.FullName -NewName $MovedItem.Name.Replace('.tmp','')
            
            $RunToCopy.Progress = 100
            $RunToCopy.CurrentPhaseProgress = 100

            $CopyRunJob = $RunToCopy.ParentQueue.ParentJob
            $CopyRunJob.RunsInProgress.Remove($RunToCopy)
            $CopyRunJob.CompletedRunCount++

            if (-not$CopyRunJob.BasicPlotting){
                $FinalVol.PendingFinalRuns.Remove($RunToCopy)
                $TempVol.CurrentChiaRuns.Remove($RunToCopy)
            }
            $RunToCopy.ExitCode = $RunToCopy.ChiaPRocess.ExitCode
            $RunToCopy.ExitTime = [datetime]::Now

            $RunToCopy.Status = "Completed"
            $CopyRunJob.CompletedPlotCount++
            $RunToCopy.ParentQueue.CompletedPlotCount++
            $DataHash.MainViewModel.CompletedRuns.Add($RunToCopy)
            $RunToCopy.CheckPlotPowershellCommand = "&'$ChiaPath' plots check -g $($RunToCopy.PlotId)"
            Update-ChiaGUISummary -Success
            if ($RunToCopy.PlottingParameters.AutoPlotCheckEnabled){
                $PlotCheckResults = Test-ChiaPlot -Path $RunToCopy.PlotId -ErrorAction Continue
                if ($Null -ne $PlotCheckResults){
                    $RunToCopy.PlotCheckRatio = [math]::Round($PlotCheckResults.Ratio,2)
                }
            } #if autoplotcheck

            $RunToCopy.ParentQueue.CurrentRun = $null
            $DataHash.MainViewModel.CurrentRuns.Remove($RunToCopy)
        }
        catch{
            Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            if (-not$DataHash.MainViewModel.FailedRuns.Contains($RunToCopy)){
                $DataHash.MainViewModel.FailedRuns.Add($RunToCopy)
            }
            if ($DataHash.MainViewModel.CurrentRuns.Contains($RunToCopy)){
                $DataHash.MainViewModel.CurrentRuns.Remove($RunToCopy)
            }
            if ($CopyRunJob.RunsInProgress.Contains($RunToCopy)){
                $CopyRunJob.RunsInProgress.Remove($RunToCopy)
            }
            if (-not$CopyRunJob.BasicPlotting){
                if ($FinalVol){
                    if ($FinalVol.PendingFinalRuns.Contains($RunToCopy)){
                        $FinalVol.PendingFinalRuns.Remove($RunToCopy)
                    }
                }
            }
        }
    }.AddParameters($PSBoundParameters)
    $StartCopyPhaseScript.RunspacePool = $ScriptsHash.RunspacePool
    [void]$StartCopyPhaseScript.BeginInvoke()
}
function Stop-PSChiaPlotter{
    [CmdletBinding()]
    param(
        [switch]$EndChiaProcess
    )

    $RunningQueues = $DataHash.MainViewModel.AllQueues | Where-Object Status -eq "Running"
    foreach ($Queue in $RunningQueues){
        $queue.Status = "Paused"
    }

    if ($EndChiaProcess){
        $ALLChiaProcesses = $DataHash.MainViewModel.CurrentRuns
        foreach ($run in $ALLChiaProcesses){
            try{
                Stop-Process $run.ProcessID
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        }
    }
    $RunningRunspaces = $DataHash.Runspaces
    foreach ($runspace in $RunningRunspaces){
        try{
            $runspace.Stop()
        }
        catch{
            Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        }
    }
}
function Test-AlternativePlotterParameters {
    [CmdletBinding()]
    param()

    try{
        $ChiaParameters = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters
        if ($ChiaParameters.AlternativePlotterEnabled -eq $true){
            if (-not(Test-Path -Path $ChiaParameters.AlternativePlotterPath -PathType Leaf)){
                return "The path to the alternative plotter is invalid - [$($ChiaParameters.AlternativePlotterPath)]"
            }
            
            if ($ChiaParameters.PoolContractEnabled){
                if ([string]::IsNullOrEmpty($ChiaParameters.PoolContractAddress)){
                    return "You must supply a Pool Contract Address for the alternative plotter to use!"
                }
            }
            else{
                if ([string]::IsNullOrEmpty($ChiaParameters.PoolPublicKey)){
                    return "You must supply a pool public key for the alternative plotter to use!"
                }
            }

            if ([string]::IsNullOrEmpty($ChiaParameters.FarmerPublicKey)){
                return "You must supply a farmer public key for the alternative plotter to use!"
            }
            if ($ChiaParameters.KSize.KSizeValue -ne 32){
                return "Currently alternative plotter does not accept any KSize other than 32, please change KSize to 32"
            }
            [void](Show-MessageBox -Text "PSChiaPlotter will not check for temp free space when using alternative plotters, so please read space requirments based on the plotter's documentation and use accordingly!" -Icon Information)
        }
        return $true
    }
    catch{
        return $_.Exception.Message
        Write-PSChiaPlotterLog -LogLevel "Error" -ErrorObject $_
    }
}
function Test-ChiaParameters {
    param(
        $NewJob
    )
    $ChiaParameters = $NewJob.InitialChiaParameters

    if ([string]::IsNullOrEmpty($NewJob.JobName)){
        return "Job Name cannot be null or empty"
    }
    if ($ChiaParameters.RAM -lt 100){
        return "RAM needs to be greater than 100"
    }
    if ($ChiaParameters.Threads -le 0){
        return "Threads needs to 1 or higher"
    }
    if ($ChiaParameters.Buckets -le 0){
        return "Buckets cannot be less than 1"
    }
    if ($NewJob.EnablePhaseOneLimitor){
        if ($NewJob.PhaseOneLimit -lt 1){
            return "Phase one limit cannot be less than 1... that doesn't make sense."
        }
    }
    if ($NewJob.BasicPlotting){
        if (-not[System.IO.Directory]::Exists($ChiaParameters.BasicTempDirectory.DirectoryPath)){
            return "Temp Directory `"$($ChiaParameters.BasicTempDirectory.DirectoryPath)`" does not exists"
        }
        if (-not[System.IO.Directory]::Exists($ChiaParameters.BasicFinalDirectory.DirectoryPath)){
            return "Final Directory `"$($ChiaParameters.BasicFinalDirectory.DirectoryPath)`" does not exists"
        }
        if ($ChiaParameters.EnableBasicSecondTempDirectory){
            if (-not[System.IO.Directory]::Exists($ChiaParameters.BasicSecondTempDirectory)){
                return "2nd Temp Directory `"$($ChiaParameters.BasicSecondTempDirectory)`" does not exists"
            }
        }
    }
    else{
        if ($NewJob.TempVolumes.Count -lt 1){
            return "No Temp drives have been added!"
        }
        foreach ($tempvol in $NewJob.TempVolumes){
            if (-not[System.IO.Directory]::Exists($tempvol.DirectoryPath)){
                return "Temp Directory `"$($tempvol.DirectoryPath)`" does not exists"
            }
            $ValidPath = $false
            foreach ($path in $tempvol.AccessPaths){
                if ($tempvol.DirectoryPath.StartsWith($path,[System.StringComparison]::CurrentCultureIgnoreCase)){
                    $ValidPath = $true
                }
            } #foreach
            if (-not$ValidPath){
                return "Directory path '$($tempvol.DirectoryPath)' for Drive $($tempvol.DriveLetter) does not start with a valid access path, valid paths shown below.`n`n$($tempvol.AccessPaths | foreach {"$_`n"})"
            }
        }
        if ($NewJob.FinalVolumes.Count -lt 1){
            return "No Final Drives have been added!"
        }
        foreach ($finalvol in $NewJob.FinalVolumes){
            if (-not[System.IO.Directory]::Exists($finalvol.DirectoryPath)){
                return "Final Directory `"$($finalvol.DirectoryPath)`" does not exists"
            }
            $ValidPath = $false
            foreach ($path in $finalvol.AccessPaths){
                if ($finalvol.DirectoryPath.StartsWith($path,[System.StringComparison]::CurrentCultureIgnoreCase)){
                    $ValidPath = $true
                }
            } #foreach
            if (-not$ValidPath){
                return "Directory path '$($finalvol.DirectoryPath)' for Drive $($finalvol.DriveLetter) does not start with a valid access path, valid paths shown below.`n`n$($finalvol.AccessPaths | foreach {"$_`n"})"
            }
        }
    } #else
    
    if (-not[System.IO.Directory]::Exists($ChiaParameters.LogDirectory)){
        return "Log Directory does not exists"
    }
    if ($NewJob.DelayInMinutes -gt 35791){
        return "Delay Time is greater than 35791 minutes, which is the max"
    }
    if ($NewJob.FirstDelay -gt 35791){
        return "First delay time is greater than 35791 minutes, which is the max"
    }
    if ($ChiaParameters.PoolContractEnabled){
        if ([string]::IsNullOrEmpty($ChiaParameters.PoolContractAddress)){
            return "Pool contract address is enabled, but no address was provided!"
        }
    }
    return $true
}
function Test-PhaseOneIsOpen {
    [CmdletBinding()]
    param(
        $ChiaJob
    )

    try{
        if ($ChiaJob.EnablePhaseOneLimitor){
            $phaseOneCount = ($ChiaJob.RunsInProgress | where Phase -eq "Phase 1" | Measure-Object).Count
            if ($phaseOneCount -ge $ChiaJob.PhaseOneLimit){
                return $false
            }
            else{
                return $true
            }
        }
        else{
            return $true
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogLevel "Warning" -Message "Unable to check if phase one is open!"
    }
}
function Test-PlotCount {
    [CmdletBinding()]
    param(
        $CurrentJob,
        [switch]$BreakLoop
    )

    if ($BreakLoop){
        (($CurrentJob.CompletedRunCount + $CurrentJob.RunsInProgress.Count) -ge $CurrentJob.TotalPlotCount) -and ($CurrentJob.PlotInfinite -eq $false)
    }
    else{
        (($CurrentJob.CompletedRunCount + $CurrentJob.RunsInProgress.Count) -lt $CurrentJob.TotalPlotCount) -or ($CurrentJob.PlotInfinite -eq $true)
    }
}
function Test-ReplotParameters{
    [CmdletBinding()]
    param()

    try{
        $ChiaParameters = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters
        if ($ChiaParameters.ReplotEnabled){
            if ($DataHash.NewJobViewModel.NewChiaJob.BasicPlotting){
                $FinalVolumes = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory
            }
            else{
                $FinalVolumes = $DataHash.NewJobViewModel.NewChiaJob.FinalVolumes
            }
            foreach ($replotVolume in $FinalVolumes){
                if (-not$replotVolume.ReplotEnabled){
                    return "ReplotEnabled Property is not true for volume '$($replotVolume.DriveLetter)'.`n`nWhen replotting all final volumes must have plots to replot!"
                }
                if ($replotVolume.OldPlotDirectories.Count -eq 0){
                    return "Volume '$($replotVolume.DriveLetter)' has zero old plot directories added to it. Please a directory to replot!"
                }
                if ($replotVolume.TotalReplotCount -lt 1){
                    return "Volume '$($replotVolume.DriveLetter)' has zero plots to replot, please remove it or add old plot directories to replot!"
                }
                if (($replotVolume.OldPlotDirectories.KSizeValue | Group-Object | Measure-Object).Count -gt 1){
                    return "You are trying to replot different KSizes at the same time... This is not possible with this plot manager."
                }
                if ($replotVolume.OldPlotDirectories[0].KSizeValue -ne $ChiaParameters.KSize.KSizeValue){
                    return "You are trying to replot with a different KSize. This plot manager is not smart enough to do that!`n Please make all KSizes match!"
                }
                if ($replotVolume.DirectoryPath -in $replotVolume.OldPlotDirectories.Path){
                    return "Your new plot directory path cannot be any of the old plot directory paths, please create a new folder for the new plots or move the old plots to a different folder!"
                }
            }
            if ($DataHash.NewJobViewModel.NewChiaJob.PlotInfinite -eq $true){
                return "Plot Infinite needs to be disabled when the replot feature is in use!"
            }
            $TotalReplotCount = ($FinalVolumes.OldPlotDirectories | Measure-Object -Property PlotCount -Sum).Sum
            if ($TotalReplotCount -lt $DataHash.NewJobViewModel.NewChiaJob.TotalPlotCount){
                $Response = Show-MessageBox -Icon Warning -Buttons YesNo -Text "You cannot plot more than the total number of plots you want to replot!`n`nWould you like to change the total plot count to $([string]$TotalReplotCount)?"
                if ($Response -eq [System.Windows.MessageBoxResult]::Yes){
                    $DataHash.NewJobViewModel.NewChiaJob.TotalPlotCount = $TotalReplotCount
                    return $true
                }
                else{
                    return "Either add more plots to replot or lower your total plot count!"
                }
            }
        }
        return $true
    }
    catch{
        Write-PSChiaPlotterLog -LogType Error -ErrorObject $_
        Show-MessageBox -Text $_.Exception.Message -Title "Replot Parameter Check" -Icon Error | Out-Null
        return "Unable to test replot parameters :("
    }
}
function Update-ChiaGUISummary{
    [CmdletBinding()]
    param(
        [switch]$Success,
        [switch]$Failed
    )

    if ($Success){
        $OneDayAgo = (Get-Date).AddDays(-1)
        $PlotsIn24Hrs = $DataHash.MainViewModel.CompletedRuns | where ExitTime -GT $OneDayAgo
        $DataHash.MainViewModel.PlotPlottedPerDay = ($PlotsIn24Hrs | Measure-Object).Count
        $totalTBPlotted = 0
        foreach ($plot in $PlotsIn24Hrs){
            $totalTBPlotted += ($plot.PlottingParameters.KSize.FinalSize / 1gb)
        }
        $DataHash.MainViewModel.TBPlottedPerDay = [math]::Round($totalTBPlotted / 1000,4)

        $SortedRuns = $DataHash.MainViewModel.CompletedRuns | Sort-Object -Property Runtime
        $Fastest = $SortedRuns | Select-Object -First 1
        $Slowest = $SortedRuns | Select-Object -Last 1
        $Average = $SortedRuns.RunTime | Measure-Object -Property TotalSeconds -Average

        if ($Fastest){
            $DataHash.MainViewModel.FastestRun = $Fastest.Runtime
        }
        if ($Slowest){
            $DataHash.MainViewModel.SlowestRun = $Slowest.Runtime
        }
        if ($Average){
            $AverageRun = New-TimeSpan -Seconds $Average.Average
            $DataHash.MainViewModel.AverageTime = $AverageRun
        }
    }
}
function Update-ChiaVolume {
    [CmdletBinding()]
    param()
    $Volumes = Get-ChiaVolume
    $CurrentVolumes = $Volumes | where UniqueId -in $DataHash.MainViewModel.AllVolumes.UniqueId
    foreach ($volume in $CurrentVolumes){
        $matchedVolume = $DataHash.MainViewModel.AllVolumes | where UniqueId -eq $volume.UniqueId
        if ($matchedVolume){
            $matchedVolume.FreeSpace = $volume.FreeSpace
            $matchedVolume = $null
        }
    }

    $newVolumes = $Volumes | where UniqueId -notin $DataHash.MainViewModel.AllVolumes.UniqueId
    foreach ($newvolume in $newVolumes){
        $DataHash.MainViewModel.AllVolumes.Add($newvolume)
    }

    $removedVolumes = $DataHash.MainViewModel.AllVolumes | where UniqueId -NotIn $Volumes.UniqueId
    foreach ($removedvolume in $removedVolumes){
        $DataHash.MainViewModel.AllVolumes.Remove($removedvolume)
    }
}
function Update-PSChiaPlotter {
    [CmdletBinding()]
    param()

    $UpdateScript = [powershell]::Create().AddScript{
        Add-Type -AssemblyName PresentationFramework
        Add-Type -AssemblyName System.Windows.Forms
        Get-childItem -Path $DataHash.PrivateFunctions -File | ForEach-Object {Import-Module $_.FullName}
        Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}
        Import-Module -Name PSChiaPlotter

        $CurrentModule = Get-Module -Name PSChiaPlotter
        $NewestModule = Find-Module -Name PSChiaPLotter -Repository PSGallery
        if ($NewestModule.Version -gt $CurrentModule.Version){
            $Response = Show-Messagebox -Text "New version found! Version - $($NewestModule.Version.ToString())`nWould you like to update now?" -Buttons YesNo
            if ($Response -eq [System.Windows.MessageBoxResult]::Yes){
                try{
                    Update-Module -Name PSChiaPlotter -Force -ErrorAction Stop
                    $message = "PSChiaPlotter module successfully updated from $($CurrentModule.Version.ToString()) to $($NewestModule.Version.ToString())"
                    $message += "`nYou must restart the GUI before changes can take effect.`nOnly do this when your plots have finished!"
                    Write-PSChiaPlotterLog -LogType INFO -Message $message
                    Show-Messagebox -Text $message | Out-Null
                }
                catch{
                    Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                    Show-Messagebox -Text "Unable to update to the latest version. Check logs more info" | Out-Null
                }
            }
        }
        else{
            Try{
                Show-Messagebox -Text "Your PSChiaPlotter is up to date!" | Out-Null
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        }
    }
    $UpdateScript.RunspacePool = $ScriptsHash.Runspacepool
    $UpdateScript.BeginInvoke()
}
function Write-PSChiaPlotterLog {
    [CmdletBinding()]
    param(
        [ValidateSet("INFO","WARNING","ERROR")]
        [string]$LogType,
        [string]$Message,
        [int]$LineNumber,
        [string]$Line,
        $ErrorObject
    )

    try{
        $Date = Get-Date -Format "[yyyy-MM-dd.HH:mm:ss]"
        switch ($LogType){
            "ERROR" {
                $Message = $ErrorObject.Exception.Message
                $LineNumber = $ErrorObject.InvocationInfo.ScriptLineNumber
                $Line = $ErrorObject.InvocationInfo.Line
                Write-Host "[$LogType]$Date-$LineNumber-$Message`n $Line"
                break
            }
            "WARNING" {
                if ($DataHash.MainViewModel.LogLevel -eq "WARNING"){
                    Write-Host "[$LogType]-$Date-$Message"
                }
                break
            }
            "INFO" {
                if ($DataHash.MainViewModel.LogLevel -eq "INFO" -or $DataHash.MainViewModel.LogLevel -eq "WARNING"){
                    Write-Host "[$LogType]-$Date-$Message"
                }
                break
            }
        }
    }
    catch{
        Write-Host $_.Exception.Message
    }
}
function Write-RGBText {
    [CmdletBinding()]
    param(
        [string]$Text,

        [Parameter(Position = 1)]
        [int]$fRed = 0,
        [int]$fGreen = 0,
        [int]$fBlue = 0,

        [int]$bRed = 0,
        [int]$bGreen = 0,
        [int]$bBlue = 0,
        
        # No newline after the text.
        [Parameter()]
        [switch] $NoNewLine,

        [switch]$UnderLine
    )

    $escape = [char]27 + '['
    $resetAttributes = "$($escape)0m"

    if ($UnderLine){
        $UL = "$($escape)4m"
    }
    
    $foreground = "$($escape)38;2;$($fRed);$($fGreen);$($fBlue)m"
    $background = "$($escape)48;2;$($bRed);$($bGreen);$($bBlue)m"
    
    Write-Host ($foreground + $background + $UL + $Text + $resetAttributes) -NoNewline:$NoNewLine
}
function Invoke-AddOldPlotDirectoryButtonClick {
    [CmdletBinding()]
    param(
        [string]$Path
    )
    try{
        if (-not$DataHash.NewJobViewModel.NewChiaJob.BasicPlotting){
            $ValidPath = $false
            foreach ($accesspath in $OldDirectories_ListBox.DataContext.AccessPaths){
                if ($OldDirectories_ListBox.DataContext.DirectoryPath.StartsWith($accesspath,[System.StringComparison]::CurrentCultureIgnoreCase)){
                    $ValidPath = $true
                }
            } #foreach
            if (-not$ValidPath){
                [void](Show-MessageBox "The replot directory path does not exists in the volume you are trying to replot!")
            }
        }
        if ($OldDirectories_ListBox.DataContext.DirectoryPath -eq $path){
            Show-MessageBox -Text "Your 'New Plot Directory' cannot be the same as a replot diretory!`n`nPlease change your 'New Plot Directory'!" -Icon Warning | Out-Null
            return
        }
        if ([System.IO.Directory]::Exists($Path)){
    
            if ($Path -in $OldDirectories_ListBox.DataContext.OldPlotDirectories.Path){
                Show-MessageBox -Icon Warning -Text "This old plot directory has already been added!" | Out-Null
                return
            }
            $currentKSize = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize.KSizeValue
            $plots = Get-ChildItem -Path $Path -Filter "*.plot" -File
            $matchedPlots = $plots | where Name -like "plot-k$($currentKSize)*.plot"
            $plotcount = ($matchedPlots | Measure-Object).Count

            if ($plotcount -ge 1){
                [PSChiaPlotter.OldPlotDirectory]::new($path,$plotcount,$currentKSize)
            }
            elseif (($plots | Measure-Object).Count -ge 1){
                Show-MessageBox -Text "Plots were found, but they are not K$currentKSize and cannot be replotted with the current settings!" -Icon Warning | Out-Null
            }
            else{
                Show-MessageBox -Text "No plots were found of any KSize in this directory - [$Path]!" -Icon Warning | Out-Null
            }
        }
        else{
            Show-MessageBox -Text "Directory path provided does not exists!" -Icon Warning | Out-Null
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType Error -ErrorObject $_
        Show-MessageBox -Text $_.Exception.Message -Title "Add Directory Error" -Icon Error | Out-Null
    }
}
function Invoke-AddPlotLogDirectoryPathButtonClick {
    [CmdletBinding()]
    param(
        $PlotLogDirPath
    )
    $AddPlotPathScript = [powershell]::Create().AddScript{
        param(
            $PlotLogDirPath
        )
        try{
            $ErrorActionPreference = "Stop"
            Add-Type -AssemblyName PresentationFramework
    
            #Import required assemblies and private functions
            Get-childItem -Path $DataHash.PrivateFunctions -File -Recurse | ForEach-Object {Import-Module $_.FullName}
            Get-childItem -Path $DataHash.Classes -File | ForEach-Object {Import-Module $_.FullName}

            $UIHash.AddPlotLogPath_Button.Dispatcher.Invoke([action]{$UIHash.AddPlotLogPath_Button.IsEnabled = $false})
            #$PlotLogDirPath = $UIHash.AddPlotLog_TextBox.Text
            if ($DataHash.MainViewModel.PlotLogDirectoryPaths.Contains($PlotLogDirPath)){
                [void](Show-MessageBox -Text "This log directory has already been added!" -Icon Warning)
                return
            }
    
            if (Test-Path -Path $PlotLogDirPath -PathType Container){
                $AllPlotLogs = (Get-ChildItem -Path $PlotLogDirPath -File).FullName
                if ($null -ne $AllPlotLogs){
                    $AllLogStats = $null
                    $AllLogStats = Get-ChiaPlottingStatistic -Path $AllPlotLogs
                    $newlogstats = foreach ($stat in $AllLogStats){
                        try{
                            $phase1 = New-TimeSpan -Seconds $stat.Phase_1_sec
                            $phase2 = New-TimeSpan -Seconds $stat.Phase_2_sec
                            $phase3 = New-TimeSpan -Seconds $stat.Phase_3_sec
                            $phase4 = New-TimeSpan -Seconds $stat.Phase_4_sec
                            $totaltime = New-TimeSpan -Seconds $stat.TotalTime_sec
                            $copyTime = New-TimeSpan -Seconds $stat.CopyTime_sec
                            $copyandplot = New-TimeSpan -Seconds $stat.PlotAndCopyTime_sec
                
                            if ($stat.PlotId){
                                $stat | Add-Member -NotePropertyMembers @{
                                    Phase_1 = $phase1
                                    Phase_2 = $phase2
                                    Phase_3 = $phase3
                                    Phase_4 = $phase4
                                    PlotTime = $totaltime
                                    CopyPhase = $copyTime
                                    PlotAndCopy = $copyandplot
                                    ParentFolder = $PlotLogDirPath
                                }
                                $stat
                            }
                            Clear-Variable "phase1","phase2","phase3","phase4","totaltime","copyTime","copyandplot" -ErrorAction SilentlyContinue
                        }
                        catch{
                            Write-Information "Unable to add time span properties"
                        }
                    }
                    foreach ($logstat in $newLogStats){
                        if (-not$DataHash.MainViewModel.AllPlottingLogStats.Contains($logstat)){
                            $DataHash.MainViewModel.AllPlottingLogStats.Add($logstat)
                        }
                    } #foreach logstat
                    $DataHash.MainViewModel.PlotLogDirectoryPaths.Add($PlotLogDirPath)
                }
                else{
                    [void](Show-MessageBox -Text "No Log files found in the folder '$PlotLogDirPath'!" -Icon Warning)
                }
            }
            else{
                [void](Show-MessageBox -Text "Path '$PlotLogDirPath' does not exist!" -Icon Warning)
            }
        }
        catch{
            Write-PSChiaPlotterLog -LogType Error -ErrorObject $_
            [void](Show-MessageBox -Text $_.Exception.Message -Title "Add Directory Error" -Icon Error)
        }
        Finally{
            $UIHash.AddPlotLogPath_Button.Dispatcher.Invoke([action]{$UIHash.AddPlotLogPath_Button.IsEnabled = $true})
        }
    }.AddParameters($PSBoundParameters) #script
    $AddPlotPathScript.RunspacePool = $ScriptsHash.RunspacePool
    [void]$AddPlotPathScript.BeginInvoke()
}
function Invoke-CancelReplotButtonClick{
    [CmdletBinding()]
    param()

    try{
        $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.ReplotEnabled = $false
        foreach ($finalVolume in $DataHash.NewJobViewModel.NewChiaJob.FinalVolumes){
            $finalVolume.ReplotEnabled = $false
        }
        $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.ReplotEnabled = $false
        $ReplotConfig_Window.Close()
    }
    catch{
        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
    }
}
function Invoke-HelpReplotButtonClick {
    [CmdletBinding()]
    param()

    try{
        $HowToReplotPath = Join-Path $DataHash.HelpFiles -ChildPath "HowToReplot.Txt"
        Invoke-Item -Path $HowToReplotPath
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
        Show-MessageBox -Text "Unable to open help file :("
    }
}
function Invoke-LoadJobButtonClick {
    [CmdletBinding()]
    param()

    try{
        $JobFilePath = $SavedJobs_ComboBox.SelectedValue
        if (($null -ne $JobFilePath) -and (Test-Path $JobFilePath)){

            #Have to transfer the properties over since the imported job is Desesersilzed Object

            $ImportedJob = Import-Clixml -Path $JobFilePath
            Write-PSChiaPlotterLog -LogType "INFO" -Message "Imported Job"

            $newSavedJob = [PSChiaPlotter.ChiaJob]::new()
            $newSavedJob.JobNumber = $jobNumber
            $newSavedJob.Status = "Waiting"
            $NewSavedJobViewModel = [PSChiaPlotter.NewJobViewModel]::new($newSavedJob)

            $SkipJobProperties = @("InitialChiaParameters","Queues","RunsInProgress","TempVolumes","FinalVolumes")
            $JobProperties = ($ImportedJob.NewChiaJob | Get-Member -MemberType Property).Name
            $JobProperties = $JobProperties | where {$_ -notin $SkipJobProperties}
            foreach ($property in $JobProperties){
                try{
                    $NewSavedJobViewModel.NewChiaJob.$property = $ImportedJob.NewChiaJob.$property
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            }

            $SkipParameterProperties = @("SecondTempVolume","KSize","BasicFinalDirectory","BasicTempDirectory")
            $ParameterProperties = ($ImportedJob.NewChiaJob.InitialChiaParameters | Get-Member -MemberType Property).Name
            $ParameterProperties = $ParameterProperties | where {$_ -notin $SkipParameterProperties}
            foreach ($property in $ParameterProperties){
                try{
                    $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.$property = $ImportedJob.NewChiaJob.InitialChiaParameters.$property
                }
                catch{
                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                }
            }

            $NewSavedJobViewModel.NewChiaJob.JobNumber = $jobNumber
            $NewSavedJobViewModel.NewChiaJob.Status = "Waiting"
            $NewSavedJobViewModel.NewChiaJob.StartTime = Get-Date

            Get-ChiaVolume | foreach {
                $NewSavedJobViewModel.FinalAvailableVolumes.Add($_)
            }
            $NewSavedJobViewModel.FinalAvailableVolumes | foreach {
                $NewSavedJobViewModel.SecondTempVolumes.Add([PSChiaPlotter.ChiaVolume]::new($_))
                $NewSavedJobViewModel.TempAvailableVolumes.Add([PSChiaPlotter.ChiaVolume]::new($_))
            }

            #need to update directory paths for each volume...
            $NewSavedJobViewModel.TempAvailableVolumes | foreach {
                $FoundVolume = $ImportedJob.TempAvailableVolumes | where UniqueId -eq $_.UniqueId
                if ($FoundVolume -ne $Null){
                    $_.DirectoryPath = $FoundVolume.DirectoryPath
                }
                else{
                    $FoundVolume = $ImportedJob.NewChiaJob.TempVolumes | where UniqueId -eq $_.UniqueId
                    if ($FoundVolume -ne $Null){
                        $_.DirectoryPath = $FoundVolume.DirectoryPath
                    }
                }
                $FoundVolume = $Null
            }
            $NewSavedJobViewModel.FinalAvailableVolumes | foreach {
                $FoundVolume = $ImportedJob.FinalAvailableVolumes | where UniqueId -eq $_.UniqueId
                if ($FoundVolume -ne $Null){
                    $_.DirectoryPath = $FoundVolume.DirectoryPath
                }
                else{
                    $FoundVolume = $ImportedJob.NewChiaJob.FinalVolumes | where UniqueId -eq $_.UniqueId
                    if ($FoundVolume -ne $Null){
                        $_.DirectoryPath = $FoundVolume.DirectoryPath
                    }
                }
                $FoundVolume = $Null
            }
            $NewSavedJobViewModel.SecondTempVolumes | foreach {
                $FoundVolume = $ImportedJob.SecondTempVolumes | where UniqueId -eq $_.UniqueId
                if ($FoundVolume -ne $Null){
                    $_.DirectoryPath = $FoundVolume.DirectoryPath
                }
                $FoundVolume = $Null
            }

            #Basic Volumes
            $FinalDirString = [string]$ImportedJob.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.DirectoryPath
            $TempDirString = [string]$ImportedJob.NewChiaJob.InitialChiaParameters.BasicTempDirectory.DirectoryPath
            $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory = [PSChiaPlotter.ChiaVolume]::new($FinalDirString)
            $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.ReplotEnabled = $ImportedJob.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.ReplotEnabled
            $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicTempDirectory = [PSChiaPlotter.ChiaVolume]::new($TempDirString)

            if ($ImportedJob.NewChiaJob.InitialChiaParameters.ReplotEnabled){
                foreach ($replotVolume in $ImportedJob.NewChiaJob.FinalVolumes){
                    $FoundFinalVolume = $Null
                    $FoundFinalVolume = $NewSavedJobViewModel.FinalAvailableVolumes | where UniqueId -eq $replotVolume.UniqueId
                    if ($null -ne $FoundFinalVolume){
                        foreach ($oldplotdirectory in $replotVolume.OldPlotDirectories){
                            try{
                                $totaloldplots = (Get-ChildItem -Path $oldplotdirectory.Path -Filter "plot-k$($oldplotdirectory.KSizeValue)*.plot" | Measure-Object).Count
                                $oldplot = [PSChiaPlotter.OldPlotDirectory]::New($oldplotdirectory.Path,$totaloldplots,$oldplotdirectory.KSizeValue)
                                $FoundFinalVolume.OldPlotDirectories.Add($oldplot)
                            }
                            catch{
                                Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                            }
                        }
                    }
                    else{
                        $FoundFinalVolume = $NewSavedJobViewModel.FinalVolumes | where UniqueId -eq $replotVolume.UniqueId
                        if ($null -ne $FoundFinalVolume){
                            foreach ($oldplotdirectory in $replotVolume.OldPlotDirectories){
                                try{
                                    $totaloldplots = (Get-ChildItem -Path $oldplotdirectory.Path -Filter "plot-k$($oldplotdirectory.KSizeValue)*.plot" | Measure-Object).Count
                                    $oldplot = [PSChiaPlotter.OldPlotDirectory]::New($oldplotdirectory.Path,$totaloldplots,$oldplotdirectory.KSizeValue)
                                    $FoundFinalVolume.OldPlotDirectories.Add($oldplot)
                                }
                                catch{
                                    Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                                }
                            }
                        }
                    }
                    $FoundFinalVolume.TotalReplotCount = ($FoundFinalVolume.OldPlotDirectories | Measure-Object -Property PlotCount -Sum).Sum
                } #foreach final volume

                foreach ($oldplotdirectory in $ImportedJob.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.OldPlotDirectories){
                    try{
                        $totaloldplots = (Get-ChildItem -Path $oldplotdirectory.Path -Filter "plot-k$($oldplotdirectory.KSizeValue)*.plot" | Measure-Object).Count
                        $oldplot = [PSChiaPlotter.OldPlotDirectory]::New($oldplotdirectory.Path,$totaloldplots,$oldplotdirectory.KSizeValue)
                        $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.OldPlotDirectories.Add($oldplot)
                    }
                    catch{
                        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
                    }
                }
                $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.TotalReplotCount = ($NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.OldPlotDirectories | Measure-Object -Property PlotCount -Sum).Sum
            }

            $NewSavedJobViewModel.AvailableKSizes = $DataHash.NewJobViewModel.AvailableKSizes

            $SecondTempVolume = $NewSavedJobViewModel.SecondTempVolumes | where UniqueId -eq $ImportedJob.NewChiaJob.InitialChiaParameters.SecondTempVolume.UniqueId
            $NewSavedJobViewModel.NewChiaJob.InitialChiaParameters.SecondTempVolume = $SecondTempVolume

            foreach ($Volume in $ImportedJob.NewChiaJob.TempVolumes){
                $FoundTempVolume = $NewSavedJobViewModel.TempAvailableVolumes | where UniqueId -eq $Volume.UniqueId
                if ($FoundTempVolume){
                    $NewSavedJobViewModel.AddTempVolume($FoundTempVolume)
                }
                $FoundTempVolume = $null
            }
            $Volume = $null
            foreach ($Volume in $ImportedJob.NewChiaJob.FinalVolumes){
                $FoundFinalVolume = $NewSavedJobViewModel.FinalAvailableVolumes | where UniqueId -eq $Volume.UniqueId
                if ($FoundFinalVolume){
                    $NewSavedJobViewModel.AddFinalVolume($FoundFinalVolume)
                    if ($volume.ReplotEnabled){
                        $FoundFinalVolume.ReplotEnabled = $true
                    }
                }
                $FoundFinalVolume = $null
            }

            $DataHash.NewJobViewModel = $NewSavedJobViewModel
            $UIHash.NewJob_Window.DataContext = $NewSavedJobViewModel

            #Combobox wouldn't automatically update for some reason
            switch ($ImportedJob.NewChiaJob.InitialChiaParameters.KSize.KSizeValue){
                25 {$Index = 0;break}
                32 {$Index = 1;break}
                33 {$Index = 2;break}
                34 {$Index = 3;break}
                35 {$Index = 4;break}
                default {$Index = 1}
            }
            $UIHash.KSize_ComboBox.SelectedIndex = $Index
            $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize = $UIHash.KSize_ComboBox.SelectedItem
            $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.RAM = $ImportedJob.NewChiaJob.InitialChiaParameters.RAM

            if ($DataHash.NewJobViewModel.NewChiaJob.BasicPlotting){
                $AdvancedBasic_Button.Content = "Switch To Advance"
                $AdvancedPlotting_TabControl.Visibility = [System.Windows.Visibility]::Collapsed
                $BasicPlotting_Grid.Visibility = [System.Windows.Visibility]::Visible
            }
            else{
                $AdvancedBasic_Button.Content = "Switch To Basic"
                $BasicPlotting_Grid.Visibility = [System.Windows.Visibility]::Collapsed
                $AdvancedPlotting_TabControl.Visibility = [System.Windows.Visibility]::Visible
            }
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
        Show-MessageBox -Text "Unable to laod previous job :( Check logs for more info"
    }
}
function Invoke-NewJobButtonClick {
    [CmdletBinding()]
    param()

    try{
        $SavedJobsPath = Join-Path -Path $ENV:LOCALAPPDATA -ChildPath 'PSChiaPlotter\SavedJobs'
        $SavedJobsList = New-Object -TypeName System.Collections.Generic.List[Object]
        if ([System.IO.Directory]::Exists($SavedJobsPath)){
            Get-ChildItem -Path $SavedJobsPath | foreach {
                try{
                    $savedjob = [pscustomobject]@{
                        Name = $_.BaseName
                        FullName = $_.FullName
                    }
                    $SavedJobsList.Add($savedjob)
                }
                catch{
                    Write-Error -LogType "Error" -ErrorObject $_
                }
            }
        }

        $XAMLPath = Join-Path -Path $DataHash.WPF -ChildPath NewJobWindow.xaml
        $UIHash.NewJob_Window = Import-Xaml -Path $XAMLPath
        $jobNumber = $DataHash.MainViewModel.AllJobs.Count + 1

        $newJob = [PSChiaPlotter.ChiaJob]::new()
        $newJob.JobNumber = $jobNumber
        $newJob.JobName = "Job $jobNumber"
        $newJob.Status = "Waiting"
        $NewJobViewModel = [PSChiaPlotter.NewJobViewModel]::new($newJob)
        $DataHash.NewJobViewModel = $NewJobViewModel
        $UIHash.NewJob_Window.DataContext = $NewJobViewModel

        #Combobox
        $UIHash.KSize_ComboBox = $UIHash.NewJob_Window.FindName("KSize_ComboBox")
        $UIHash.KSize_ComboBox.SelectedIndex = 1

        $SavedJobs_ComboBox = $UIHash.NewJob_Window.FindName("SavedJobs_Combobox")
        $SavedJobs_ComboBox.ItemsSource = $SavedJobsList

        #Buttons
        $AdvancedBasic_Button = $UIHash.NewJob_Window.FindName("AdvancedBasic_Button")
        $LoadJob_Button = $UIHash.NewJob_Window.FindName("LoadJob_Button")
        $CreateJob_Button = $UIHash.NewJob_Window.FindName("CreateJob_Button")
        $CancelJobCreation_Button = $UIHash.NewJob_Window.FindName("CancelJobCreation_Button")
        $SaveJob_Button = $UIHash.NewJob_Window.FindName("SaveJob_Button")
        $ClearTempVolume_Button = $UIHash.NewJob_Window.FindName("RemoveTempVolumeButton")
        $ReplotConfig_Button = $UIHash.NewJob_Window.FindName("ReplotButton")
        $BasicReplot_Button = $UIHash.NewJob_Window.FindName("BasicReplot_Button")

        #TabControl
        $AdvancedPlotting_TabControl = $UIHash.NewJob_Window.FindName("AdvancedPlotting_TabControl")
        
        #Grid
        $BasicPlotting_Grid = $UIHash.NewJob_Window.FindName("BasicPlotting_Grid")

        #need to run get-chiavolume twice or the temp and final drives will be the same object in the application and will update each other...
        Get-ChiaVolume | foreach {
            $NewJobViewModel.FinalAvailableVolumes.Add($_)
        }
        $NewJobViewModel.FinalAvailableVolumes | foreach {
            $NewJobViewModel.SecondTempVolumes.Add([PSChiaPlotter.ChiaVolume]::new($_))
            $NewJobViewModel.TempAvailableVolumes.Add([PSChiaPlotter.ChiaVolume]::new($_))
        }

        $AdvancedBasic_Button.Add_Click({
            try{
                if ($AdvancedBasic_Button.Content -eq "Switch To Basic"){
                    $AdvancedBasic_Button.Content = "Switch To Advance"
                    $DataHash.NewJobViewModel.NewChiaJob.BasicPlotting = $true
                    $AdvancedPlotting_TabControl.Visibility = [System.Windows.Visibility]::Collapsed
                    $BasicPlotting_Grid.Visibility = [System.Windows.Visibility]::Visible
                }
                else{
                    $AdvancedBasic_Button.Content = "Switch To Basic"
                    $DataHash.NewJobViewModel.NewChiaJob.BasicPlotting = $false
                    $BasicPlotting_Grid.Visibility = [System.Windows.Visibility]::Collapsed
                    $AdvancedPlotting_TabControl.Visibility = [System.Windows.Visibility]::Visible
                }
            }
            catch{
                Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
            }
        })

        $LoadJob_Button.Add_Click({
            try{
                Invoke-LoadJobButtonClick
            }
            catch{
                Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
            }
        })

       $UIHash.KSize_ComboBox.Add_SelectionChanged({
            try{
                $KSizeTempSize = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize.TempSize
                $KSizeFinalSize = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize.FinalSize
                $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.RAM = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize.MinRAM
                foreach ($volume in $DataHash.NewJobViewModel.TempAvailableVolumes){
                    $max = [math]::Floor([decimal]($volume.size / $KSizeTempSize))
                    $volume.MaxConCurrentTempChiaRuns = $max
                }
                foreach ($volume in $DataHash.NewJobViewModel.NewChiaJob.TempVolumes){
                    $max = [math]::Floor([decimal]($volume.size / $KSizeTempSize))
                    $volume.MaxConCurrentTempChiaRuns = $max
                }

                foreach ($volume in $DataHash.NewJobViewModel.FinalAvailableVolumes){
                    $max = [math]::Floor([decimal]($volume.FreeSpace / $KSizeFinalSize))
                    $volume.PotentialFinalPlotsRemaining = $max
                }
                foreach ($volume in $DataHash.NewJobViewModel.NewChiaJob.FinalVolumes){
                    $max = [math]::Floor([decimal]($volume.FreeSpace / $KSizeFinalSize))
                    $volume.PotentialFinalPlotsRemaining = $max
                }

                foreach ($volume in $DataHash.NewJobViewModel.SecondTempVolumes){
                    $max = [math]::Floor([decimal]($volume.size / $KSizeTempSize))
                    $volume.MaxConCurrentTempChiaRuns = $max
                }
            }
            catch{
                Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
            }
        })

        $CreateJob_Button.add_Click({
            try{
                if ($DataHash.NewJobViewModel.NewChiaJob.DelayInMinutes -eq 60){
                    $response = Show-Messagebox -Text "You left the default delay time of 60 Minutes, continue?" -Button YesNo
                    if ($response -eq [System.Windows.MessageBoxResult]::No){
                        return
                    }
                }
                if ($DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.KSize.KSizeValue -eq 25){
                    $response = Show-Messagebox -Text "KSize 25 is only for testing and cannot farm XCH, continue?" -Button YesNo -Icon Warning
                    if ($response -eq [System.Windows.MessageBoxResult]::No){
                        return
                    }
                }

                if ($DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.PlotWhileCopy -and $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.AlternativePlotterEnabled -eq $false){
                    $Response = Show-MessageBox -Text "I advise to check 'Exclude Final Directory' when using 'Plot While Copy'. This is because the OG chia plotter will add the temp directory to your farming directories instead of the final directory`n`nDo you want to continue and start the job?" -Icon Warning -Buttons YesNo
                    if ($Response -eq [System.Windows.MessageBoxResult]::No){
                        return
                    }
                }

                $Results = Test-ChiaParameters $DataHash.NewJobViewModel.NewChiaJob
                if ($Results -ne $true){
                    Show-Messagebox -Text $Results -Title "Invalid Parameters" -Icon Warning
                    return
                }

                $Results = Test-ReplotParameters
                if ($Results -ne $true){
                    Show-Messagebox -Text $Results -Title "Invalid Replot Parameters" -Icon Warning
                    return
                }

                $Results = Test-AlternativePlotterParameters
                if ($Results -ne $true){
                    Show-Messagebox -Text $Results -Title "Invalid Replot Parameters" -Icon Warning
                    return
                }

                $DataHash.MainViewModel.AllJobs.Add($DataHash.NewJobViewModel.NewChiaJob)
                $newJobRunSpace = New-ChiaJobRunspace -Job $DataHash.NewJobViewModel.NewChiaJob
                $newJobRunSpace.Runspacepool = $ScriptsHash.RunspacePool
                [void]$newJobRunSpace.BeginInvoke()
                $DataHash.Runspaces.Add($newJobRunSpace)
                $UIHash.NewJob_Window.Close()
            }
            catch{
                Write-PSChiaPlotterLog -LogType "ERROR" -ErrorObject $_
                Show-Messagebox -Text $_.Exception.Message -Title "Create New Job Error" -Icon Error
            }
        })

        $CancelJobCreation_Button.Add_Click({
            try{
                $UIHash.NewJob_Window.Close()
            }
            catch{
                Show-Messagebox -Text $_.Exception.Message -Title "Exit New Job Window Error" -Icon Error
            }
        })

        $SaveJob_Button.Add_Click({
            try{
                $PSChiaPlotterFolderPath = Join-Path -Path $ENV:LOCALAPPDATA -ChildPath 'PSChiaPlotter\SavedJobs'
                if (-not[System.IO.Directory]::Exists($PSChiaPlotterFolderPath)){
                    New-Item -Path $PSChiaPlotterFolderPath -ItemType Directory | Out-Null
                }
                if ([string]::IsNullOrWhiteSpace($DataHash.NewJobViewModel.NewChiaJob.JobName)){
                    Show-Messagebox -Text "Please give your a job a name first" | Out-Null
                    return
                }
                $SaveJobPath = Join-Path -Path $PSChiaPlotterFolderPath -ChildPath "$($DataHash.NewJobViewModel.NewChiaJob.JobName).xml"
                if (Test-Path $SaveJobPath){
                    $Response = Show-MessageBox -Text "Job $($DataHash.NewJobViewModel.NewChiaJob.JobName) already exists, would you like to overwrite it?" -Buttons YesNo
                    if ($Response -eq [System.Windows.MessageBoxResult]::Yes){
                        $DataHash.NewJobViewModel | Export-Clixml -Path $SaveJobPath -Depth 10 -Force
                        Show-MessageBox "$($DataHash.NewJobViewModel.NewChiaJob.JobName) job saved to $PSChiaPlotterFolderPath"
                        return
                    }
                    else {
                        return
                    }
                }
                $DataHash.NewJobViewModel | Export-Clixml -Path $SaveJobPath -Depth 10
                Show-MessageBox "$($DataHash.NewJobViewModel.NewChiaJob.JobName) job saved to $PSChiaPlotterFolderPath"
            }
            catch{
                Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
            }
        })

        $ClearTempVolume_Button.Add_Click({
            try{
                $tempVolume = $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.SecondTempVolume
                if ($tempVolume -ne $Null){
                    Write-PSChiaPlotterLog -LogType "INFO" -Message "Clearing Temp Volume Selection"
                    $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.SecondTempVolume = $null
                }
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })

        $ReplotConfig_Button.Add_Click({
            try{
                Invoke-OpenReplotConfigButtonClick
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                Show-MessageBox -Text $_.Exception.Message -Icon Error -Title "Open Replot Config Error"
            }
        })

        $BasicReplot_Button.Add_Click({
            try{
                Invoke-OpenReplotConfigButtonClick
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
                Show-MessageBox -Text $_.Exception.Message -Icon Error -Title "Open Replot Config Error"
            }
        })

        $UIHash.NewJob_Window.ShowDialog()
    }
    catch{
        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        Show-Messagebox -Text $_.Exception.Message -Title "Create New Job Error" -Icon Error
    }
}
function Invoke-OpenReplotConfigButtonClick {
    [CmdletBinding()]
    param()

    try{
        $XAMLPath = Join-Path -Path $DataHash.WPF -ChildPath "ReplotConfigWindow.xaml"
        $ReplotConfig_Window = Import-Xaml -Path $XAMLPath

        $FinalVolume_DataGrid = $ReplotConfig_Window.FindName("FinalVolume_DataGrid")

        if ($DataHash.NewJobViewModel.NewChiaJob.BasicPlotting){
            if ([string]::IsNullOrEmpty($DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.DirectoryPath)){
                [void](Show-MessageBox -Text "Please give a valid final directory path first!" -Icon Warning)
                return
            }
            $DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory.ReplotEnabled = $true
            $BasicVolumeList = New-Object -TypeName System.Collections.Generic.List[PSChiaPlotter.ChiaVolume]
            $BasicVolumeList.Add($DataHash.NewJobViewModel.NewChiaJob.InitialChiaParameters.BasicFinalDirectory)
            $FinalVolume_DataGrid.ItemsSource = $BasicVolumeList
        }
        else{
            $DataHash.NewJobViewModel.NewChiaJob.FinalVolumes | foreach {
                $_.ReplotEnabled = $true
                $FinalVolume_DataGrid.ItemsSource = $DataHash.NewJobViewModel.NewChiaJob.FinalVolumes
            }
        }

        $AddOldPlot_Grid = $ReplotConfig_Window.FindName("AddOldPlot_Grid")
        $OldPlotDirectory_Textbox = $ReplotConfig_Window.FindName("OldPlotDirectory_Textbox")
        $OldDirectories_ListBox = $ReplotConfig_Window.FindName("OldDirectories_ListBox")

        #Button
        $AddOldPlotDirectory_Button = $ReplotConfig_Window.FindName("AddOldPlotDirectory_Button")
        $ConfirmReplot_Button = $ReplotConfig_Window.FindName("ConfirmReplot_Button")
        $CancelReplot_Button = $ReplotConfig_Window.FindName("CancelReplot_Button")
        $HelpReplot_Button = $ReplotConfig_Window.FindName("HelpReplot_Button")

        $FinalVolume_DataGrid.Add_SelectionChanged({
            try{
                Invoke-ReplotVolumeSelectionChange
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })

        $AddOldPlotDirectory_Button.Add_Click({
            try{
                $PathToAdd = Invoke-AddOldPlotDirectoryButtonClick -Path $OldPlotDirectory_Textbox.Text
                if ($null -ne $PathToAdd){
                    $OldDirectories_ListBox.DataContext.OldPlotDirectories.Add($PathToAdd)
                    $OldPlotDirectory_Textbox.Text = $OldDirectories_ListBox.DataContext.DirectoryPath
                    $OldDirectories_ListBox.DataContext.TotalReplotCount = ($OldDirectories_ListBox.DataContext.OldPlotDirectories | Measure-Object -Property PlotCount -Sum).Sum
                }
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })

        $ConfirmReplot_Button.Add_Click({
            try{
                $Results = Test-ReplotParameters
                if ($Results -ne $true){
                    Show-Messagebox -Text $Results -Title "Invalid Replot Parameters" -Icon Warning
                    return
                }
                $ReplotConfig_Window.Close()
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })
        
        $CancelReplot_Button.Add_Click({
            try{
                Invoke-CancelReplotButtonClick
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })

        $HelpReplot_Button.Add_Click({
            try{
                Invoke-HelpReplotButtonClick
            }
            catch{
                Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
            }
        })

        $ReplotConfig_Window.ShowDialog()
    }
    catch{
        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
        Show-MessageBox -Text $_.Exception.Message -Icon Error -Title "Open Replot Config Error"
    }
}
function Invoke-PauseAllQueuesButtonClick {
    [CmdletBinding()]
    param()

    try{
        $Message = "Pausing Queues does not end the current running chia process."
        $message += " It will only prevent new processes from starting."
        $message += "`n`nAre you sure you want to pause all queues?"
        $Response = Show-MessageBox -Text $message -Buttons YesNo -Icon Information
        if ($Response -eq [System.Windows.MessageBoxResult]::Yes){
            $AllCurrentQueues = $DataHash.MainViewModel.AllQueues | where {$_.Status -eq "Running" -or $_.Status -eq "Waiting"}
            foreach ($queue in $AllCurrentQueues){
                $Queue.PauseResumeQueue()
            }
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
    }
}
function Invoke-PauseQueueButtonClick{
    [CmdletBinding()]
    param()

    try{
        $SelectedQueue = $UIHash.Queues_DataGrid.SelectedItem
        $Pauseable = $SelectedQueue.Status -eq "Running" -or $SelectedQueue.Status -eq "Waiting" -or $SelectedQueue.Pause
        if ($SelectedQueue -ne $Null){
            if ($Pauseable){
                $SelectedQueue.PauseResumeQueue()
                $UIHash.PauseQueue_Button.Content = $SelectedQueue.ButtonContent
            }
            else{
                Show-MessageBox -Text "Only Queues that are currenting running or waiting can be paused" -Icon Warnin
            }
        }
        else{
            Show-MessageBox -Text "No Queue was selected!" -Icon Warning
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
        Show-MessageBox -Text "Unable To Pause Queue! Check logs for more info" -Icon Error
    }
}
function Invoke-QuitJobButtonClick{
    [CmdletBinding()]
    param()

    try{
        $SelectedJob = $Null
        $SelectedJob = $UIHash.Jobs_DataGrid.SelectedItem
        if ($SelectedJob){
            if ($SelectedJob.Status -eq "Completed" -or $SelectedJob.Status -eq "Quitting"){
                Show-MessageBox -Text "This Job is either completed or in the process of quitting" -Icon Information
                return
            }
            $Message = "Are you sure you want to quit job - $($SelectedJob.JobName)?"
            $Message += "`nAll running chia processes under this job will be cancelled!"
            $Response = Show-MessageBox -Text $Message -Buttons YesNo
            if ($Response -eq [System.Windows.MessageBoxResult]::Yes){
                $runningQueues = $SelectedJob.Queues | where Status -ne "Finished" | where Status -ne "Failed"
                foreach ($queue in $runningQueues){
                    $queue.Quit = $true
                    $queue.Status = "Quitting"
                }
                foreach ($run in $SelectedJob.RunsInProgress){
                    $run.ChiaProcess.Kill()
                }
                $SelectedJob.Status = "Completed"
            }
        }
        else{
            Show-MessageBox -Text "No Job Selected!" -Icon Warning
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
    }
}
function Invoke-QuitQueueButtonClick{
    [CmdletBinding()]
    param()

    try{
        $SelectedQueue = $UIHash.Queues_DataGrid.SelectedItem
        if ($SelectedQueue){
            if ($SelectedQueue.Status -ne "Finished"){
                $SelectedQueue.QuitQueue()
                $UIHash.QuitQueue_Button.IsEnabled = $false
                $UIHash.PauseQueue_Button.IsEnabled = $false
            }
            else{
                Show-MessageBox -Text "Queue has already Finished!" -Icon Information
            }
        }
        else{
            Show-MessageBox -Text "No Queue was selected!" -Icon Warning
        }
    }
    catch{
        Show-MessageBox -Text "Unable To Quit Queue. Check logs for more info!" -Icon Error
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
    }
}
function Invoke-RemovePlotLogDirectoryButtonClick {
    [CmdletBinding()]
    param()

    try{
        if ($null -ne $UIHash.PlotLog_ListBox.SelectedItem){
            $SelectedPath = $UIHash.PlotLog_ListBox.SelectedItem
            $DataHash.MainViewModel.PlotLogDirectoryPaths.Remove($UIHash.PlotLog_ListBox.SelectedItem)
            $RemoveItems = $DataHash.MainViewModel.AllPlottingLogStats | where ParentFolder -eq $SelectedPath
            foreach ($removelogstat in $RemoveItems){
                $DataHash.MainViewModel.AllPlottingLogStats.Remove($removelogstat)
            }
        }
        else{
            [void](Show-MessageBox -Text "Please select a directory to remove" -Icon Warning)
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType Error -ErrorObject $_
        [void](Show-MessageBox -Text $_.Exception.Message -Title "Remove Directory Error" -Icon Error)
    }
}
function Invoke-QueueSelectionChange{
    [CmdletBinding()]
    param()

    try{
        $SelectedQueue = $UIHash.Queues_DataGrid.SelectedItem
        if ($SelectedQueue){
            $UIHash.PauseQueue_Button.Content = $SelectedQueue.ButtonContent
            $UIHash.PauseQueue_Button.IsEnabled = $SelectedQueue.ButtonEnabled
            $UIHash.QuitQueue_Button.IsEnabled = $SelectedQueue.QuitButtonEnabled
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType "Error" -ErrorObject $_
    }
}
function Invoke-ReplotVolumeSelectionChange {
    [CmdletBinding()]
    param()

    try{
        $SelectedVolume = $FinalVolume_DataGrid.SelectedItem
        if ($SelectedVolume){
            $AddOldPlot_Grid.DataContext = $SelectedVolume
            $AddOldPlot_Grid.IsEnabled = $true
            $OldPlotDirectory_Textbox.Text = $SelectedVolume.DirectoryPath
        }
        else{
            $AddOldPlot_Grid.IsEnabled = $false
            $AddOldPlot_Grid.DataContext = $null
        }
    }
    catch{
        Write-PSChiaPlotterLog -LogType ERROR -ErrorObject $_
    }
}
Export-ModuleMember -function ConvertTo-FriendlyTimeSpan, Get-ChiaHarvesterActivity, Get-ChiaKPlotCombination, Get-ChiaMaxParallelCount, Get-ChiaPlotProgress, Get-ChiaPlottingStatistic, Get-ChiaProcessCounter, Get-ChiaRAMInfo, New-TestPlotWatcher, Show-ChiaPlottingStatistic, Show-PSChiaPlotter, Start-ChiaHarvesterWatcher, Start-ChiaParallelPlotting, Start-ChiaPlotting, Test-ChiaPlot, Test-ChiaPlotParallel