# This file inherits the licencing from the batch file (smalltalk.bat). (MIT)

# $executable        ... stx.com or .exe

# $log_file          ... log file name with path

# $log_file_encoding ... user defined encoding

# $append_to_log     ... should the log file be appended? (TRUE/FALSE)

# $cmd_close         ... sends either cmd /u /c (close cmd) or /u /k (cmd remains open)

# $PowerShellVersion ... detected powershell version

# $cmd_in_powershell ... should cmd.exe be used for stdout redirection? (TRUE/FALSE)

param($executable, $log_file, $log_file_encoding, $append_to_log, $cmd_close, $PowerShellVersion, $cmd_in_powershell, $stx_manual_switch_detected)

# ===========================================================================

# Reading directly from environment - due to the issues with passing quotes =

# ===========================================================================

# StX switches which are build during batch file execution $env:stx_switch

$stx_switch = [environment]::GetEnvironmentVariable("stx_switch")

# PowerShell version detected during batch file execution  $env:powershell_version_all_functionality

If (![String]::IsNullOrEmpty([environment]::GetEnvironmentVariable("powershell_version_all_functionality"))) {

    $stx_powershell_version = [environment]::GetEnvironmentVariable("powershell_version_all_functionality")

} Else {

    $host.ui.WriteErrorLine('[ERROR] Missing powershell detection variable -> powershell_version_all_functionality <-.')

    EXIT 1

}

# getting line width for the log file

If (![String]::IsNullOrEmpty([environment]::GetEnvironmentVariable("stx.__numeric.log_file_width"))) {

    $log_file_width = [environment]::GetEnvironmentVariable("stx.__numeric.log_file_width")

} Else {

    $host.ui.WriteErrorLine('[ERROR] Missing -> stx.__numeric.log_file_width <- from smalltalk.cfg file.')

    EXIT 1

}

# Defines start-sleep periods while running custom switches

If (![String]::IsNullOrEmpty([environment]::GetEnvironmentVariable("stx.__numeric.start_sleep_in_debug"))) {

    $start_sleep_period = [environment]::GetEnvironmentVariable("stx.__numeric.start_sleep_in_debug")

} Else {

    $host.ui.WriteErrorLine('[ERROR] Missing -> stx.__numeric.start_sleep_in_debug <- from smalltalk.cfg file.')

    EXIT 1

}

# =======================================================

# Adjust all variables to PowerShell style $true/$false =

# =======================================================

If ([environment]::GetEnvironmentVariable("stx.__binary.colored_stdout") -eq 'TRUE') {

    $use_color = $true

} Else {

    $use_color = $false

}

If ($cmd_in_powershell -eq 'TRUE') {

    $cmd_in_powershell = $true

} Else {

    $cmd_in_powershell = $false

}

If ($append_to_log -eq 'TRUE') {

    $append_to_log = $true

} Else {

    $append_to_log = $false

}

If ($stx_manual_switch_detected -eq 'TRUE') {

    $stx_manual_switch_detected = $true

} Else {

    $stx_manual_switch_detected = $false

}

If ($use_color) {

    # fastest way to init empty Hastable

    $saved_color = [System.Collections.Hashtable]@{}

    # save colors for later restore

    $window_private_data = (Get-Host).PrivateData

    $saved_color.Add('VerboseBackgroundColor', "$window_private_data.VerboseBackgroundColor") | Out-null; # Out-null for supressing the natural output

    $saved_color.Add('VerboseForegroundColor', "$window_private_data.VerboseForegroundColor") | Out-null

    $saved_color.Add('WarningBackgroundColor', "$window_private_data.WarningBackgroundColor") | Out-null

    $saved_color.Add('WarningForegroundColor', "$window_private_data.WarningForegroundColor") | Out-null

    $saved_color.Add('ErrorBackgroundColor', "$window_private_data.ErrorBackgroundColor") | Out-null

    $saved_color.Add('ErrorForegroundColor', "$window_private_data.ErrorForegroundColor") | Out-null

    #setting the user specified colors

    $window_private_data.VerboseBackgroundColor = [environment]::GetEnvironmentVariable("stx.stdout_VerboseBackgroundColor")

    $window_private_data.VerboseForegroundColor = [environment]::GetEnvironmentVariable("stx.stdout_VerboseForegroundColor")

    $window_private_data.WarningBackgroundColor = [environment]::GetEnvironmentVariable("stx.stdout_WarningBackgroundColor")

    $window_private_data.WarningForegroundColor = [environment]::GetEnvironmentVariable("stx.stdout_WarningForegroundColor")

    $window_private_data.ErrorBackgroundColor = [environment]::GetEnvironmentVariable("stx.stdout_ErrorBackgroundColor")

    $window_private_data.ErrorForegroundColor = [environment]::GetEnvironmentVariable("stx.stdout_ErrorForegroundColor")

} ElseIf ($cmd_in_powershell) {

    $window_private_data = (Get-Host).PrivateData

    $window_private_data.VerboseBackgroundColor = 'Black'

    $window_private_data.VerboseForegroundColor = 'Gray'

}

