using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Threading;
using log4net;

namespace TBF.BenchControl.Cameras.IdcCamera
{
	public class SerialLayer
	{
		static readonly ILog log = LogManager.GetLogger(typeof(SerialLayer));

		///
		/// Set to true when shut-down is in progress
		///
		public static bool g_shutDown = false;
		public bool m_disconnecting;

		int cameraNr;
		int comPortNr;
		int baudRate;
		int readTimeout;
		string imagesPath;

		Queue<byte> readQueue;
		ManualResetEvent queueNotEmptyEvent;

		SerialFileIO serialFileIO;

		SerialPort serialPort;

		byte[] singleCharWrBuff;		/// predefined serial write buffer for 1 byte
		byte[] twoCharsWrBuff;			/// predefined serial write buffer for 2 bytes

		#region Content switching, multiplexing

		const byte CTRLZ = 26;
		const byte CTRLQ = 17;
		const byte XON   = 17;
		const byte CTRLS = 19;
		const byte XOFF  = 19;

		/// <summary>
		/// Multiplexed channel content ID (destination ID)
		/// </summary>
		enum Mux
		{
			Console,	/// Command console, identified by  CTRLZ + 'C' byte sequence
			File,		/// File download (ICD camera -> file), identified by CTRLZ = 'F' byte sequence
		}

		Mux lastWriteContentId;
		Mux currentReadContentId;
		bool lastReadCtrlZ;

		#endregion

		/// <summary>
		/// Create a SerialLayer instance.
		/// </summary>
        /// <param name="cameraNr">0-based camera number</param>
		/// <param name="comPortNr">COM port number 1..999</param>
		/// <param name="baudRate">Baud rate 57600 or 115200</param>
		/// <param name="readTimeout">Read timeout in ms</param>
		/// <param name="imagesPath">Path to a folder where received files are stored</param>
		public SerialLayer(int cameraNr, int comPortNr, int baudRate, int readTimeout, string imagesPath)
		{
            log.InfoFormat("new SerialLayer(ix={0}, com{1}, {2}Bd, tmout={3}ms, ipath={4})", cameraNr, comPortNr, baudRate, readTimeout, imagesPath);

			this.cameraNr = cameraNr;
			this.comPortNr = comPortNr;
			this.baudRate = baudRate;
			this.readTimeout = readTimeout;
			this.imagesPath = imagesPath;

			singleCharWrBuff = new byte[1];
			twoCharsWrBuff = new byte[2];
			twoCharsWrBuff[0] = CTRLZ;

			m_disconnecting = false;
			readQueue = new Queue<byte>();
			queueNotEmptyEvent = new ManualResetEvent(false); 

			serialPort = new SerialPort();
			serialPort.DataReceived += serialPort_DataReceived;
		}

		/// <summary>
		/// Open the serial port.
		/// </summary>
		/// <returns>RetVal.OK or RetVal.CANNOT_OPEN_COMPORT</returns>
		public RetVal OpenPort()
		{
			log.Info("OpenPort()");

			if (serialPort.IsOpen) return RetVal.OK;

			if (comPortNr<1 || comPortNr>999) return RetVal.CannotOpenComPort;

			m_disconnecting = false;

			/// Initialize FIFO, content switching, multiplexing
			readQueue.Clear();
			lastWriteContentId = Mux.Console;
			currentReadContentId = Mux.Console;
			lastReadCtrlZ = false;

			serialFileIO = new SerialFileIO(cameraNr, imagesPath);

			/// Finally open the serial port
			try
			{
				serialPort.PortName = "COM" + comPortNr.ToString();
				serialPort.BaudRate = baudRate;
				serialPort.Parity = Parity.None;
				serialPort.DataBits = 8;
				serialPort.StopBits = StopBits.One;
				serialPort.Handshake = Handshake.None;
				serialPort.RtsEnable = true;
				serialPort.DtrEnable = true;

				serialPort.ReadTimeout = 1000000;	/// Sufficiently large, read timeout is applied to FIFO read
				serialPort.WriteTimeout = SerialPort.InfiniteTimeout;

				serialPort.Open();
			}
			catch (Exception e)
			{
				log.Error("Cannot open serial port COM" + comPortNr.ToString(), e);
				return RetVal.CannotOpenComPort;
			}

			return RetVal.OK;
		}

