/*
 * This is a demo that shows how we can have a stream-oriented view of characters from the console
 * while also listening to console events like mouse, menu, focus, buffer/viewport(1) resize events.
 *
 * This has always been tricky to do because ReadConsoleW/A doesn't allow retrieving events.
 * Only ReadConsoleInputW/A returns events, but isn't stream-oriented. Using both doesn't work because
 * ReadConsoleW/A flushes the input queue, meaning calls to ReadConsoleInputW/A will wait forever.
 *
 * I do this by deriving a new Stream class which wraps ReadConsoleInputW and accepts a provider/consumer
 * implementation of BlockingCollection<Kernel32.INPUT_RECORD>. This allows asynchronous monitoring of
 * console events while simultaneously streaming the character input. I also use Mark Gravell's great
 * System.IO.Pipelines utility classes (2) and David Hall's excellent P/Invoke wrappers (3) to make this
 * demo cleaner to read; both are pulled from NuGet.
 *
 * (1) in versions of windows 10 prior to 1809, the buffer resize event only fires for enlarging
 * the viewport, as this would cause the buffer to be enlarged too. Now it fires even when
 * shrinking the viewport, which won't change the buffer size.
 *
 * (2) https://github.com/mgravell/Pipelines.Sockets.Unofficial
 * https://www.nuget.org/packages/Pipelines.Sockets.Unofficial
 *
 * (3) https://github.com/dahall/Vanara
 * https://www.nuget.org/packages/Vanara.Pinvoke.Kernel32
 *
 * Oisin Grehan - 2019年4月21日
 *
 * https://twitter.com/oising
 * https://github.com/oising
 */

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

using Pipelines.Sockets.Unofficial;
using Vanara.PInvoke;

namespace Samples.Terminal
{
 internal class Program
 {
 private static async Task Main(string[] args)
 {
 // run for 90 seconds
 var timeout = TimeSpan.FromSeconds(90);

 // in reality this will likely never be reached, but it is useful to guard against
 // conditions where the queue isn't drained, or not drained fast enough. 
 const int maxNonKeyEventRetention = 128;

 var source = new CancellationTokenSource(timeout);
 var token = source.Token;
 var handle = Kernel32.GetStdHandle(Kernel32.StdHandleType.STD_INPUT_HANDLE);

 if (!Kernel32.GetConsoleMode(handle, out Kernel32.CONSOLE_INPUT_MODE mode))
 throw NativeMethods.GetExceptionForWin32Error(Marshal.GetLastWin32Error());

 mode |= Kernel32.CONSOLE_INPUT_MODE.ENABLE_WINDOW_INPUT;
 mode |= Kernel32.CONSOLE_INPUT_MODE.ENABLE_VIRTUAL_TERMINAL_INPUT;
 mode &= ~Kernel32.CONSOLE_INPUT_MODE.ENABLE_ECHO_INPUT;
 mode &= ~Kernel32.CONSOLE_INPUT_MODE.ENABLE_LINE_INPUT;

 if (!Kernel32.SetConsoleMode(handle, mode))
 throw NativeMethods.GetExceptionForLastWin32Error();

 // base our provider/consumer on a bounded queue to keep memory usage under control
 var events = new BlockingCollection<Kernel32.INPUT_RECORD>(
 new ConcurrentBoundedQueue<Kernel32.INPUT_RECORD>(maxNonKeyEventRetention));

 // Task that will consume non-key events asynchronously
 var consumeEvents = Task.Run(() =>
 {
 Console.WriteLine("consumeEvents started");

 try
 {
 while (!events.IsCompleted)
 {
 // blocking call
 var record = events.Take(token);

 Console.WriteLine("record: {0}",
 Enum.GetName(typeof(Kernel32.EVENT_TYPE), record.EventType));
 }
 }
 catch (OperationCanceledException)
 {
 // timeout
 }

 Console.WriteLine("consumeEvents ended");
 }, token);

 // Task that will watch for key events while feeding non-key events into our provider/consumer collection 
 var readInputAndProduceEvents = Task.Run(async () =>
 {
 //So, this is the key point - we cannot use the following or we lose all non-key events:
 // Stream stdin = Console.OpenStandardInput();
 
 // get a unicode character stream over console input 
 Stream stdin = new ReadConsoleInputStream(handle, events);

 // wrap in a System.IO.Pipelines.PipeReader to get clean async and span/memory usage 
 var reader = StreamConnection.GetReader(stdin);

 while (!token.IsCancellationRequested)
 {
 // blocking call
 var result = await reader.ReadAsync(token);

 if (result.IsCanceled)
 break;

 var sequence = result.Buffer;
 var segment = sequence.Start;

 while (sequence.TryGet(ref segment, out var mem))
 {
 // decode back from unicode
 var datum = Encoding.Unicode.GetString(mem.Span);
 Console.Write(datum);
 }

 reader.AdvanceTo(sequence.End);
 }
 }, token);

 Console.WriteLine("Running");

 try
 {
 await Task.WhenAll(consumeEvents, readInputAndProduceEvents);
 }
 catch (OperationCanceledException)
 {
 // timeout
 }

 Console.WriteLine("press any key...");
 Console.ReadKey(true);
 }
 }
}