//******************************************************************************************************
//  SerialClient.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  07/24/2006 - Pinal C. Patel
//       Original version of source code generated.
//  09/06/2006 - J. Ritchie Carroll
//       Added bypass optimizations for high-speed serial port data access.
//  09/29/2008 - J. Ritchie Carroll
//       Converted to C#.
//  07/08/2009 - J. Ritchie Carroll
//       Added WaitHandle return value from asynchronous connection.
//  07/15/2009 - Pinal C. Patel
//       Modified Disconnect() to add error checking.
//  09/14/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  11/29/2010 - Pinal C. Patel
//       Corrected the implementation of ConnectAsync() method.
//  09/21/2011 - J. Ritchie Carroll
//       Added Mono implementation exception regions.
//  12/13/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO.Ports;
using System.Text;
using System.Threading;

namespace GSF.Communication
{
    /// <summary>
    /// Represents a communication client based on <see cref="SerialPort"/>.
    /// </summary>
    /// <example>
    /// This example shows how to use <see cref="SerialClient"/> for communicating with <see cref="SerialPort"/>:
    /// <code>
    /// using System;
    /// using GSF;
    /// using GSF.Communication;
    /// 
    /// class Program
    /// {
    ///     static SerialClient s_client;
    /// 
    ///     static void Main(string[] args)
    ///     {
    ///         // Initialize the client.
    ///         s_client = new SerialClient("Port=COM1; BaudRate=9600; Parity=None; StopBits=One; DataBits=8; DtrEnable=False; RtsEnable=False");
    ///         s_client.Initialize();
    ///         // Register event handlers.
    ///         s_client.ConnectionAttempt += s_client_ConnectionAttempt;
    ///         s_client.ConnectionEstablished += s_client_ConnectionEstablished;
    ///         s_client.ConnectionTerminated += s_client_ConnectionTerminated;
    ///         s_client.SendDataComplete += s_client_SendDataComplete;
    ///         s_client.ReceiveDataComplete += s_client_ReceiveDataComplete;
    ///         // Connect the client.
    ///         s_client.Connect();
    /// 
    ///         // Write user input to the serial port.
    ///         string input;
    ///         while (string.Compare(input = Console.ReadLine(), "Exit", true) != 0)
    ///         {
    ///             s_client.Send(input);
    ///         }
    /// 
    ///         // Disconnect the client on shutdown.
    ///         s_client.Dispose();
    ///     }
    /// 
    ///     static void s_client_ConnectionAttempt(object sender, EventArgs e)
    ///     {
    ///         Console.WriteLine("Client is connecting to serial port.");
    ///     }
    /// 
    ///     static void s_client_ConnectionEstablished(object sender, EventArgs e)
    ///     {
    ///         Console.WriteLine("Client connected to serial port.");
    ///     }
    /// 
    ///     static void s_client_ConnectionTerminated(object sender, EventArgs e)
    ///     {
    ///         Console.WriteLine("Client disconnected from serial port.");
    ///     }
    /// 
    ///     static void s_client_SendDataComplete(object sender, EventArgs e)
    ///     {
    ///         Console.WriteLine(string.Format("Sent data - {0}", s_client.TextEncoding.GetString(s_client.Client.SendBuffer)));
    ///     }
    /// 
    ///     static void s_client_ReceiveDataComplete(object sender, EventArgs&lt;byte[], int&gt; e)
    ///     {
    ///         Console.WriteLine(string.Format("Received data - {0}", s_client.TextEncoding.GetString(e.Argument1, 0, e.Argument2)));
    ///     }
    /// }
    /// </code>
    /// </example>
    public class SerialClient : ClientBase
    {
        #region [ Members ]

        // Constants

        /// <summary>
        /// Specifies the default value for the <see cref="ClientBase.ConnectionString"/> property.
        /// </summary>
        public const string DefaultConnectionString = "Port=COM1; BaudRate=9600; Parity=None; StopBits=One; DataBits=8; DtrEnable=False; RtsEnable=False; ReceivedBytesThreshold=512";

        /// <summary>
        /// Default value for <see cref="ReceivedBytesThreshold"/> property.
        /// </summary>
        public const int DefaultReceivedBytesThreshold = 1;