		/// <summary>
		/// Close the serial port.
		/// </summary>
		public void ClosePort()
		{
			log.InfoFormat("{0}: ClosePort()", cameraNr);
			if (!serialPort.IsOpen) return;
			m_disconnecting = true;				/// Complete any pending I/O operations
			serialPort.Close();
		}


		public void FifoFlush()
		{
			lock (readQueue) { readQueue.Clear(); }
		}

		public void UnlockLastRead()
		{
			lock (readQueue) { readQueue.Enqueue((byte)' '); }	/// quit infinite fifo.Get() waiting

		}

		/// <summary>
		/// Serial port data received event handler method
		/// </summary>
		/// <param name="sender">SerialPort</param>
		/// <param name="e"></param>
		void serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
		{
			byte[] data = new byte[serialPort.BytesToRead];
			serialPort.Read(data, 0, data.Length);

			foreach (byte dat in data)
			{
				byte b = dat;

				if (lastReadCtrlZ)
				{
					lastReadCtrlZ = false;

					if (dat == (byte)'C')
					{
						currentReadContentId = Mux.Console;		/// Ctrl-Z + 'C' sequence detected: Mux.Console
						continue;
					}
					if (dat == (byte)'F')
					{
						currentReadContentId = Mux.File;		/// Ctrl-Z + 'F' sequence detected: Mux.File
						continue;
					}

					if (dat == (byte)'1') b = (byte)XON;		/// Ctrl-Z + '1' sequence detected: XON
					if (dat == (byte)'2') b = (byte)XOFF;		/// Ctrl-Z + '2' sequence detected: XOFF
				}
				else if (dat == CTRLZ)
				{
					lastReadCtrlZ = true;
					continue;
				}
				
				///
				/// Process demultiplexed data byte b appropriately
				///
				if (currentReadContentId == Mux.Console)
				{
					lock (readQueue)
					{
						readQueue.Enqueue(b);
						queueNotEmptyEvent.Set();
					}
				}
				else
				{
					serialFileIO.ProcessByte(b);
				}
			}
		}


		#region Read from readQueue

		/// <summary>
		/// Read one byte from the console content FIFO.
		/// </summary>
		/// <param name="response">Received byte</param>
		/// <returns>RetVal.OK, RetVal.COMM_TIMEOUT or RetVal.SHUTDOWN</returns>
		public RetVal ReadByte(out byte response)
		{
			if (g_shutDown || m_disconnecting)
			{
				response = 0;
                log.DebugFormat("{0}: ReadByte() returns RetVal.SHUTDOWN", cameraNr);
				return RetVal.ShutdownInProgress;
			}

			lock (readQueue)
			{
				if (readQueue.Count > 0)
				{
					response = readQueue.Dequeue();
					return RetVal.OK;
				}
				else
				{
					queueNotEmptyEvent.Reset();
				}
			}

			if (queueNotEmptyEvent.WaitOne(readTimeout))
			{
				lock (readQueue)
				{
					response = readQueue.Dequeue();
					return RetVal.OK;
				}
			}
			else
			{
				response = 0;
                log.ErrorFormat("{0}: ReadByte() returns RetVal.COMM_TIMEOUT", cameraNr);
				return RetVal.CommTimeout;
			}
		}