# ===========

# Functions =

# ===========

# Function for correct $LASTEXITCODE to ERRORLEVEL passing

function ExitWithCode {

    param (

        $exitcode

    )

    $host.SetShouldExit($exitcode)

    EXIT

} # end ExitWithCode

# To correctly write to stderr when launching from cmd.exe

# more at: https://stackoverflow.com/questions/4998173/how-do-i-write-to-standard-error-in-powershell/15669365#15669365

<#

 .SYNOPSIS

 Writes text to stderr when running in a regular console window,

 to the host''s error stream otherwise.

 .DESCRIPTION

 Writing to true stderr allows you to write a well-behaved CLI

 as a PS script that can be invoked from a batch file, for instance.

 Note that PS by default sends ALL its streams to *stdout* when invoked from 

 cmd.exe.

 This function acts similarly to Write-Host in that it simply calls

 .ToString() on its input; to get the default output format, invoke

 it via a pipeline and precede with Out-String.

#> 

# function Write-StdErr {

#     param (

#         [PSObject] $input_object

#     )

#     $out_function = If ($Host.Name -eq 'ConsoleHost') { 

#         [Console]::Error.WriteLine

#     } Else {

#         $host.ui.WriteErrorLine

#     }

#     If ($input_object) {

#         [void] $out_function.Invoke($input_object.ToString())

#     } Else {

#         [string[]] $lines = @()

#         $Input | % { $lines += $_.ToString() }

#         [void] $out_function.Invoke($lines -join "`r`n")

#     }

# }

# Print User message using String Array $message

function PrintMessage {

    param(

        [Parameter( `

            Mandatory=$True, `

            Valuefrompipeline = $true)]

        [String]$message

    )

    begin {}

    process {

        foreach ($Message in $Message) {

            # Write-Host Considered Harmful - see http://www.jsnover.com/blog/2013/12/07/write-host-considered-harmful/

            # first way how to correctly write it

            #Write-host $message

            # highlights warning and error messages from StX VM!

            If ($line -match '\[error\]' -or $line -match '\[sigsegv\]') {

                $host.ui.WriteErrorLine("$message")

            } ElseIf ($message -match '\[warn\]') {

                Write-Warning $message

            } Else {

                Write-Verbose -Message $message -Verbose

            } 

        }

    }

    end {}

} # end PrintMessage

# To correctly simultinously write to stdout and log file when using out-file!

# Colors the output based on string match

function Tee-Host {

    Param (

        [Parameter(Mandatory=$true,

        ValueFromPipeline=$true,

        Position=0)]

        $message

    )

    begin {}

    Process {

        # first way how to correctly write it

        # -EV is short (an alias) for -ErrorVariable

        If ($line -match '\[error\]' -or $line -match '\[sigsegv\]') {

            # this is printing error compatible with all PS versions

            $host.ui.WriteErrorLine("$message")

        } ElseIf ($message -match '\[warning\]') {

            Write-Warning "$message"

        } Else {

            Write-Verbose -Message "$message" -Verbose

        }

        # second correct way how to write it

        #$VerbosePreference = "Continue"

        #Write-Verbose $input_object; 

        return $message

    }

    end {}

} # end Tee-Host

# Synchronously (stdout & stderr) executes Smalltalk/X executable 

# stdout & stderr are redirected together via 2>&1 redirect

function InvokeCommandExecute {

    param(

       $execute_command

    )

    try {

       "`n", "[INFO] Executing command: $execute_command" | PrintMessage

       Invoke-Expression -Command:$execute_command

       If ($lastexitcode -ne 0) {

           $result = $result -join "`n"

           throw "$result `n"

       }

    }

    catch {

        $window_private_data = (Get-Host).PrivateData

        # saving the original colors

        $saved_background_color = $window_private_data.ErrorBackgroundColor

        $saved_foreground_color = $window_private_data.ErrorForegroundColor

        # setting the new colors

        $window_private_data.ErrorBackgroundColor = 'White'

        $window_private_data.ErrorForegroundColor = 'Red'

        $host.ui.WriteErrorLine("[ERROR] happned in stx.com or PowerShell script - See log file: $log_file for more information.")

        Write-Error "`n`n[ERROR] Error from PowerShell:`n`n $_" 2>&1 | Tee-Host | Out-File -Append -Encoding $log_file_encoding -FilePath $log_file -Width $log_file_width

        $window_private_data.ErrorBackgroundColor = $saved_background_color

        $window_private_data.ErrorForegroundColor = $saved_foreground_color

    }

} # end InvokeCommandExecute

