// Copyright (c) 2018, Lars Brubaker, John Lewin
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Semaphore implementation might stop the rare chance of a super slow print occuring in the ReSliceHasCorrectEPositions test.
#define USE_SEMAPHORE_FOR_RECEIVE_QUEUE

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using MatterHackers.Agg.UI;
using MatterHackers.SerialPortCommunication.FrostedSerial;
using MatterHackers.VectorMath;

namespace MatterHackers.PrinterEmulator
{
	public class Emulator : IFrostedSerialPort, IDisposable
	{
		/// <summary>
		/// The number of seconds the emulator should take to heat up to a given target.
		/// </summary>
		public static double DefaultHeatUpTime = 3;

		public int CDChangeCount;
		public bool CDState;
		public int CtsChangeCount;
		public bool CtsState;
		public int DsrChangeCount;
		public bool DsrState;
		private static Regex numberRegex = new Regex(@"[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?");

		private long commandIndex = 1;

		private int recievedCount = 0;

		// Dictionary of command and response callback
		private readonly Dictionary<string, Func<string, string>> responses;

		private bool shuttingDown = false;

		public Emulator()
		{
			Emulator.Instance = this;

			string ChangeToSlow(string a)
			{
				this.RunSlow = true;
				return "ok\n";
			}

            string TurnOnConductive(string a)
			{
                this.ConductivePad = true;
                return "ok\n";
            }

			string ChangeToFast(string a)
			{
				this.RunSlow = false;
				return "ok\n";
			}

			responses = new Dictionary<string, Func<string, string>>()
			{
				{ "A",    Echo },
				{ "FAST", ChangeToFast },
				{ "CONDUCTIVE", TurnOnConductive },
				{ "G0",   ParseMovmentCommand },
				{ "G1",   ParseMovmentCommand },
				{ "G28",  HomeAxis },
				{ "G30",  ProbePosition },
				{ "G4",   Wait },
				{ "G92",  G92ResetPosition },
				{ "M104", SetExtruderTemperature },
				{ "M105", ReturnTemp },
				{ "M106", SetFan },
				{ "M109", SetExtruderTemperature },
				{ "M110", SetLineCount },
				{ "M114", GetPosition },
				{ "M115", ReportMarlinFirmware },
				{ "M119", ReportEndStops },
				{ "M140", SetBedTemperature },
				{ "M190", SetBedTemperature },
				{ "M20",  ListSdCard },
				{ "M21",  InitSdCard },
				{ "M306", SetHomeOffset },
				{ "M851", SetXYZProbeOffset },
				{ "N",    ParseChecksumLine },
				{ "SLOW", ChangeToSlow },
				{ "THROWERROR", ThrowError },
				{ "T0",    SetExtruderIndex },
				{ "T1",    SetExtruderIndex },
			};
		}

		private string ThrowError(string arg)
		{
			// throw an error for testing
			return "MINTEMP\nok\n";
		}

		private AxisAlignedBoundingBox xMaxTriggerRegion = new AxisAlignedBoundingBox(95, 210, -10, 105, 220, 0);

		private string ReportEndStops(string arg)
		{
			var xMaxOpen = "open";
			if (xMaxTriggerRegion.Contains(CurrentPosition))
			{
				xMaxOpen = "TRIGGERED";
			}

			var status = "Reporting endstop status\n";
			status += $"x_min: open\n";
			status += $"x_max: {xMaxOpen}\n";
			status += $"y_min: open\n";
			status += $"z_min: open\n";

			if (ConductivePad)
			{
				if (conductivePadTriggerRegion.Contains(CurrentPosition))
				{
					status += $"conductive: TRIGGERED\n";
				}
				else
                {
					status += $"conductive: open\n";
				}
			}

			status += "ok\n";
			return status;
		}

		public event EventHandler ExtruderIndexChanged;

		public event EventHandler ExtruderTemperatureChanged;

		public event EventHandler FanSpeedChanged;

		public event EventHandler DestinationChanged;

		public event EventHandler EPositionChanged;