		/// <summary>
		/// Read bytes and form the output string until a delimiter character is received.
		/// Output string excludes the delimiter.
		/// </summary>
		/// <param name="delimiter">Delimiter character</param>
		/// <param name="text">Output string</param>
		/// <returns>RetVal.OK, RetVal.COMM_TIMEOUT or RetVal.SHUTDOWN</returns>
		RetVal ReadUntil(char delimiter, out string output)
		{
			StringBuilder buffer = new StringBuilder();

			while (true)
			{
				RetVal retv;
				byte znak;

				if (RetVal.OK != (retv = ReadByte(out znak)))
				{
					output = buffer.ToString();		/// Copy data received so far to the output
					log.Error("ReadUntil('" + delimiter.ToString() + "', out \"" + output + "\") returns " + retv.ToString());
					return retv;					/// Communication error
				}
				char c = (char)znak;
				if (c == delimiter) break;
				buffer.Append(c);
			}

			output = buffer.ToString();
			return RetVal.OK;
		}

		/// <summary>
		/// Read bytes and form the output string until "\r\n" is received.
		/// Output string excludes "\r\n".
		/// </summary>
		/// <param name="text">Output string</param>
		/// <returns>RetVal.OK, RetVal.COMM_TIMEOUT, RetVal.COMM_ERROR or RetVal.SHUTDOWN</returns>
		RetVal ReadLine(out string output)
		{
			RetVal retv = ReadUntil('\r', out output);
			if (retv != RetVal.OK) return retv;

			/// Read the expected '\n'
			byte znak;
			if (RetVal.OK != (retv = ReadByte(out znak))) return retv;
			if (znak != (byte)'\n')
			{
				log.Error("ReadLine(out \"" + output + "\") returns " + retv.ToString());
				return RetVal.CommError;
			}

			return RetVal.OK;
		}

		#endregion


		#region Write to serial port

		/// <summary>
		/// Write one byte (console content) to the serial port.
		/// </summary>
		/// <param name="b">Byte to send</param>
		public void WriteByte(byte b)
		{
			WriteByte_Mux(b, Mux.Console);
		}

		/// <summary>
		/// Write one byte from any source (either console or file) to the serial port.
		/// Perform multiplexing - expansion to escape sequences using CTRLZ.
		/// </summary>
		/// <param name="b">Byte to send</param>
		/// <param name="contentId">Mux.Console or Mux.File</param>
		void WriteByte_Mux(byte b, Mux contentId)
		{
			if (contentId != lastWriteContentId)
			{
				/// Switching contentId when writing to a camera is not supported yet,
				/// therefore this code within { } wont be invoked right now.

				/// Send the content switch command CTRLZ + contentId
				twoCharsWrBuff[1] = (contentId == Mux.Console) ? (byte)'C' : (byte)'F';
				serialPort.Write(twoCharsWrBuff, 0, 2);
				lastWriteContentId = contentId;
				return;
			}

			if (b == CTRLZ)
			{
				/// If 'b'=CTRLZ send CTRLZ + CTRLZ
				twoCharsWrBuff[1] = CTRLZ;
				serialPort.Write(twoCharsWrBuff, 0, 2);
				return;
			}
			else if (b == XON)
			{
				/// If 'b'=XON send CTRLZ + '1'
				twoCharsWrBuff[1] = (byte)'1';
				serialPort.Write(twoCharsWrBuff, 0, 2);
				return;
			}
			else if (b == XOFF)
			{
				/// If 'b'=XON send CTRLZ + '2'
				twoCharsWrBuff[1] = (byte)'2';
				serialPort.Write(twoCharsWrBuff, 0, 2);
				return;
			}
			else
			{
				/// Send a single regular byte 'b'
				singleCharWrBuff[0] = b;
				serialPort.Write(singleCharWrBuff, 0, 1);
				return;
			}
		}

