#if UNITY_STANDALONE || UNITY_EDITOR
using UnityEngine;

namespace Crosstales.Common.Util
{
   #region CTProcess

   /// <summary>Native process class for standalone IL2CPP-builds (mimicking the missing "System.Diagnostics.Process"-class with the most important properties, methods and events).</summary>
   public class CTProcess : System.IDisposable
   {
      #region Variables

      private uint _exitCode = 123456;
      private CTProcessStartInfo _startInfo = new CTProcessStartInfo();

      private static readonly System.Reflection.FieldInfo[] EVENT_FIELDS = typeof(System.Diagnostics.DataReceivedEventArgs).GetFields(
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.DeclaredOnly);

      #endregion


      #region Properties

      /// <summary>Gets the native handle of the associated process.</summary>
      public System.IntPtr Handle { get; private set; }

      /// <summary>Gets the unique identifier for the associated process.</summary>
      public int Id { get; private set; }

      /// <summary>Gets or sets the properties to pass to the Start() method of the Process.</summary>
      public CTProcessStartInfo StartInfo
      {
         get => _startInfo;

         set
         {
            if (value != null)
               _startInfo = value;
         }
      }

      /// <summary>Gets a value indicating whether the associated process has been terminated.</summary>
      public bool HasExited { get; private set; }

      /// <summary>Gets the value that the associated process specified when it terminated.</summary>
      public uint ExitCode => _exitCode;

      /// <summary>Gets the time that the associated process was started.</summary>
      public System.DateTime StartTime { get; private set; }

      /// <summary>Gets the time that the associated process exited.</summary>
      public System.DateTime ExitTime { get; private set; }

      /// <summary>Gets a stream used to read the textual output of the application.</summary>
      public System.IO.StreamReader StandardOutput { get; private set; }

      /// <summary>Gets a stream used to read the error output of the application.</summary>
      public System.IO.StreamReader StandardError { get; private set; }

      /// <summary>Gets a value indicating whether the associated process has been busy.</summary>
      public bool isBusy { get; private set; }

      #endregion


      #region Events

      public event System.EventHandler Exited;

//#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN || ENABLE_IL2CPP
      public event System.Diagnostics.DataReceivedEventHandler OutputDataReceived;

      public event System.Diagnostics.DataReceivedEventHandler ErrorDataReceived;
//#endif

      #region Event-trigger methods

      private void onExited()
      {
         if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
            Debug.Log($"onExited: {ExitCode}");

         Exited?.Invoke(this, System.EventArgs.Empty);
      }

      #endregion

      #endregion


      #region Public methods

      public void BeginOutputReadLine()
      {
         //System.Threading.Thread.Sleep(100);
         new System.Threading.Thread(watchStdOut).Start();
      }

      public void BeginErrorReadLine()
      {
         //System.Threading.Thread.Sleep(100);
         new System.Threading.Thread(watchStdErr).Start();
      }

      /// <summary>Starts the process resource that is specified by the parameter containing process start information (for example, the file name of the process to start) and associates the resource with a new Process component..</summary>
      public void Start(CTProcessStartInfo info)
      {
         if (info != null)
            StartInfo = info;

         Start();
      }

      #endregion

#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
      #region Windows

      #region Variables

      private System.IntPtr _threadHandle = System.IntPtr.Zero;

      private const uint INFINITE = 0xffffffff;

      // Creation flags
      private const uint CREATE_NO_WINDOW = 0x08000000;

      #endregion


      #region Public methods

      /// <summary>Starts (or reuses) the process resource that is specified by the StartInfo property of this Process component and associates it with the component.</summary>
      public void Start()
      {
         cleanup();

         isBusy = true;
         HasExited = false;

         if (StartInfo.UseThread)
         {
            new System.Threading.Thread(createProcess).Start();

            System.Threading.Thread.Sleep(200);
         }
         else
         {
            createProcess();
         }
      }