		public event EventHandler<string> RecievedInstruction;

		// Instance reference allows test to access the most recently initialized emulator
		public static Emulator Instance { get; private set; }

		public Heater CurrentExtruder { get { return Extruders[ExtruderIndex]; } }

		public int ExtruderIndex { get; private set; }

		public List<Heater> Extruders { get; private set; } = new List<Heater>()
		{
			new Heater("Hotend1") { CurrentTemperature = 27 }
		};

		public double FanSpeed { get; private set; }

		public bool HasHeatedBed { get; set; } = true;

		public Heater HeatedBed { get; } = new Heater("HeatedBed") { CurrentTemperature = 26 };

		public string PortName { get; set; }

		public bool RunSlow { get; set; } = false;

		public bool SimulateLineErrors { get; set; } = false;

		private Vector3 _destination;

		public Vector3 Destination
		{
			get => _destination;

			private set
			{
				if (value != _destination)
				{
					_destination = value;
					DestinationChanged?.Invoke(null, null);
				}
			}
		}

		public Vector3 CurrentPosition { get; private set; }

		/// <summary>
		/// Gets the feedrate in mm / m.
		/// </summary>
		public double FeedRate { get; private set; }

		public static int CalculateChecksum(string commandToGetChecksumFor)
		{
			int checksum = 0;
			if (commandToGetChecksumFor.Length > 0)
			{
				checksum = commandToGetChecksumFor[0];
				for (int i = 1; i < commandToGetChecksumFor.Length; i++)
				{
					checksum ^= commandToGetChecksumFor[i];
				}
			}

			return checksum;
		}

		public static bool GetFirstNumberAfter(string stringToCheckAfter, string stringWithNumber, ref double readValue, int startIndex = 0)
		{
			int stringPos = stringWithNumber.IndexOf(stringToCheckAfter, startIndex);
			if (stringPos != -1)
			{
				stringPos += stringToCheckAfter.Length;
				readValue = ParseDouble(stringWithNumber, ref stringPos);

				return true;
			}

			return false;
		}

		public static double ParseDouble(string source, ref int startIndex)
		{
			Match numberMatch = numberRegex.Match(source, startIndex);
			string returnString = numberMatch.Value;
			startIndex = numberMatch.Index + numberMatch.Length;
			double.TryParse(returnString, NumberStyles.Number, CultureInfo.InvariantCulture, out double returnVal);
			return returnVal;
		}

		public void Dispose()
		{
			this.ShutDown();
			Emulator.Instance = null;
		}

		public string Echo(string command)
		{
			return command;
		}

		public string GetCommandKey(string command)
		{
			if (command.IndexOf(' ') != -1)
			{
				return command.Substring(0, command.IndexOf(' '));
			}

			return command;
		}