		/// <summary>
		/// Write a string (console content) to the serial port.
		/// </summary>
		/// <param name="str">String to send</param>
		public void WriteString(string str)
		{
			if (str == null) return;		/// There is nothing to send - return

			if (str.EndsWith("\r\n"))
			{
                log.InfoFormat("{0}: WriteString(\"{1}\\r\\n\")", cameraNr, str.Substring(0, str.Length - 2));
			}
			else
			{
                log.InfoFormat("{0}: WriteString(\"{1}\")", cameraNr, str);
			}

			for (int i = 0; i < str.Length; i++) WriteByte((byte)str[i]);
		}

		#endregion


//-------------------------------------------------------------------------------
/////////////////////////  Higher level console commands  ///////////////////////
//-------------------------------------------------------------------------------

		//---------------------------------------------------------------------------
		// Sends the specified command and waits for the following response.
		//		strings separated by spaces and terminated by <cr>
		// Stores response into an array of CStrings pointed by pStrArray.
		//
		// Returns:
		//		positive numbers and 0
		//			The number of fields in the response. Returned number may be
		//			greater then arrayLen. Only the first arrayLen strings are saved.
		//		negative numbers
		//			negative error code returned by lower level functions:
		//				-RetVal.COMM_TIMEOUT	      = timeout occurred
		//				-RetVal.COMM_ERROR = all other errors
		//---------------------------------------------------------------------------
		public int CommandStr(string cmd, out string[] strArray, int nrFields, out string remaining)
		{
			StringBuilder tmp = new StringBuilder();
			StringBuilder logStr = new StringBuilder();
			StringBuilder rem = new StringBuilder();

			lock (readQueue) { readQueue.Clear(); }
			WriteString(cmd);						/// send

			strArray = null;
			remaining = String.Empty;

			string beforeGT;
			RetVal retv = ReadUntil('>', out beforeGT);
			if (retv != RetVal.OK) return -(int)retv;	/// If Read... fails quit the loop ...
														/// ... and return negative error code
			/// Read the expected ' '
			byte znak;
			if (RetVal.OK != (retv = ReadByte(out znak))) return -(int)retv;
			if (znak != (byte)' ') return -(int)RetVal.CommError;

			/// Read fields after '>', parse the first field (the return code)
			string received;
			retv = ReadLine(out received);
			if (retv != RetVal.OK) return -(int)retv;
			strArray = received.Split(new char[] { ' ' }, nrFields + 1);

            log.InfoFormat("{0}: Received: > {1}", cameraNr, received);

			/// Skip until '$' received
			retv = ReadUntil('$', out received);
			if (retv != RetVal.OK) return -(int)retv;

			/// Parse the return code (the 1st field)
			int returnCode;
			if (!int.TryParse(strArray[0], out returnCode) || returnCode < 0) return returnCode;

			if (strArray.GetLength(0) == nrFields + 1) remaining = strArray[nrFields];

			return Math.Min(strArray.GetLength(0), nrFields);
		}

		//---------------------------------------------------------------------------
		// Sends the specified command and waits for the following response.
		//		integers separated by spaces and terminated by <cr>
		// Stores response into an integer array pointed by pIntArray;
		//
		// Returns:
		//		positive numbers and 0
		//			The number of fields in the response. Returned number may be
		//			greater then arrayLen. Only the first arrayLen strings are saved.
		//		negative numbers
		//			negative error code returned by lower level functions
		//---------------------------------------------------------------------------
		public int CommandInt(string cmd, out int[] intArray, int nrFields, out string remaining)
		{
			string[] strArray;
			int retv = CommandStr(cmd, out strArray, nrFields, out remaining);

			if (retv <= 0)
			{
				intArray = null;
				return retv;
			}

			intArray = new int[retv];
			for (int i = 0; i < retv; i++)
			{
				 int.TryParse(strArray[i], out intArray[i]);
			}

			return retv;
		}