        // Fields
        private readonly TransportProvider<SerialPort> m_serialClient;
        private Dictionary<string, string> m_connectData;
        private ManualResetEvent m_connectionHandle;
        private Thread m_connectionThread;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Initializes a new instance of the <see cref="SerialClient"/> class.
        /// </summary>
        public SerialClient() : this(DefaultConnectionString)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SerialClient"/> class.
        /// </summary>
        /// <param name="connectString">Connect string of the <see cref="SerialClient"/>. See <see cref="DefaultConnectionString"/> for format.</param>
        public SerialClient(string connectString) : base(TransportProtocol.Serial, connectString) => m_serialClient = new TransportProvider<SerialPort>();

        /// <summary>
        /// Initializes a new instance of the <see cref="SerialClient"/> class.
        /// </summary>
        /// <param name="container"><see cref="IContainer"/> object that contains the <see cref="SerialClient"/>.</param>
        public SerialClient(IContainer container) : this() => container?.Add(this);

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets the <see cref="SerialPort"/> object for the <see cref="SerialClient"/>.
        /// </summary>
        [Browsable(false)]
        public SerialPort Client => m_serialClient.Provider;

        /// <summary>
        /// Gets the server URI of the <see cref="SerialClient"/>.
        /// </summary>
        [Browsable(false)]
        public override string ServerUri => $"{TransportProtocol}://{m_connectData["port"]}".ToLower();

        /// <summary>
        /// Gets or sets the needed number of bytes in the internal input buffer before a <see cref="ClientBase.OnReceiveDataComplete"/> event occurs.
        /// </summary>
        /// <remarks>
        /// This option is ignored under Mono deployments.
        /// </remarks>
        [DefaultValue(DefaultReceivedBytesThreshold)]
        public int ReceivedBytesThreshold { get; set; } = DefaultReceivedBytesThreshold;

