// **********************************************************************************************************
//    CommDeviceSerialAsync.cs
//    4/3/2024
//    NGI - Next Generation Interceptor
//    
//    Contract No. HQ0856-21-C-0003/1022000209
//    
//    THIS DOCUMENT DOES NOT CONTAIN TECHNOLOGY OR TECHNICAL DATA CONTROLLED UNDER EITHER THE U.S. 
//    INTERNATIONAL TRAFFIC IN ARMS REGULATIONS OR THE U.S. EXPORT ADMINISTRATION REGULATIONS.
//    
//    RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION PROPRIETARY TO RAYTHEON 
//    COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. 
//    DISCLOSURE TO UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO RAYTHEON 
//    COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS CONTENTS SHALL BE FURNISHED OR DISCLOSED 
//    TO OR COPIED OR USED BY PERSONS OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF 
//    RAYTHEON COMPANY.
//    
//    UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
//    
//    DESTRUCTION NOTICE: FOR CLASSIFIED DOCUMENTS FOLLOW THE PROCEDURES IN DOD 5220.22-M, 
//    NATIONAL INDUSTRIAL SECURITY PROGRAM OPERATING MANUAL, FEBRUARY 2006, 
//    INCORPORATING CHANGE 1, MARCH 28, 2013, CHAPTER 5, SECTION 7, OR DODM 5200.01-VOLUME 3, 
//    DOD INFORMATION SECURITY PROGRAM: PROTECTION OF CLASSIFIED INFORMATION, ENCLOSURE 3, 
//    SECTION 17. FOR CONTROLLED UNCLASSIFIED INFORMATION FOLLOW THE PROCEDURES IN DODM 5200.01-VOLUME 4, 
//    INFORMATION SECURITY PROGRAM: CONTROLLED UNCLASSIFIED INFORMATION.
//    
//    CONTROLLED BY: MISSILE DEFENSE AGENCY
//    CONTROLLED BY: GROUND-BASED MIDCOURSE DEFENSE PROGRAM OFFICE
//    CUI CATEGORY: CTI 
//    DISTRIBUTION/DISSEMINATION CONTROL: F 
//    POC: Alex Kravchenko (1118268)
// **********************************************************************************************************
using System;
using System.IO.Ports;
using System.Threading;
using System.Threading.Tasks;
using NLog;
using Raytheon.Common;

namespace Raytheon.Instruments
{
   /// <summary>
   /// A sim communication device
   /// </summary>
   public class CommDeviceSerialAsync : ICommAsync
   {
      #region PrivateClassMembers

      private uint _defaultReadTimeout;
      private uint _defaultSendTimeout;
      private uint _defaultReadBufferSize;
      private object _syncObj = new object();

      private SerialPort _serialPort;

      private string _comPortName;
      private int _baudRate;
      private Parity _parity;
      private int _dataBits;
      private StopBits _stopBits;

      private readonly string _name;
      private State _state;

      private readonly ILogger _logger;

      private readonly IConfigurationManager _configurationManager;
      private readonly IConfiguration _configuration;

      #endregion

      public bool ClearErrors() => false;
      public bool FrontPanelEnabled { get => false; set => throw new NotImplementedException(); }
      public bool DisplayEnabled { get => false; set => throw new NotImplementedException(); }
      public string DetailedStatus => $"This is a TCP/IP Device called {_name}";
      public InstrumentMetadata Info => throw new NotImplementedException();
      public State Status => _state;
      public string Name => _name;
      public SelfTestResult PerformSelfTest() => SelfTestResult;
      public SelfTestResult SelfTestResult => SelfTestResult.Unknown;

      public void Close() => Shutdown();
      public void Reset()
      {
         Close();
         Open();
      }

      #region Public Functions

      /// <summary>
      /// CommDevice factory constructor
      /// </summary>
      /// <param name="deviceName"></param>
      /// <param name="configurationManager"></param>
      public CommDeviceSerialAsync(string deviceName, IConfigurationManager configurationManager)
      {
         _name = deviceName;
         _configurationManager = configurationManager;
         _configuration = _configurationManager.GetConfiguration(deviceName);
         _logger = LogManager.GetLogger($"{this.GetType().Name} - {deviceName}");

         _comPortName = _configuration.GetConfigurationValue(_name, "COMPortName");
         int.TryParse(_configuration.GetConfigurationValue(_name, "BaudRate"), out _baudRate);
         Enum.TryParse(_configuration.GetConfigurationValue(_name, "Parity"), true, out _parity);
         int.TryParse(_configuration.GetConfigurationValue(_name, "DataBits"), out _dataBits);
         Enum.TryParse(_configuration.GetConfigurationValue(_name, "StopBits"), true, out _stopBits);

         uint.TryParse(_configuration.GetConfigurationValue(_name, "ReadTimeout"), out _defaultReadTimeout);
         uint.TryParse(_configuration.GetConfigurationValue(_name, "SendTimeout"), out _defaultSendTimeout);
         uint.TryParse(_configuration.GetConfigurationValue(_name, "BufferSize"), out _defaultReadBufferSize);

         _state = State.Uninitialized;
      }

      /// <summary>
      /// Destructor
      /// </summary>
      ~CommDeviceSerialAsync()
      {
         Shutdown();
      }

      /// <summary>
      /// initialize instrument
      /// </summary>
      public void Initialize()
      {
         Open();
      }

      /// <summary>
      /// Opens COM serial port for communications
      /// </summary>
      public void Open()
      {
         if (_state == State.Uninitialized)
         {
            _serialPort = new SerialPort(_comPortName, _baudRate, _parity, _dataBits, _stopBits);
            _serialPort.Open();
            _state = State.Ready;
         }
      }