		//---------------------------------------------------------------------------
		// Sends the specified command and waits for the following response.
		//		real numbers separated by spaces and terminated by <cr>
		// Stores response into a double array pointed by pDblArray;
		//
		// Returns:
		//		positive numbers and 0
		//			The number of fields in the response. Returned number may be
		//			greater then arrayLen. Only the first arrayLen strings are saved.
		//		negative numbers
		//			negative error code returned by lower level functions
		//---------------------------------------------------------------------------
		public int CommandDbl(string cmd, out double[] dblArray, int arrayLen, out string remaining)
		{
			string[] strArray;
			int retv = CommandStr(cmd, out strArray, arrayLen, out remaining);

			if (retv <= 0)
			{
				dblArray = null;
				return retv;
			}

			dblArray = new double[retv];
			for (int i = 0; i < retv; i++)
			{
				double.TryParse(strArray[i], out dblArray[i]);
			}

			return retv;
		}

		/// <summary>
		/// Get camera version string
		/// </summary>
		/// <param name="versionStr">Version string</param>
		/// <returns>RetVal.OK, RetVal.COMM_TIMEOUT, RetVal.COMM_ERROR, RetVal.SHUTDOWN or a camera ret.code (1..999)</returns>
		public RetVal GetVer(out string versionStr)
		{
            log.DebugFormat("{0}: GetVer()", cameraNr);

			versionStr = String.Empty;
			StringBuilder tmp = new StringBuilder();
			const int arrayLen = 1;
			string[] strArray = new string[arrayLen];

			lock (readQueue) { readQueue.Clear(); }

			WriteString("info\r\n");				/// Send

			/// Read info message until '>'
			string infoMessage;
			RetVal retv = ReadUntil('>', out infoMessage);
			if (retv != RetVal.OK) return retv;
            log.DebugFormat("{0}: InfoMessage: {1}", cameraNr, infoMessage);

			/// Read the expected ' '
			byte znak;
			if (RetVal.OK != (retv = ReadByte(out znak))) return retv;
			if (znak != (byte)' ') return RetVal.CommError;

			/// Read fields after '>', parse the first field (the return code)
			string tempStr;
			retv = ReadLine(out tempStr);
			if (retv != RetVal.OK) return retv;
			string[] fields = tempStr.Split(new char[] { ' ' }, 2);
			int returnCode;
			if (!int.TryParse(fields[0], out returnCode) || returnCode < 0) return (RetVal)(-returnCode);

			/// Skip until '$' received
			retv = ReadUntil('$', out tempStr);
			if (retv != RetVal.OK) return retv;

			/// Parse the infoMessage
			int pos1 = infoMessage.IndexOf("version = ");
			if (pos1 != -1)
			{
				pos1 += "version = ".Length;
				int pos2 = infoMessage.IndexOf("\r\n", pos1);
				versionStr = infoMessage.Substring(pos1, pos2 - pos1);

                log.InfoFormat("{0}: GetVer(out \"" + versionStr + "\")", cameraNr);
				return RetVal.OK;
			}

            log.ErrorFormat("{0}: GetVer(...) returns RetVal.OP_FAILED", cameraNr);
			return RetVal.CommError;	/// Cannot read the version string
		}

		//----------------------------------------------------------------------------
		// Check if livestream of serial characters is coming.
		//
		// Returns:
		//		RetVal.OK ..... not (OK),
		//      RetVal.BUSY ... yes (camera needs to be restarted)
		//----------------------------------------------------------------------------
		RetVal CheckLiveStream()
		{
			byte znak;

			// 500 characters without timeout = stream
			// copyright message is +/-350 characters long

			for (int i=0; i<500; i++)
			{
				if (RetVal.CommTimeout == ReadByte(out znak)) return RetVal.OK;   /// timeout ... no stream (OK)
			}

#if true
			// try to stop the stream
			lock (readQueue) { readQueue.Clear(); }

			WriteString("\r\nstopstream\r\n");
			while (RetVal.CommTimeout != ReadByte(out znak)) { };
			return RetVal.OK;
#else
			// just report a running stream (RetVal.Busy)
			return RetVal.Busy;
#endif
		}

	}
}