stgsharp/StgSharp.Common/Environment/Dialogue.cs

//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Dialogue"
// Project: StgSharp
// AuthorGroup: Nitload
// Copyright (c) Nitload. All rights reserved.
//     
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
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();
        }

    }
}