      /// <summary>
      /// shuts down the device
      /// </summary>
      public void Shutdown()
      {
         if (_serialPort != null)
            _serialPort.Close();

         _state = State.Uninitialized;
      }

      /// <summary>
      /// Read data from the device asynchronously.
      /// </summary>
      /// <param name="dataRead">The buffer to put the data in</param>
      /// <returns>The number of bytes read</returns>
      public async Task<uint> ReadAsync(byte[] dataRead, CancellationToken token = default)
      {
         var bytesRead = await _serialPort.BaseStream.ReadAsync(dataRead, 0, dataRead.Length, token);
         return (uint)bytesRead;
      }

      /// <summary>
      /// Read string from the device asynchronously.
      /// </summary>
      /// <param name="dataRead">The buffer to put the data in</param>
      /// <returns>The number of bytes read</returns>
      public async Task<string> ReadAsync(CancellationToken token = default)
      {
         var data = await ReadLineAsync(token);
         return data;
      }

      /// <summary>
      /// Sets the read timeout
      /// </summary>
      /// <param name="timeoutMs"></param>
      public void SetReadTimeout(uint timeoutMs)
      {
         if (_serialPort == null)
            return;

         _serialPort.ReadTimeout = (int)timeoutMs;
      }

      /// <summary>
      /// Write data to the device asynchronously
      /// </summary>
      /// <param name="dataToSend"></param>
      /// <param name="numBytesToWrite"></param>
      /// <returns></returns>
      public async Task<uint> WriteAsync(byte[] dataToSend, uint numBytesToWrite, CancellationToken token = default)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return 0;

         await _serialPort.BaseStream.WriteAsync(dataToSend, 0, (int)numBytesToWrite, token);
         return numBytesToWrite;
      }

      /// <summary>
      /// Write string data to the device asynchronously
      /// </summary>
      /// <param name="message"></param>
      /// <returns></returns>
      public async Task WriteAsync(string message, CancellationToken token = default)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return;

         await WriteLineAsync(message, token);
      }

      /// <summary>
      /// Send Command and Get Response asynchronously
      /// </summary>
      /// <param name="message"></param>
      /// <param name="timeoutInMs"></param>
      /// <returns></returns>
      public async Task<string> SendCommandGetResponseAsync(string message, CancellationToken cancellationToken = default, int timeoutInMs = 5000)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return null;

         using (var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(timeoutInMs)))
         {
            if (cancellationToken == default)
            {
               cancellationToken = cts.Token;
            }
            await WriteAsync(message, cancellationToken);
            string readResponse = await ReadAsync(cancellationToken);
            return readResponse;
         }
      }

      /// <summary>
      /// Send Command and Get Response asynchronously
      /// </summary>
      /// <param name="message"></param>
      /// <param name="timeoutInMs"></param>
      /// <returns></returns>
      public async Task<byte[]> SendCommandGetResponseAsync(byte[] data, CancellationToken token = default, int timeoutInMs = 5000)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return null;

         await WriteAsync(data, (uint)data.Length, token);
         _serialPort.ReadTimeout = timeoutInMs;
         var response = new byte[data.Length];
         await ReadAsync(response, token);
         return response;
      }

      /// <summary>
      /// keeps reading until canceled via token,
      /// received messages sent to dataReceived function
      /// </summary>
      /// <param name="cancellationToken"></param>
      /// <param name="dataReceived"></param>
      /// <returns></returns>
      public async Task KeepReadingAsync(CancellationToken cancellationToken, Action<string> dataReceived)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return;

         while (!cancellationToken.IsCancellationRequested)
         {
            var data = await ReadAsync(cancellationToken);
            dataReceived?.Invoke(data);
         }
      }

      /// <summary>
      /// keeps reading until canceled via token,
      /// received messages sent to dataReceived function
      /// </summary>
      /// <param name="cancellationToken"></param>
      /// <param name="dataReceived"></param>
      /// <returns></returns>
      public async Task KeepReadingAsync(CancellationToken cancellationToken, Action<byte[]> dataReceived)
      {
         if (_serialPort == null || !_serialPort.IsOpen)
            return;

         while (!cancellationToken.IsCancellationRequested)
         {
            var data = new byte[_defaultReadBufferSize]; // Adjust buffer size as needed
            var bytesRead = await ReadAsync(data, cancellationToken);
            Array.Resize(ref data, (int)bytesRead);
            dataReceived?.Invoke(data);
         }
      }

      #endregion

      #region private functions
      /// <summary>
      /// reads line async
      /// </summary>
      /// <param name="cancellationToken"></param>
      /// <returns></returns>
      private async Task<string> ReadLineAsync(CancellationToken cancellationToken = default)
      {
         try
         {
            cancellationToken.ThrowIfCancellationRequested();
            var line = await Task.Run(() => _serialPort.ReadLine(), cancellationToken);
            return line;
         }
         catch (OperationCanceledException ex)
         {
            _logger.Error(ex, ex.Message);
            return null;
         }
      }

      /// <summary>
      /// writes line async
      /// </summary>
      /// <param name="message"></param>
      /// <param name="cancellationToken"></param>
      /// <returns></returns>
      private async Task WriteLineAsync(string message, CancellationToken cancellationToken = default)
      {
         try
         {
            cancellationToken.ThrowIfCancellationRequested();
            await Task.Run(() => _serialPort.WriteLine(message), cancellationToken);
         }
         catch (OperationCanceledException ex)
         {
            _logger.Error(ex, ex.Message);
         }
      }

      #endregion
   }
}