stgsharp/StgSharp.Common/Environment/Dialogue.cs

// -----------------------------------------------------------------------------
// file="Dialogue"
// Project: StgSharp
// Copyright (c) Nitload.
// SPDX-License-Identifier: MIT
// -----------------------------------------------------------------------------

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace StgSharp
{
    public static class Dialogue
    {

        private static Process? _dialogueProcess;
        private static AnonymousPipeServerStream _dialogueClientPipe,_dialogueServerPipe;
        private static int _readAndWriteThreadId;
        private static ProcessStartInfo _dialogueProcessInfo;
        private static StreamReader _dr;
        private static StreamWriter _dw;

        public static bool NeedShowWhenStartup { get; set; }

        public static void PostError(
                           Exception ex
        )
        {
            CreateDialogueProcessIfNotExist();

            _dw.WriteLine($"posterror {ex.Message}");

            _dialogueProcess!.Exited -= DialogueProcessExitCallback;
        }

        public static void SetReadAndWriteThread(
                           Thread thread
        )
        {
            _readAndWriteThreadId = thread.ManagedThreadId;
        }

        internal static void CreateDialogueProcessIfNotExist()
        {
            if (_dialogueProcess != null) {
                return;
            }
            if (!File.Exists(_dialogueProcessInfo.FileName)) {
                return;
            }
            _dialogueProcess = Process.Start(_dialogueProcessInfo);

            _dr = new StreamReader(_dialogueClientPipe);
            _dw = new StreamWriter(_dialogueServerPipe);

            _dialogueProcess!.Exited += DialogueProcessExitCallback;

            _dialogueServerPipe.DisposeLocalCopyOfClientHandle();
            _dialogueClientPipe.DisposeLocalCopyOfClientHandle();
        }

        internal static void LoadDialogue()
        {
            _dialogueServerPipe = new AnonymousPipeServerStream(
                PipeDirection.Out, HandleInheritability.Inheritable);
            _dialogueClientPipe = new AnonymousPipeServerStream(
                PipeDirection.In, HandleInheritability.Inheritable);

            string route = Assembly.GetAssembly(typeof(World))?.Location ?? string.Empty;
            string path = Path.GetDirectoryName(route) ?? string.Empty;

            string exeName;

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                exeName = ".exe";
            } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
                       RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                exeName = string.Empty;
            } else
            {
                throw new PlatformNotSupportedException("Unknown OS platform");
            }

            string consoleRoute = Path.Combine(
                path, @"StgSharp.TerminalDialogue", $@"StgSharp.TerminalDialogue{exeName}");

            _dialogueProcessInfo = new ProcessStartInfo
            {
                FileName = consoleRoute,
                Arguments =
                $"{_dialogueServerPipe.GetClientHandleAsString()} {_dialogueClientPipe.GetClientHandleAsString()}",
                UseShellExecute = true,
                RedirectStandardOutput = false,
            };
        }

        internal static void PostMessage(
                             string instruction,
                             params string[] operands
        )
        {
            CreateDialogueProcessIfNotExist();

            _dw.WriteLine($"{instruction} {operands}");
        }

        internal static void UnloadDialogue()
        {
            if (_dialogueProcess != null) {
                _dialogueProcess.Kill();
            }
            _dialogueProcess = null;

            _dialogueServerPipe.Dispose();
            _dialogueClientPipe.Dispose();
        }

        internal static string WaitCertainReturn(
                               string target
        )
        {
            if (_dialogueProcess == null) {
                return string.Empty;
            }

            string temp = string .Empty;
            do
            {
                temp = _dr.ReadLine();
                temp = temp ?? string.Empty;
                if (!temp!.StartsWith(target))
                {
                    break;
                }
            } while (true);

            int index = temp.IndexOf(' ');
            return index != -1 ? temp.Substring(index + 1) : string.Empty;
        }

        private static void AssertThread()
        {
            if (_readAndWriteThreadId != Environment.CurrentManagedThreadId) {
                throw new InvalidOperationException(
                    "Communication with dialogue can only call from certain thread.");
            }
        }

        private static void DialogueProcessExitCallback(
                            object? sender,
                            EventArgs e
        )
        {
            _dialogueProcess = null;
            _dr.Close();
            _dw.Close();
        }

    }
}