//                           UNCLASSIFIED
/*-------------------------------------------------------------------------
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.

THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.

UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/

using System;
using System.IO.Ports;
using System.Net.Sockets;
using System.Text;
using NLog;
using Raytheon.Common;

namespace Raytheon.Instruments
{
   /// <summary>
   /// Chiller class used to interact with the FTS chiller.
   /// </summary>
   public class ChillerFTS : IChiller, IDisposable
   {
      #region PrivateMembers
      private enum DEGREES
      {
         Celsius = 0,
         Fahrenheit = 1,
         Kevin = 2
      }

      private static object m_sync = new object();

      private const string _CARRIAGE_RETURN = "\r";
      private const string _FLOWDISABLE = "STOP";
      private const string _FLOWENABLE = "START";
      private const string _TEMPREAD = "PT?";
      private const string _TEMPREADSETPOINT = "SP?";
      private const string _TEMPSET = "SP=";
      private const string _DEGREES = "DEGREES=";
      private const string _SUCCESS = "OK";
      private const string _EXC_POINT = "!";

      private readonly string _ipAddr;
      private readonly int _port;
      private const int _READ_BUFFER_SIZE = 128;
      private const int _READ_TIMEOUT = 5000;
      private byte[] _readBuffer;
      private NetworkStream _tcpStream;

      public string DetailedStatus { get; protected set; }

      public bool DisplayEnabled { get; set; }
      public bool FrontPanelEnabled { get; set; }

      public InstrumentMetadata Info { get; set; }

      public string Name { get; protected set; }

      public SelfTestResult SelfTestResult => PerformSelfTest();

      public State Status { get; set; }

      private readonly ILogger _logger;

      private readonly IConfigurationManager _configurationManager;
      private readonly IConfiguration _configuration;

      #endregion

      #region PrivateFunctions
      /// <summary>
      /// Destructor
      /// </summary>
      ~ChillerFTS()
      {
         Dispose(false);
      }

      /// <summary>
      /// Open socket to the chiller
      /// </summary>
      private void ConnectEthernet()
      {
         Initialize();
      }

      public void Initialize()
      {
         //Create and open a socket to chiller cart server
         TcpClient chillerSocket = new TcpClient(_ipAddr, _port);
         _tcpStream = chillerSocket.GetStream();
         _tcpStream.ReadTimeout = _READ_TIMEOUT;
      }

      /// <summary>
      /// Dispose of the object's resources.
      /// </summary>
      /// <param name="disposing">Currently disposing.</param>
      protected virtual void Dispose(bool disposing)
      {
         if (disposing)
         {
            //Close Connection (if available)
            _tcpStream?.Close();
         }
      }

      /// <summary>
      /// Send a command to the chiller and request a response
      /// </summary>
      /// <param name="cmd">Command to send.</param>
      /// <returns>Response from the chiller.</returns>
      private string SendMessageGetResponse(string cmd)
      {
         lock (m_sync)
         {
            //Format the command before sending
            string commandString = cmd + _CARRIAGE_RETURN;

            //convert to byte array for sending
            byte[] commandBuffer = Encoding.ASCII.GetBytes(commandString);

            //send the data
            _tcpStream.Write(commandBuffer, 0, commandBuffer.Length);

            //clear the buffer
            Array.Clear(_readBuffer, 0, _readBuffer.Length);

            //read from the response buffer
            int numBytesRead = _tcpStream.Read(_readBuffer, 0, _readBuffer.Length);

            //convert response to a string
            string rspStr = Encoding.ASCII.GetString(_readBuffer);

            //Check Response
            if (rspStr.Contains(_SUCCESS))
            {
               //Remove !
               rspStr = rspStr.Replace(_EXC_POINT, "");

               //Parse string ("/r")
               char[] delimit = { '\r' };
               string[] parsed = rspStr.Split(delimit, StringSplitOptions.RemoveEmptyEntries);

               //Return parsed message
               return parsed[1];
            }
            else
            {
               throw new Exception("SendMessageGetResponse::SendMessageGetResponse() - Command message not successful");
            }
         }
      }
      /// <summary>
      /// Change the units of measurement for the chiller.
      /// </summary>
      /// <param name="units">Celsius/Fahrenheit</param>
      private void SetDegreesUnits(DEGREES units)
      {
         lock (m_sync)
         {
            //Set the units of measurement to Celsius
            string rsp = SendMessageGetResponse(_DEGREES + units.ToString());
         }
      }

      #endregion


      /// <summary>
      /// ChillerFTS factory constructor
      /// </summary>
      /// <param name="deviceName"></param>
      /// <param name="configurationManager"></param>
      public ChillerFTS(string deviceName, IConfigurationManager configurationManager)
      {
         Name = deviceName;

         _logger = LogManager.GetLogger($"{this.GetType().Name} - {deviceName}");

         _configurationManager = configurationManager;
         _configuration = _configurationManager.GetConfiguration(Name);


         _ipAddr = _configuration.GetConfigurationValue("ChillerFTS", "IpAddr", "");
         _port = _configuration.GetConfigurationValue("ChillerFTS", "Port", 0);

         _readBuffer = new byte[_READ_BUFFER_SIZE];

         //Connect to device
         ConnectEthernet();
      }

      /// <summary>
      /// Constructor for the chiller. It makes a socket connection to the chiller and sets the degrees to Celsius
      /// </summary>
      /// <param name="deviceName">The name</param>
      /// <param name="ipAddress">IP Address of the equipment</param>
      /// <param name="port">Port of the equipment</param>
      public ChillerFTS(string deviceName, string ipAddress, int port)
      {
         Name = deviceName;
         _ipAddr = ipAddress;
         _port = port;
         _logger = LogManager.GetLogger($"{this.GetType().Name} - {deviceName}");

         _readBuffer = new byte[_READ_BUFFER_SIZE];

         //Connect to device
         ConnectEthernet();
      }

      /// <summary>
      /// 
      /// </summary>
      /// <param name="name"></param>
      /// <param name="comPortName"></param>
      /// <param name="delayBeforeReadMs"></param>
      /// <param name="baudRate"></param>
      /// <param name="parity"></param>
      /// <param name="dataBits"></param>
      /// <param name="stopBits"></param>
      public ChillerFTS(string name, string comPortName, uint delayBeforeReadMs, int baudRate = 115200, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
      {
         throw new NotImplementedException();
      }

      /// <summary>
      /// Stop the chiller pump.
      /// </summary>
      public void DisableFlow()
      {
         lock (m_sync)
         {
            //Send the command to stop coolant flow
            string rsp = SendMessageGetResponse(_FLOWDISABLE);
         }
      }

      /// <summary>
      /// Dispose of this objects resources
      /// </summary>
      [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly")]
      public void Dispose()
      {
         Dispose(true);

         GC.SuppressFinalize(this);
      }

      /// <summary>
      /// Start the chiller pump.
      /// </summary>
      public void EnableFlow()
      {
         lock (m_sync)
         {
            //Send the command to start coolant flow
            string rsp = SendMessageGetResponse(_FLOWENABLE);
         }
      }

      /// <summary>
      /// Query the current setting for the coolant.
      /// </summary>
      /// <returns>The current coolant setting.</returns>
      public double GetCoolantSetpoint()
      {
         lock (m_sync)
         {
            //Name of the function
            const string SETPOINT_RESPONSE = "F057=";

            //Request the setpoint
            string results = SendMessageGetResponse(_TEMPREADSETPOINT);

            //Not connected. No results
            if (results == "")
            {
               return double.MaxValue;
            }

            //Remove function header
            results = results.Replace(SETPOINT_RESPONSE, "");

            return double.Parse(results);
         }
      }

      /// <summary>
      /// Query the temperature of the coolant reservoir.
      /// </summary>
      /// <returns>The temperature of the coolant.</returns>
      public double GetCoolantTemperature()
      {
         lock (m_sync)
         {
            //Name of the function
            const string TEMP_RESPONSE = "F043=";

            //Request the temperature
            string results = SendMessageGetResponse(_TEMPREAD);

            //Not connected. No results
            if (results == "")
            {
               return double.MaxValue;
            }

            //Remove function header
            results = results.Replace(TEMP_RESPONSE, "");

            return double.Parse(results);
         }
      }

      /// <summary>
      /// Set the coolant temperature to a desired setpoint.
      /// </summary>
      /// <param name="temp">The desired coolant temperature.</param>
      public void SetCoolantTemperature(double temp)
      {
         lock (m_sync)
         {
            //Set the coolant temperature
            string rsp = SendMessageGetResponse(_TEMPSET + temp.ToString());
         }
      }

      public bool ClearErrors()
      {
         throw new NotImplementedException();
      }

      public SelfTestResult PerformSelfTest()
      {
         return SelfTestResult.Unknown;
      }

      public void Reset()
      {
         Shutdown();

         Initialize();
      }

      public void Shutdown()
      {
         Dispose();
      }
   }
}
