//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//     file="Dialogue.cs"
//     Project: StgSharp
//     AuthorGroup: Nitload Space
//     Copyright (c) Nitload Space. 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 ConcurrentBag<string> msgCache = new ConcurrentBag<string>(
            );
        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 SetReadAndWriteThread(Thread thread)
        {
            _readAndWriteThreadId = thread.ManagedThreadId;
        }

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

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

            }
            _dialogueProcess = Process.Start( _dialogueProcessInfo );

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

            _dialogueProcess!.Exited += DialogueProcessExitCallback; 

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

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

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

            string route = Assembly.GetAssembly( typeof( StgSharp ) ).Location;
            string path = Path.GetDirectoryName( route );

            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, @"StgSharpTerminalDialogue", $@"StgSharpTerminalDialogue{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}");

        }

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

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

            _dialogueProcess!.Exited -= DialogueProcessExitCallback;
        }

        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;
        }

    }
}