		public string GetCorrectResponse(string inCommand)
		{
			try
			{
				RecievedInstruction?.Invoke(this, inCommand);

				// Remove line returns
				var commandNoNl = inCommand.Split('\n')[0]; // strip of the trailing cr (\n)
				var command = ParseChecksumLine(commandNoNl);
				if (command.Contains("Resend"))
				{
					return command + "ok\n";
				}

				if (!command.StartsWith("G0")
					&& !command.StartsWith("G1")
					&& !command.StartsWith("M105"))
				{
					// Log non-busy commands
					Console.WriteLine(command);
				}

				if (command.StartsWith("T"))
				{
					int a = 0;
				}

				var commandKey = GetCommandKey(command);
				if (responses.ContainsKey(commandKey))
				{
					if (RunSlow)
					{
						// do the right amount of time for the given command
						if (command.StartsWith("G0") || command.StartsWith("G1"))
						{
							var startPostion = CurrentPosition;
							var length = Math.Max(CurrentExtruder.ECurrent - CurrentExtruder.EDestination, (CurrentPosition - Destination).Length); // WIP, factor in the extruder movement
							var timeToMove_ms = (long)(length / FeedRate * 1000.0 * 60.5);
							var startTime_ms = UiThread.CurrentTimerMs;
							var doneTime_ms = startTime_ms + timeToMove_ms;
							// wait for the amount of time it takes to move the extruder
							while (UiThread.CurrentTimerMs < doneTime_ms)
							{
								var ratio = (UiThread.CurrentTimerMs - startTime_ms) / (double)timeToMove_ms;
								CurrentPosition = startPostion + (Destination - startPostion) * ratio;
								CurrentExtruder.ECurrent = CurrentExtruder.EStart + (CurrentExtruder.EDestination - CurrentExtruder.EStart) * ratio;
								Thread.Sleep(1);
							}
						}
						else
						{
							// sleep for an amount of time that is about the usb serial latency time
							Thread.Sleep(20);
						}
					}

					CurrentPosition = Destination;
					CurrentExtruder.ECurrent = CurrentExtruder.EDestination;

					return responses[commandKey](command);
				}
				else
				{
					// Too noisy... restore if needed when debugging emulator
					// Console.WriteLine($"Command {command} not found");
				}
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		public string GetPosition(string command)
		{
			// position commands look like this: X:0.00 Y:0.00 Z0.00 E:0.00 Count X: 0.00 Y:0.00 Z:0.00 then an ok on the next line
			return $"X:{Destination.X:0.00} Y: {Destination.Y:0.00} Z: {Destination.Z:0.00} E: {CurrentExtruder.EDestination:0.00} Count X: 0.00 Y: 0.00 Z: 0.00\nok\n";
		}

		public string ReportMarlinFirmware(string command)
		{
			var response = @"MatterControl Printer Emulator
Commands:
    SLOW // make the emulator simulate actual printing speeds (default)
    FAST // run as fast as possible
    THROWERROR // generate a simulated error for testing
Emulating:
FIRMWARE_NAME:Marlin V1; Sprinter/grbl mashup for gen6 FIRMWARE_URL:https://github.com/MarlinFirmware/Marlin PROTOCOL_VERSION:1.0 MACHINE_TYPE:Framelis v1 EXTRUDER_COUNT:1 UUID:155f84b5-d4d7-46f4-9432-667e6876f37a
ok
".Replace("\r", "");

			return response;
		}

		// Add response callbacks here
		public string ReturnTemp(string command)
		{
			// temp commands look like this: ok T:19.4 /0.0 B:0.0 /0.0 @:0 B@:0
			string response = "ok";
			for (int i = 0; i < Extruders.Count; i++)
			{
				string tString = (Extruders.Count == 1) ? "T" : $"T{i}";
				response += $" {tString}:{Extruders[i].CurrentTemperature:0.0} / {Extruders[i].TargetTemperature:0.0}";
			}

			// Newline if HeatedBed is disabled otherwise HeatedBed stats
			response += (!this.HasHeatedBed) ? "\n" : $" B: {HeatedBed.CurrentTemperature:0.0} / {HeatedBed.TargetTemperature:0.0}\n";
			return response;
		}

		public string SetFan(string command)
		{
			try
			{
				var sIndex = command.IndexOf('S') + 1;

				string fanSpeed = command.Substring(sIndex);

				int spaceIndex = fanSpeed.IndexOf(' ');
				if (spaceIndex != -1)
				{
					fanSpeed = fanSpeed.Substring(0, spaceIndex);
				}

				FanSpeed = int.Parse(fanSpeed);
				FanSpeedChanged?.Invoke(this, null);
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		public void ShutDown()
		{
			if (!shuttingDown)
			{
				shuttingDown = true;
#if USE_SEMAPHORE_FOR_RECEIVE_QUEUE
				receiveResetEvent.Release();
#endif

					HeatedBed.Stop();
				foreach (var extruder in Extruders)
				{
					extruder.Stop();
				}
			}
		}

		public void SimulateReboot()
		{
			commandIndex = 1;
			recievedCount = 0;
		}

		private string HomeAxis(string command)
		{
			if (command == "G28")
			{
				// naked G28 home all axis
				_destination = HomePosition;
			}
			else
			{
				// home the axis specified
				if (command.Contains("X"))
				{
					_destination.X = HomePosition.X;
				}

				if (command.Contains("Y"))
				{
					_destination.Y = HomePosition.Y;
				}

				if (command.Contains("Z"))
				{
					_destination.Z = HomePosition.Z;
				}
			}

			return "ok\n";
		}

		/// <summary>
		/// Set home offset calculated from toolhead position. This is implemented in smoothie.
		/// https://reprap.org/wiki/G-code#M306:_Set_home_offset_calculated_from_toolhead_position
		/// </summary>
		/// <param name="command">The line that this command issued with.</param>
		/// <returns>Printer status after command.</returns>
		private string SetHomeOffset(string command)
		{
			var newPosition = Destination;
			GetFirstNumberAfter("X", command, ref newPosition.X);
			GetFirstNumberAfter("Y", command, ref newPosition.Y);
			GetFirstNumberAfter("Z", command, ref newPosition.Z);

			HomePosition = newPosition;

			return "ok\n";
		}

		private string SetXYZProbeOffset(string command)
		{
			XYZProbeOffset = Destination;

			return "ok\n";
		}

		private readonly Random rand = new Random();

		private string ProbePosition(string command)
		{
			if (RunSlow)
			{
				Thread.Sleep(500);
			}

			return $"Bed Position X: {CurrentPosition.X} Y: {CurrentPosition.Y} Z: {-XYZProbeOffset.Z + rand.NextDouble():0.###}\n"
				 + "ok\n";
		}

		private string InitSdCard(string arg)
		{
			return "ok\n";
		}

		private string ListSdCard(string arg)
		{
			string[] responsList =
			{
				"Begin file list",
				"Item 1.gcode",
				"Item 2.gcode",
				"End file list",
			};

			foreach (var response in responsList)
			{
				this.QueueResponse(response + '\n');
			}

			return "ok\n";
		}

		private string ParseChecksumLine(string command)
		{
			recievedCount++;
			if (SimulateLineErrors && (recievedCount % 11) == 0)
			{
				command = "N-1 nthoeuc 654*";
			}

			if (!string.IsNullOrEmpty(command) && command[0] == 'N')
			{
				double lineNumber = 0;
				GetFirstNumberAfter("N", command, ref lineNumber);
				var checksumStart = command.LastIndexOf('*');
				var commandToChecksum = command.Substring(0, checksumStart);
				if (commandToChecksum[commandToChecksum.Length - 1] == ' ')
				{
					commandToChecksum = commandToChecksum.Substring(0, commandToChecksum.Length - 1);
				}

				double expectedChecksum = 0;
				GetFirstNumberAfter("*", command, ref expectedChecksum, checksumStart);
				int actualChecksum = CalculateChecksum(commandToChecksum);
				if ((lineNumber == commandIndex
					&& actualChecksum == expectedChecksum)
					|| command.Contains("M110"))
				{
					commandIndex++;
					int spaceIndex = command.IndexOf(' ') + 1;
					int endIndex = command.IndexOf('*');
					return command.Substring(spaceIndex, endIndex - spaceIndex);
				}
				else
				{
					return $"Error:checksum mismatch, Last Line: {commandIndex - 1}\nResend: {commandIndex}\n";
				}
			}
			else
			{
				return command;
			}
		}

		private string G92ResetPosition(string command)
		{
			var newDestination = Destination;
			GetFirstNumberAfter("X", command, ref newDestination.X);
			GetFirstNumberAfter("Y", command, ref newDestination.Y);
			GetFirstNumberAfter("Z", command, ref newDestination.Z);
			Destination = newDestination;
			// we are asserting that the printer is here
			CurrentPosition = Destination;

			double value = 0;
			if (GetFirstNumberAfter("E", command, ref value))
			{
				CurrentExtruder.EStart = value;
				CurrentExtruder.EDestination = value;
				CurrentExtruder.ECurrent = value;
				EPositionChanged?.Invoke(null, null);
			}

			return "ok\n";
		}

		private string SetBedTemperature(string command)
		{
			try
			{
				// M140 S210 or M190 S[temp]
				var sIndex = command.IndexOf('S') + 1;

				string temperature = command.Substring(sIndex);

				int spaceIndex = temperature.IndexOf(' ');
				if (spaceIndex != -1)
				{
					temperature = temperature.Substring(0, spaceIndex);
				}

				HeatedBed.TargetTemperature = int.Parse(temperature);
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		private string SetExtruderIndex(string command)
		{
			try
			{
				// T0, T1, T2 are the expected format
				var index = command.IndexOf('T') + 1;

				EnsureExtruderCount(index);

				var extruderIndex = command.Substring(index);

				ExtruderIndex = int.Parse(extruderIndex);
				ExtruderIndexChanged?.Invoke(this, null);
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		private string SetExtruderTemperature(string command)
		{
			try
			{
				// M104 S210 or M109 S[temp]

				double index = 0;
				GetFirstNumberAfter("T", command, ref index);

				double temp = 0;
				GetFirstNumberAfter("S", command, ref temp);

				EnsureExtruderCount(index);

				Extruders[(int)index].TargetTemperature = temp;
				ExtruderTemperatureChanged?.Invoke(this, null);
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		private void EnsureExtruderCount(double index)
		{
			if (index > Extruders.Count - 1)
			{
				// increase the number of extruders
				var newList = new List<Heater>(Extruders.Count + 1);
				foreach (var extruder in Extruders)
				{
					newList.Add(extruder);
				}

				for (int i = Extruders.Count + 1; i < index + 2; i++)
				{
					newList.Add(new Heater($"Hotend{i}") { CurrentTemperature = 27 });
				}

				Extruders = newList;
			}
		}

		private string SetLineCount(string command)
		{
			double number = commandIndex;
			if (GetFirstNumberAfter("N", command, ref number))
			{
				commandIndex = (long)number + 1;
			}

			return "ok\n";
		}

		private string ParseMovmentCommand(string command)
		{
			var newPosition = Destination;
			GetFirstNumberAfter("X", command, ref newPosition.X);
			GetFirstNumberAfter("Y", command, ref newPosition.Y);
			GetFirstNumberAfter("Z", command, ref newPosition.Z);

			if (newPosition.Y < 30)
			{
				int a = 0;
			}

			Destination = newPosition;

			double value = 0;
			if (GetFirstNumberAfter("F", command, ref value))
			{
				FeedRate = value;
			}

			if (GetFirstNumberAfter("E", command, ref value))
			{
				CurrentExtruder.EStart = CurrentExtruder.EDestination;
				CurrentExtruder.EDestination = value;
				CurrentExtruder.AbsoluteEPosition += CurrentExtruder.EDestination - CurrentExtruder.EStart;
				EPositionChanged?.Invoke(null, null);
			}

			return "ok\n";
		}

		private string Wait(string command)
		{
			try
			{
				// M140 S210 or M190 S[temp]
				double timeToWait = 0;
				if (!GetFirstNumberAfter("S", command, ref timeToWait))
				{
					if (GetFirstNumberAfter("P", command, ref timeToWait))
					{
						timeToWait /= 1000;
					}
				}

				Thread.Sleep((int)(timeToWait * 1000));
			}
			catch (Exception e)
			{
				Console.WriteLine(e);
			}

			return "ok\n";
		}

		private readonly object receiveLock = new object();
		private readonly Queue<string> receiveQueue = new Queue<string>();

#if !USE_SEMAPHORE_FOR_RECEIVE_QUEUE
		private AutoResetEvent receiveResetEvent = new AutoResetEvent(false);
#else
		private SemaphoreSlim receiveResetEvent = new(0);
#endif
		private readonly object sendLock = new object();
		private readonly Queue<string> sendQueue = new Queue<string>(new string[] { "Emulator v0.1\n" });

		public int BaudRate { get; set; }

		public int BytesToRead
		{
			get
			{
				if (sendQueue.Count == 0)
				{
					return 0;
				}

				return sendQueue?.Peek().Length ?? 0;
			}
		}

		public bool DtrEnable { get; set; }

		public bool IsOpen { get; private set; }

		public int ReadTimeout { get; set; }

		public bool RtsEnable { get; set; }

		public int WriteTimeout { get; set; }

		public Vector3 HomePosition { get; set; } = default(Vector3);

		public Vector3 XYZProbeOffset { get; set; } = new Vector3(0, 0, -5);

        /// <summary>
        /// The emulated printer has a conductive pad that can be used to probe the bed.
        /// </summary>
        public bool ConductivePad { get; set; }

		private AxisAlignedBoundingBox conductivePadTriggerRegion = new AxisAlignedBoundingBox(40, 210, -10, 60, 240, 0);

		public void Close()
		{
			this.ShutDown();
		}

		public void Open()
		{
			this.IsOpen = true;

#if !USE_SEMAPHORE_FOR_RECEIVE_QUEUE
			receiveResetEvent = new AutoResetEvent(false);
#else
			receiveResetEvent = new(0);
#endif

			this.ReadTimeout = 500;
			this.WriteTimeout = 500;

			Console.WriteLine("\n Initializing emulator (Speed: {0})", this.RunSlow ? "slow" : "fast");

			Task.Run(() =>
			{
				Thread.CurrentThread.Name = "EmulatorDtr";
				while (!shuttingDown)
				{
					if (this.DtrEnable != DsrState)
					{
						DsrState = this.DtrEnable;
						DsrChangeCount++;
					}

					Thread.Sleep(10);
				}
			});

			Task.Run(() =>
			{
				Thread.CurrentThread.Name = "EmulatorPipeline";

#if !USE_SEMAPHORE_FOR_RECEIVE_QUEUE
				while (!shuttingDown || receiveQueue.Count > 0)
				{
					if (receiveQueue.Count == 0)
					{
						if (shuttingDown)
						{
							return;
						}

						receiveResetEvent.WaitOne();
					}

					if (receiveQueue.Count == 0)
					{
						if (shuttingDown)
						{
							return;
						}

						Thread.Sleep(10);
					}
					else
					{
						string receivedLine;

						lock (receiveLock)
						{
							receivedLine = receiveQueue.Dequeue();
						}

						if (receivedLine?.Length > 0)
						{
							// Thread.Sleep(250);
							string emulatedResponse = GetCorrectResponse(receivedLine);

							lock (sendLock)
							{
								sendQueue.Enqueue(emulatedResponse);
							}
						}
					}
				}
#else
				for (; ;)
				{
					receiveResetEvent.Wait();

					string receivedLine;

					lock (receiveLock)
					{
						if (receiveQueue.Count <= 0)
						{
							// End of queue. The only other thing the semaphore is signalled for is shutdown.
							System.Diagnostics.Debug.Assert(shuttingDown);
							break;
						}

						receivedLine = receiveQueue.Dequeue();
					}

					if (receivedLine?.Length > 0)
					{
						// Thread.Sleep(250);
						string emulatedResponse = GetCorrectResponse(receivedLine);

						lock (sendLock)
						{
							sendQueue.Enqueue(emulatedResponse);
						}
					}
				}
#endif

			});
		}

		public void QueueResponse(string line)
		{
			sendQueue.Enqueue(line);
		}

		public int Read(byte[] buffer, int offset, int count) => throw new NotImplementedException();

		public string ReadExisting()
		{
			lock (sendLock)
			{
				return sendQueue.Dequeue();
			}
		}

		public void Write(string receivedLine)
		{
			lock (receiveLock)
			{
				receiveQueue.Enqueue(receivedLine);
			}

			// Release the main loop to process the received command
#if !USE_SEMAPHORE_FOR_RECEIVE_QUEUE
			receiveResetEvent.Set();
#else
			receiveResetEvent.Release();
#endif
		}

		public void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException();
	}
}