# Asynchronously output stdout & stderr while executing Smalltalk/X executable

# Note: 

# 1) for now used only while having manual switches to smalltalk.bat

# 2) Is seems to be little bit slower than the Invoke-Expression, howerver Smalltalk/X GUI

#    appears sooner than all the messages are processed so the end speed should be comparable

# 3) for now used only when manual switches (inputed by user) are detected

# 4) Will output everything from stdout/stderr even when stx executable crashes or powershell encounters an error

#    (of course not closing the powershell window)

function DebugProcessExecute {

    param(

        [Parameter(Mandatory=$true, Position = 0)]

        [ValidateNotNullOrEmpty()]

        [String]$executable,

        [Parameter(Mandatory=$true, Position = 1)]

        $stx_switch,

        [Parameter(Mandatory=$true, Position = 2)]

        [String]$logging_function,

        [Parameter(Mandatory=$true, Position = 3)]

        [Int]$start_sleep_period,

        [Parameter(Mandatory=$false, Position = 4)]

        [String]$verb,

        [Parameter(Mandatory=$false, Position = 5)]

        [System.Diagnostics.ProcessPriorityClass]$Priority = [System.Diagnostics.ProcessPriorityClass]::Normal

    )

    begin {

        If ($log_file_encoding -eq 'ASCII') {

            $output_encoding = New-Object -typename System.Text.ASCIIEncoding

        } ElseIf ($log_file_encoding -eq 'UTF8') {

            $output_encoding = New-Object -typename System.Text.UTF8Encoding

        } ElseIf ($log_file_encoding -eq 'UTF16') {

            $output_encoding = New-Object -typename System.Text.UnicodeEncoding

        } ElseIf ($log_file_encoding -eq 'UTF32') {

            $output_encoding = New-Object -typename System.Text.UTF32Encoding

        }

    }

    process {

        try {

           "`n", "[INFO] Executing asynchronously command: $executable $stx_switch | $logging_function" | PrintMessage

           # Setting process invocation parameters.

           $process_start_info = New-Object -TypeName System.Diagnostics.ProcessStartInfo

           $process_start_info.CreateNoWindow = $true

           $process_start_info.UseShellExecute = $false

           $process_start_info.RedirectStandardOutput = $true

           $process_start_info.StandardOutputEncoding = $output_encoding

           $process_start_info.RedirectStandardError = $true

           $process_start_info.StandardErrorEncoding = $output_encoding

           $process_start_info.FileName = $executable

           $process_start_info.Arguments = $stx_switch

           If (![String]::IsNullOrEmpty($verb)) {

               $process_start_info.Verb = $verb

           }

           # Creating process object.

           $process = New-Object -TypeName System.Diagnostics.Process

           $process.StartInfo = $process_start_info

           $passing_variable = new-object psobject -property @{file_logging = $logging_function}

           # Asynchronously listen for OutputDataReceived events on the process (stdout)

           # Note: To use all events without ForEach loop use: $event.SourceEventArgs.Data variable

           $outEvent = Register-ObjectEvent -InputObj $process `

                           -Event "OutputDataReceived" `

                           -Action `

            {

                param

                (

                    [System.Object] $sender,

                    [System.Diagnostics.DataReceivedEventArgs] $events 

                )

                # Where to log

                $file_log = $Event.MessageData.file_logging

                ForEach  ($line in $events.data) {

                    Write-Verbose "[stdout]: $line" -Verbose

                    # write to the log file

                    $exec_with_logging = @"

Write-Output '[stdout]: $line' | $file_log

"@

                    Invoke-Expression -Command:$exec_with_logging

                }

            } -MessageData $passing_variable

            # /Out Listener - stdout

            # # asynchronously listen for ErrorDataReceived events on the process (stderr)

            $errEvent = Register-ObjectEvent -InputObj $process `

            -Event "ErrorDataReceived" `

            -Action `

            {

                param

                (

                    [System.Object] $sender,

                    [System.Diagnostics.DataReceivedEventArgs] $events

                ) 

                $file_log = $Event.MessageData.file_logging

                ForEach  ($line in $events.data) {

                    # $line = ("[stderr]:" + $line)

                    If ($line -match '\[error\]' -or $line -match '\[sigsegv\]') {

                        $host.ui.WriteErrorLine("$line")

                    } ElseIf ($line -match '\[warn\]') {

                        Write-Warning $line

                    } Else {

                        Write-Verbose -Message $line -Verbose

                    } 

                    # write to the log file

                    $exec_with_logging = @"

Write-Output '$line' | $file_log

"@

                    Invoke-Expression -Command:$exec_with_logging

                }

            } -MessageData $passing_variable

            #  Error Listener - stderr

           # Starting process with no return value

           [Void]$process.Start()

           $process.PriorityClass = $Priority

           # Begin async read events

           $process.BeginOutputReadLine()

           $process.BeginErrorReadLine()

           # loop till application exited 

           # used for logging into the stdout/stderr

           # Note: the timeout has been tested for speed vs. process usage -> 50ms does not use CPU that much + the output is reasonably fast

           while (!$process.HasExited) { 

               [System.Console]::Out.Flush()

               [System.Console]::Error.Flush()

               Start-Sleep -Milliseconds $start_sleep_period

           }

           $exit_code = $process.ExitCode

           If ($process.ExitCode -ne 0) {

               $result = $result -join "`n"

               throw "$result `n"

           }

        }

        catch {

            # The only reliable way to flush stderr is to produce an error message

            Write-Error -Message 'An error has occurred...'

            # If an error occurrences than wait till exit - all buffers are emptied

            [System.Console]::Out.Flush()

            [System.Console]::Error.Flush()

            $process.WaitForExit()

            $process.CancelOutputRead()

            $process.CancelErrorRead()

            $window_private_data = (Get-Host).PrivateData

            # saving the original colors

            $saved_background_color = $window_private_data.ErrorBackgroundColor

            $saved_foreground_color = $window_private_data.ErrorForegroundColor

            # setting the new colors

            $window_private_data.ErrorBackgroundColor = 'White'

            $window_private_data.ErrorForegroundColor = 'Red'

            $host.ui.WriteErrorLine("[ERROR] happened in stx.com or PowerShell script - See log file: $log_file for more information.")

            Write-Error "`n`n[ERROR] Error from PowerShell:`n`n $_" 2>&1 | Tee-Host | Out-File -Append -Encoding $log_file_encoding -FilePath $log_file -Width $log_file_width

            $window_private_data.ErrorBackgroundColor = $saved_background_color

            $window_private_data.ErrorForegroundColor = $saved_foreground_color

            # =======================================================

            # Add Catch section Separator when adding into the file =

            # =======================================================

            If (!$is_logfile_locked){

                If ($append_to_log) {

                    Write-Output "`r`n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!`r`n" | Out-File -Append -Encoding $log_file_encoding -FilePath $log_file -Width $log_file_width

                }

            }

        }

        finally {

           # Unregister events

           If (($Null -ne $outEvent) -or ($Null -ne $errEvent)) {

               $outEvent.Name, $errEvent.Name |

               ForEach-Object {Unregister-Event -SourceIdentifier $_}

           }

        }

    }

    end {

        return $exit_code

    } 

} # end DebugProcessExecute