      /// <summary>Immediately stops the associated process.</summary>
      public void Kill()
      {
         if (Handle != System.IntPtr.Zero)
         {
            uint _exitCode = 99999; //killed
            NativeMethods.TerminateProcess(Handle, ref _exitCode);

            Dispose();
         }
      }

      public void WaitForExit(int milliseconds = 0)
      {
         if (milliseconds > 0)
         {
            NativeMethods.WaitForSingleObject(Handle, (uint)milliseconds);
         }
         else
         {
            NativeMethods.WaitForSingleObject(Handle, INFINITE);
         }
      }

      public void Dispose()
      {
         if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
            Debug.LogWarning("Dispose called!");

         if (Handle != System.IntPtr.Zero)
            NativeMethods.CloseHandle(Handle);

         if (_threadHandle != System.IntPtr.Zero)
            NativeMethods.CloseHandle(_threadHandle);

         Handle = System.IntPtr.Zero;
         _threadHandle = System.IntPtr.Zero;
         Id = 0;

         isBusy = false;
         HasExited = true;

         StandardOutput?.Dispose();
         StandardError?.Dispose();
      }

      #endregion


      #region Private methods

      private void createProcess()
      {
         StartTime = System.DateTime.Now;

         string app = StartInfo.FileName;
         string args = StartInfo.Arguments;

         if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
            Debug.Log($"createProcess: {StartTime}");

         //isBusy = true;
         //HasExited = false;

         NativeMethods.STARTUPINFOEX startupInfo = new NativeMethods.STARTUPINFOEX();

         try
         {
            if ((StartInfo.RedirectStandardOutput || StartInfo.RedirectStandardError || StartInfo.UseCmdExecute) &&
                !StartInfo.FileName.CTContains("cmd"))
            {
               app = Crosstales.Common.Util.BaseConstants.CMD_WINDOWS_PATH;
               args = $"/c call \"{StartInfo.FileName}\" {StartInfo.Arguments}";
            }

            if (StartInfo.RedirectStandardOutput)
            {
               string tempStdFile = FileHelper.TempFile;
               args += $" > \"{tempStdFile}\"";

               if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
                  Debug.Log($"tempStdFile: {tempStdFile}");

               StandardOutput = new System.IO.StreamReader(new System.IO.FileStream(tempStdFile, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite), StartInfo.StandardOutputEncoding);
            }
            else
            {
               StandardOutput =
                  new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            if (StartInfo.RedirectStandardError)
            {
               string tempErrFile = FileHelper.TempFile;
               args += $" 2> \"{tempErrFile}\"";

               if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
                  Debug.Log($"tempErrFile: {tempErrFile}");

               StandardError = new System.IO.StreamReader(new System.IO.FileStream(tempErrFile, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite), StartInfo.StandardOutputEncoding);
            }
            else
            {
               StandardError = new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            NativeMethods.SECURITY_ATTRIBUTES pSec = new NativeMethods.SECURITY_ATTRIBUTES();
            NativeMethods.SECURITY_ATTRIBUTES tSec = new NativeMethods.SECURITY_ATTRIBUTES();
            pSec.nLength = System.Runtime.InteropServices.Marshal.SizeOf(pSec);
            tSec.nLength = System.Runtime.InteropServices.Marshal.SizeOf(tSec);

            if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
               Debug.Log($"application: {app}{System.Environment.NewLine}arguments: {args}");

            bool retValue =
               NativeMethods.CreateProcess(app, $" {args}", ref pSec, ref tSec, true,
                  StartInfo.CreateNoWindow ? CREATE_NO_WINDOW : 0x00000000, System.IntPtr.Zero,
                  StartInfo.WorkingDirectory, ref startupInfo, out NativeMethods.PROCESS_INFORMATION processInfo);

            if (retValue)
            {
               Handle = processInfo.hProcess;
               _threadHandle = processInfo.hThread;
               Id = processInfo.dwProcessId;

               WaitForExit();
            }
            else
            {
               Debug.LogError($"Could not start process: '{StartInfo.FileName}'{System.Environment.NewLine}Arguments: '{StartInfo.Arguments}'{System.Environment.NewLine}Working dir: '{StartInfo.WorkingDirectory}'{System.Environment.NewLine}Last error: {NativeMethods.GetLastError()}");
            }
         }
         catch (System.Exception ex)
         {
            Debug.LogError($"Process threw an error: {ex}");

            Dispose();
         }
         finally
         {
            System.Threading.Thread.Sleep(200); //give the streams the chance to write out all events

            NativeMethods.GetExitCodeProcess(Handle, ref _exitCode);

            ExitTime = System.DateTime.Now;

            if (Handle != System.IntPtr.Zero)
               NativeMethods.CloseHandle(Handle);

            if (_threadHandle != System.IntPtr.Zero)
               NativeMethods.CloseHandle(_threadHandle);

            Handle = System.IntPtr.Zero;
            _threadHandle = System.IntPtr.Zero;
            Id = 0;

            if (!HasExited)
               onExited();

            isBusy = false;
            HasExited = true;
         }
      }

      private void cleanup()
      {
         Kill();
         Dispose();
      }

      #endregion

      #endregion

#else

      #region Unix

      #region Variables

      private System.Threading.Thread _worker;

      #endregion


      #region Public methods

      /// <summary>Starts (or reuses) the process resource that is specified by the StartInfo property of this Process component and associates it with the component.</summary>
      public void Start()
      {
         isBusy = true;
         HasExited = false;

         if (StartInfo.UseThread)
         {
            _worker = new System.Threading.Thread(() => createProcess());
            _worker.Start();

            System.Threading.Thread.Sleep(200);
         }
         else
         {
            createProcess();
         }
      }

      /// <summary>Immediately stops the associated process.</summary>
      public void Kill()
      {
         _worker.CTAbort();

         Dispose();
      }

      public void WaitForExit(int milliseconds = 0)
      {
         //Debug.Log("Not implemented!");
      }

      public void Dispose()
      {
         if (BaseConstants.DEV_DEBUG)
            Debug.LogWarning("Dispose called!");

         Id = 0;
         isBusy = false;
         HasExited = true;

         if (StandardOutput != null)
            StandardOutput.Dispose();

         if (StandardError != null)
            StandardError.Dispose();
      }

      #endregion


      #region Private methods

      private void createProcess()
      {
         StartTime = System.DateTime.Now;

         string app = StartInfo.FileName;
         string args = StartInfo.Arguments;

         if (BaseConstants.DEV_DEBUG)
            Debug.LogWarning($"createProcess: {StartTime}");

         try
         {
#if UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
//#if false
            if (StartInfo.RedirectStandardOutput)
            {
               StandardOutput = new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            if (StartInfo.RedirectStandardError)
            {
               string tempErrFile = FileHelper.TempFile;
               args += $" 2> \"{tempErrFile}\"";

               if (BaseConstants.DEV_DEBUG)
                  Debug.Log($"tempErrFile: {tempErrFile}");

               StandardError = new System.IO.StreamReader(new System.IO.FileStream(tempErrFile, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite), StartInfo.StandardOutputEncoding);
            }
            else
            {
               StandardError = new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            string result = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(NativeMethods.RunCommand($"{app} {args}"));

            if (StartInfo.RedirectStandardOutput && !string.IsNullOrEmpty(result))
            {
               byte[] byteArray = StartInfo.StandardOutputEncoding.GetBytes(result);
               System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);
               StandardOutput = new System.IO.StreamReader(stream);
            }

            _exitCode = 0;
#else
            if (StartInfo.RedirectStandardOutput)
            {
               string tempStdFile = FileHelper.TempFile;
               args += $" > \"{tempStdFile}\"";

               if (BaseConstants.DEV_DEBUG)
                  Debug.Log($"tempStdFile: {tempStdFile}");

               StandardOutput = new System.IO.StreamReader(new System.IO.FileStream(tempStdFile, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite), StartInfo.StandardOutputEncoding);
            }
            else
            {
               StandardOutput = new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            if (StartInfo.RedirectStandardError)
            {
               string tempErrFile = FileHelper.TempFile;
               args += $" 2> \"{tempErrFile}\"";

               if (BaseConstants.DEV_DEBUG)
                  Debug.Log($"tempErrFile: {tempErrFile}");

               StandardError = new System.IO.StreamReader(new System.IO.FileStream(tempErrFile, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite), StartInfo.StandardOutputEncoding);
            }
            else
            {
               StandardError = new System.IO.StreamReader(new System.IO.MemoryStream(), StartInfo.StandardOutputEncoding);
            }

            _exitCode = (uint)NativeMethods.RunCommand($"{app} {args}");
#endif
         }
         catch (System.Threading.ThreadAbortException)
         {
            //Debug.LogWarning("Process killed!");
            _exitCode = 123456;
         }
         catch (System.Exception ex)
         {
            Debug.LogError($"Process threw an error: {ex}");
            _exitCode = 99;
         }
         finally
         {
            ExitTime = System.DateTime.Now;
            Id = 0;

            if (!HasExited)
               onExited();

            isBusy = false;
            HasExited = true;
         }
      }

      #endregion

      #endregion

#endif

      private void watchStdOut()
      {
         using (System.IO.StreamReader streamReader = StandardOutput)
         {
            while (!streamReader.EndOfStream)
            {
               string reply = streamReader.ReadLine();

               if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
                  Debug.Log($"watchStdOut: {reply}");

               OutputDataReceived?.Invoke(this, createMockDataReceivedEventArgs(reply));
            }
         }
      }

      private void watchStdErr()
      {
         using (System.IO.StreamReader streamReader = StandardError)
         {
            while (!streamReader.EndOfStream)
            {
               string reply = streamReader.ReadLine();

               if (Crosstales.Common.Util.BaseConstants.DEV_DEBUG)
                  Debug.Log($"watchStdErr: {reply}");

               ErrorDataReceived?.Invoke(this, createMockDataReceivedEventArgs(reply));
            }
         }
      }

      private static System.Diagnostics.DataReceivedEventArgs createMockDataReceivedEventArgs(string data)
      {
         if (string.IsNullOrEmpty(data))
            throw new System.ArgumentException("Data is null or empty.", nameof(data));

         System.Diagnostics.DataReceivedEventArgs mockEventArgs =
            (System.Diagnostics.DataReceivedEventArgs)System.Runtime.Serialization.FormatterServices
               .GetUninitializedObject(typeof(System.Diagnostics.DataReceivedEventArgs));

         if (EVENT_FIELDS.Length > 0)
         {
            EVENT_FIELDS[0].SetValue(mockEventArgs, data);
         }
         else
         {
            Debug.LogError("Could not create 'DataReceivedEventArgs'!");
         }

         return mockEventArgs;
      }
   }

   #endregion


   #region Native methods

   /// <summary>Native methods (bridge to Windows).</summary>
   internal static class NativeMethods
   {
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
//#if false

      #region Windows

      [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true,
         CharSet = System.Runtime.InteropServices.CharSet.Auto)]
      [return: System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.Bool)]
      internal static extern bool CreateProcess(
         string lpApplicationName, string lpCommandLine, ref SECURITY_ATTRIBUTES lpProcessAttributes,
         ref SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags,
         System.IntPtr lpEnvironment, string lpCurrentDirectory,
         [System.Runtime.InteropServices.In] ref STARTUPINFOEX lpStartupInfo,
         out PROCESS_INFORMATION lpProcessInformation);

      [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
      [System.Runtime.ConstrainedExecution.ReliabilityContract(
         System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState,
         System.Runtime.ConstrainedExecution.Cer.MayFail)]
      internal static extern bool CloseHandle(System.IntPtr hObject);

      [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
      internal static extern bool GetExitCodeProcess(System.IntPtr process, ref uint exitCode);

      [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
      internal static extern uint WaitForSingleObject(System.IntPtr handle, uint milliseconds);

      [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
      internal static extern bool TerminateProcess(System.IntPtr hProcess, ref uint exitCode);

      [System.Runtime.InteropServices.DllImport("Kernel32.dll")]
      internal static extern uint GetLastError();

      [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, CharSet =
         System.Runtime.InteropServices.CharSet.Unicode)]
      internal struct STARTUPINFOEX
      {
         public STARTUPINFO StartupInfo;
         public System.IntPtr lpAttributeList;
      }

      [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, CharSet =
         System.Runtime.InteropServices.CharSet.Unicode)]
      internal struct STARTUPINFO
      {
         public int cb;
         public string lpReserved;
         public string lpDesktop;
         public string lpTitle;
         public int dwX;
         public int dwY;
         public int dwXSize;
         public int dwYSize;
         public int dwXCountChars;
         public int dwYCountChars;
         public int dwFillAttribute;
         public int dwFlags;
         public short wShowWindow;
         public short cbReserved2;
         public System.IntPtr lpReserved2;
         public System.IntPtr hStdInput;
         public System.IntPtr hStdOutput;
         public System.IntPtr hStdError;
      }

      [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
      internal struct PROCESS_INFORMATION
      {
         public System.IntPtr hProcess;
         public System.IntPtr hThread;
         public int dwProcessId;
         public int dwThreadId;
      }

      [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
      internal struct SECURITY_ATTRIBUTES
      {
         public int nLength;
         public System.IntPtr lpSecurityDescriptor;
         public int bInheritHandle;
      }

      #endregion

#elif UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
//#elif false

      #region macOS

      [System.Runtime.InteropServices.DllImport("ProcessStart")]
      internal static extern System.IntPtr RunCommand(string command);

      #endregion

#elif UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
//#elif true

        #region Linux

        [System.Runtime.InteropServices.DllImport("libProcessStart")]
        internal static extern int RunCommand(string command);

        #endregion

#endif
   }

   #endregion


   #region CTProcessStartInfo

   /// <summary>Specifies a set of values that are used when you start a process (mimicking the "System.Diagnostics.ProcessStartInfo"-class with the most important properties).</summary>
   public class CTProcessStartInfo
   {
      public CTProcessStartInfo()
      {
         StandardErrorEncoding = StandardOutputEncoding = System.Text.Encoding.UTF8;
         UseThread = true;
      }

      /// <summary>Gets or sets the application to be threaded.</summary>
      public bool UseThread { get; set; }

      /// <summary>Gets or sets the application to be started in cmd (command prompt).</summary>
      public bool UseCmdExecute { get; set; }

      /// <summary>Gets or sets the application or document to start.</summary>
      public string FileName { get; set; }

      /// <summary>Gets or sets the set of command-line arguments to use when starting the application.</summary>
      public string Arguments { get; set; }

      /// <summary>Gets or sets a value indicating whether to start the process in a new window.</summary>
      public bool CreateNoWindow { get; set; }

      /// <summary>Gets or sets the working directory for the process to be started.</summary>
      public string WorkingDirectory { get; set; }

      /// <summary>Gets or sets a value that indicates whether the textual output of an application is written to the StandardOutput stream.</summary>
      public bool RedirectStandardOutput { get; set; }

      /// <summary>Gets or sets a value that indicates whether the error output of an application is written to the StandardError stream.</summary>
      public bool RedirectStandardError { get; set; }

      /// <summary>Gets or sets the preferred encoding for standard output (UTF8 per default).</summary>
      public System.Text.Encoding StandardOutputEncoding { get; set; }

      /// <summary>Gets or sets the preferred encoding for error output (UTF8 per default).</summary>
      public System.Text.Encoding StandardErrorEncoding { get; set; }

      /// <summary>Gets or sets a value indicating whether to use the operating system shell to start the process (ignored, always false).</summary>
      public bool UseShellExecute { get; set; }
   }

   #endregion
}
#endif
// © 2019-2023 crosstales LLC (https://www.crosstales.com)