        /// <summary>
        /// Gets the descriptive status of the <see cref="SerialClient"/>.
        /// </summary>
        public override string Status
        {
            get
            {
                if (m_connectData == null)
                    return base.Status;

                StringBuilder status = new StringBuilder();

                status.Append(base.Status);

                if (m_connectData.TryGetValue("port", out string value))
                    status.AppendLine($"                  COM port: {value}");

                if (m_connectData.TryGetValue("baudRate", out value))
                    status.AppendLine($"                 Baud rate: {value}bps");

                if (m_connectData.TryGetValue("parity", out value))
                    status.AppendLine($"                    Parity: {value}");

                if (m_connectData.TryGetValue("stopBits", out value))
                    status.AppendLine($"                 Stop bits: {value}");

                if (m_connectData.TryGetValue("dataBits", out value))
                    status.AppendLine($"                 Data bits: {value}");

                if (m_connectData.TryGetValue("receivedBytesThreshold", out value))
                    status.AppendLine($"  Received bytes threshold: {value}");

                return status.ToString();
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Reads a number of bytes from the current received data buffer and writes those bytes into a byte array at the specified offset.
        /// </summary>
        /// <param name="buffer">Destination buffer used to hold copied bytes.</param>
        /// <param name="startIndex">0-based starting index into destination <paramref name="buffer"/> to begin writing data.</param>
        /// <param name="length">The number of bytes to read from current received data buffer and write into <paramref name="buffer"/>.</param>
        /// <returns>The number of bytes read.</returns>
        /// <remarks>
        /// This function should only be called from within the <see cref="ClientBase.ReceiveData"/> event handler. Calling this method outside
        /// this event will have unexpected results.
        /// </remarks>
        /// <exception cref="InvalidOperationException">No received data buffer has been defined to read.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> or <paramref name="length"/> is less than 0 -or- 
        /// <paramref name="startIndex"/> and <paramref name="length"/> will exceed <paramref name="buffer"/> length.
        /// </exception>
        public override int Read(byte[] buffer, int startIndex, int length)
        {
            buffer.ValidateParameters(startIndex, length);

            if (m_serialClient.ReceiveBuffer == null)
                throw new InvalidOperationException("No received data buffer has been defined to read.");

            int sourceLength = m_serialClient.BytesReceived - ReadIndex;
            int readBytes = length > sourceLength ? sourceLength : length;
            Buffer.BlockCopy(m_serialClient.ReceiveBuffer, ReadIndex, buffer, startIndex, readBytes);

            // Update read index for next call
            ReadIndex += readBytes;

            if (ReadIndex >= m_serialClient.BytesReceived)
                ReadIndex = 0;

            return readBytes;
        }

        /// <summary>
        /// Disconnects the <see cref="SerialClient"/> from the <see cref="SerialPort"/>.
        /// </summary>
        public override void Disconnect()
        {
            if (CurrentState == ClientState.Disconnected)
                return;

            if (m_serialClient.Provider != null)
            {
                m_serialClient.Provider.DataReceived -= SerialPort_DataReceived;
                m_serialClient.Provider.ErrorReceived -= SerialPort_ErrorReceived;
            }

            m_serialClient.Reset();

            m_connectionThread?.Abort();

            OnConnectionTerminated();
        }

        /// <summary>
        /// Connects the <see cref="SerialClient"/> to the <see cref="SerialPort"/> asynchronously.
        /// </summary>
        /// <exception cref="InvalidOperationException">Attempt is made to connect the <see cref="SerialClient"/> when it is connected.</exception>
        /// <returns><see cref="WaitHandle"/> for the asynchronous operation.</returns>
        public override WaitHandle ConnectAsync()
        {
            m_connectionHandle = (ManualResetEvent)base.ConnectAsync();

            m_serialClient.SetReceiveBuffer(ReceiveBufferSize);

            m_serialClient.Provider = new SerialPort
            {
            #if !MONO
                ReceivedBytesThreshold = int.Parse(m_connectData["receivedBytesThreshold"]),
            #endif
                PortName = m_connectData["port"],
                BaudRate = int.Parse(m_connectData["baudRate"]),
                DataBits = int.Parse(m_connectData["dataBits"]),
                Parity = (Parity)Enum.Parse(typeof(Parity), m_connectData["parity"], true),
                StopBits = (StopBits)Enum.Parse(typeof(StopBits), m_connectData["stopBits"], true)
            };

            m_serialClient.Provider.DataReceived += SerialPort_DataReceived;
            m_serialClient.Provider.ErrorReceived += SerialPort_ErrorReceived;

            if (m_connectData.ContainsKey("dtrEnable"))
                m_serialClient.Provider.DtrEnable = m_connectData["dtrEnable"].ParseBoolean();

            if (m_connectData.ContainsKey("rtsEnable"))
                m_serialClient.Provider.RtsEnable = m_connectData["rtsEnable"].ParseBoolean();

            m_connectionThread = new Thread(OpenPort)
            {
                IsBackground = true
            };

            m_connectionThread.Start();

            return m_connectionHandle;
        }

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="SerialClient"/> and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (m_disposed)
                return;

            try
            {
                // This will be done regardless of whether the object is finalized or disposed.
                if (!disposing)
                    return;

                // This will be done only when the object is disposed by calling Dispose().
                m_connectionHandle?.Dispose();
            }
            finally
            {
                m_disposed = true;          // Prevent duplicate dispose.
                base.Dispose(disposing);    // Call base class Dispose().
            }
        }

        /// <summary>
        /// Validates the specified <paramref name="connectionString"/>.
        /// </summary>
        /// <param name="connectionString">Connection string to be validated.</param>
        /// <exception cref="ArgumentException">Port property is missing.</exception>
        /// <exception cref="ArgumentException">BaudRate property is missing.</exception>
        /// <exception cref="ArgumentException">Parity property is missing.</exception>
        /// <exception cref="ArgumentException">StopBits property is missing.</exception>
        /// <exception cref="ArgumentException">DataBits property is missing.</exception>
        protected override void ValidateConnectionString(string connectionString)
        {
            m_connectData = connectionString.ParseKeyValuePairs();

            if (!m_connectData.ContainsKey("port"))
                throw new ArgumentException($"Port property is missing (Example: {DefaultConnectionString})");

            if (!m_connectData.ContainsKey("baudRate") || !int.TryParse(m_connectData["baudRate"], out _))
                throw new ArgumentException($"BaudRate property is missing or invalid (Example: {DefaultConnectionString})");

            if (!m_connectData.ContainsKey("parity"))
                throw new ArgumentException($"Parity property is missing (Example: {DefaultConnectionString})");

            if (!m_connectData.ContainsKey("stopBits"))
                throw new ArgumentException($"StopBits property is missing (Example: {DefaultConnectionString})");

            if (!m_connectData.ContainsKey("dataBits") || !int.TryParse(m_connectData["dataBits"], out _))
                throw new ArgumentException($"DataBits property is missing or invalid (Example: {DefaultConnectionString})");

            if (!m_connectData.ContainsKey("receivedBytesThreshold") || !int.TryParse(m_connectData["receivedBytesThreshold"], out _))
                m_connectData["receivedBytesThreshold"] = ReceivedBytesThreshold.ToString();
        }

        /// <summary>
        /// Sends (writes) data to the <see cref="SerialPort"/> asynchronously.
        /// </summary>
        /// <param name="data">The buffer that contains the binary data to be sent (written).</param>
        /// <param name="offset">The zero-based position in the <paramref name="data"/> at which to begin sending (writing) data.</param>
        /// <param name="length">The number of bytes to be sent (written) from <paramref name="data"/> starting at the <paramref name="offset"/>.</param>
        /// <returns><see cref="WaitHandle"/> for the asynchronous operation.</returns>
        protected override WaitHandle SendDataAsync(byte[] data, int offset, int length)
        {
            // Send data to the file asynchronously.
            WaitHandle handle = m_serialClient.Provider.BaseStream.BeginWrite(data, offset, length, SendDataAsyncCallback, null).AsyncWaitHandle;

            // Notify that the send operation has started.
            m_serialClient.Statistics.UpdateBytesSent(length);
            OnSendDataStart();

            // Return the async handle that can be used to wait for the async operation to complete.
            return handle;
        }

        /// <summary>
        /// Callback method for asynchronous send operation.
        /// </summary>
        private void SendDataAsyncCallback(IAsyncResult asyncResult)
        {
            try
            {
                // Send operation is complete.
                m_serialClient.Provider.BaseStream.EndWrite(asyncResult);
                OnSendDataComplete();
            }
            catch (Exception ex)
            {
                // Send operation failed to complete - don't raised exceptions for a closed port
                if (!m_disposed && m_serialClient.Provider != null && m_serialClient.Provider.IsOpen)
                    OnSendDataException(ex);
            }
        }

        /// <summary>
        /// Connects to the <see cref="SerialPort"/>.
        /// </summary>
        private void OpenPort()
        {
            int connectionAttempts = 0;

            while (MaxConnectionAttempts == -1 || connectionAttempts < MaxConnectionAttempts)
            {
                try
                {
                    OnConnectionAttempt();
                    m_serialClient.Provider.Open();
                    m_connectionHandle.Set();
                    OnConnectionEstablished();

                    break;
                }
                catch (ThreadAbortException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    Thread.Sleep(1000);
                    connectionAttempts++;
                    OnConnectionException(ex);
                }
            }
        }

        /// <summary>
        /// Receive (read) data from the <see cref="SerialPort"/> (.NET serial port class raises this event when data is available).
        /// </summary>
        private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                int bytesRead = 0;

                // Retrieve data from the port.
                while (bytesRead < m_serialClient.Provider.BytesToRead)
                    bytesRead += m_serialClient.Provider.Read(m_serialClient.ReceiveBuffer, bytesRead, m_serialClient.ReceiveBuffer.Length - bytesRead);

                m_serialClient.BytesReceived = bytesRead;
                m_serialClient.Statistics.UpdateBytesReceived(bytesRead);

                // Notify of the retrieved data.
                OnReceiveDataComplete(m_serialClient.ReceiveBuffer, bytesRead);
            }
            catch (Exception ex)
            {
                // Don't raised exceptions for a closed port
                if (!m_disposed && m_serialClient.Provider != null && m_serialClient.Provider.IsOpen)
                    OnReceiveDataException(ex);
            }
        }

        /// <summary>
        /// Receive (read) error data from the <see cref="SerialPort"/> (.NET serial port class raises this event when error occurs).
        /// </summary>
        private void SerialPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e) => OnReceiveDataException(new SerialException(e.EventType));

        /// <summary>
        /// Raises the <see cref="ClientBase.ConnectionException"/> event.
        /// </summary>
        /// <param name="ex">Exception to send to <see cref="ClientBase.ConnectionException"/> event.</param>
        protected override void OnConnectionException(Exception ex)
        {
            base.Disconnect();
            base.OnConnectionException(ex);
        }

        #endregion
    }
}