# =============================

# check if log file is locked =

# =============================

function Test-FileLock {

    param (

      [parameter(Mandatory=$true)][string]$path

    )

    $log_file = New-Object System.IO.FileInfo $path

    If ((Test-Path -Path $path) -eq $false) {

        return $false

    }

    try {

      $log_file_stream = $log_file.Open([System.IO.FileMode]::Open, [System.IO.FileAccess]::ReadWrite, [System.IO.FileShare]::None)

      If ($log_file_stream) {

          $log_file_stream.Close()

      }

      $false

    } catch {

      # file is locked by a process.

      return $true

    }

}

# ========================================================================

# Check if user did not start the PowerShell file directly - exit if yes =

# ========================================================================

If ([string]::IsNullOrEmpty($executable)) {

    "`n", '[ERROR] You can not run this powershell script directly!', 'Execute batch file (.bat) instead.' | PrintMessage

    EXIT 1

}

# ====================================

# Checking the state of the log file =

# ====================================

# Must be done only once in the file in case 

# the file is unlocked before the second instance is closed

$is_logfile_locked = Test-FileLock($log_file)

# ================

# Stdout logging =

# ================

If ($is_logfile_locked){

    "`n", "[WARN] Log file $log_file in use.`n`n  !!NO LOGGING will be available for this Smalltalk/X instance!!" | PrintMessage

    '[INFO] Press any key to continue ...' | PrintMessage

    # pause - waits for pressing any key

    $host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") | Out-null

    If (!$cmd_in_powershell -and $stx_manual_switch_detected) {

        $logging_function = 'Out-null'

    } Else {

        $logging_function = 'Tee-Host | Out-null'

    }

} Else {

    If (!$cmd_in_powershell -and $stx_manual_switch_detected) {

        If ($append_to_log) {

            $logging_function = "Out-File -Append -Encoding '$log_file_encoding' -FilePath '$log_file' -Width $log_file_width"

        } Else {

            "`n", "[INFO] Creating a blank log file." | PrintMessage

            Write-Output $null | Out-File -Encoding $log_file_encoding -FilePath $log_file -Width $log_file_width

            $logging_function = "Out-File -Append -Encoding '$log_file_encoding' -FilePath '$log_file' -Width $log_file_width"

        }

    } Else {