//                           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.Threading;
using NLog;
using Raytheon.Common;
using Raytheon.Units;

namespace Raytheon.Instruments
{
   /// <summary>
   /// A simulated eload
   /// </summary>
   public class EloadSim : IEload
   {
      #region PrivateClassMembers
      private readonly double _overCurrentProtection;
      private readonly double _overVoltageProtection;
      private double _setpointVal;
      private double _ini_setpointval;
      private double _voltage;
      private readonly int _channelNumber;
      private bool _isOn;
      private EloadModuleMode _mode;
      private EloadModuleMode _originalMode;

      private readonly ILogger _logger;

      private readonly IConfigurationManager _configurationManager;
      private readonly IConfiguration _configuration;

      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; }
      #endregion

      #region PublicFuctions

      /// <summary>
      /// FlowMeterOmegaDPF20 factory constructor
      /// </summary>
      /// <param name="deviceName"></param>
      /// <param name="configurationManager"></param>
      public EloadSim(string deviceName, IConfigurationManager configurationManager)
      {
         const double SETPOINT_VOLTAGE = 28.0;

         Name = deviceName;

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

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

         _channelNumber = _configuration.GetConfigurationValue("EloadSim", "ChannelNumber", 0);
         _mode = _configuration.GetConfigurationValue("EloadSim", "Mode", EloadModuleMode.CURRENT);
         _setpointVal = _configuration.GetConfigurationValue("EloadSim", "SetpointVal", 0.0);
         _ini_setpointval = _configuration.GetConfigurationValue("EloadSim", "IniSetpointVal", 0.0);
         _overCurrentProtection = _configuration.GetConfigurationValue("EloadSim", "OverCurrentProtection", 0.0);
         _overVoltageProtection = _configuration.GetConfigurationValue("EloadSim", "OverVoltageProtection", 0.0);
         _voltage = SETPOINT_VOLTAGE;
         _originalMode = _mode;
         // make sure it is off
         Disable();
      }

      /// <summary>
      /// The constructor for an Eload (Simulation).
      /// </summary>
      /// <param name="channelNumber">The channel number for the Eload.</param>
      /// <param name="mode">The operation mode of the channel. Modes: Resistance, Voltage, Current.</param>
      /// <param name="setpointVal">The operation point of the load. This can be a voltage, current, or resistance.</param>
      /// <param name="overCurrentProtection">Overcurrent setpoint that will turn off the channel if exceeded.</param>
      /// <param name="overVoltageProtection">Overvoltage setpoint that will turn off channel if exceeded (double check).</param>
      public EloadSim(int channelNumber, EloadModuleMode mode, double setpointVal, double overCurrentProtection, double overVoltageProtection)
      {
         const double SETPOINT_VOLTAGE = 28.0;
         _logger = LogManager.GetCurrentClassLogger();

         _channelNumber = channelNumber;
         _setpointVal = setpointVal;
         _ini_setpointval = setpointVal;
         _overCurrentProtection = overCurrentProtection;
         _overVoltageProtection = overVoltageProtection;
         _voltage = SETPOINT_VOLTAGE;
         _mode = mode;
         _originalMode = mode;
         Disable();
      }

      /// <summary>
      /// The finalizer.
      /// </summary>
      ~EloadSim()
      {
         Dispose(false);
      }

      /// <summary>
      /// Dispose of this object's resources.
      /// </summary>
      public void Dispose()
      {
         Dispose(true);
         GC.SuppressFinalize(this);
      }

      /// <summary>
      /// Send a SCPI Command to the instrument and get a response.
      /// </summary>
      /// <param name="commandString">The command to send.</param>
      /// <returns>THe instrument response.</returns>
      public string IOQuery(string commandString)
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);
         return "IOQuery Sim Response";
      }

      /// <summary>
      /// Send a SCPI Command to the instrument.
      /// </summary>
      /// <param name="commandString">The command to be send.</param>
      public void IOWrite(string commandString)
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);
      }

      /// <summary>
      /// Query if the Eload input is on (simulated).
      /// </summary>
      /// <returns>Status of Eload (simulated). True = On, False = Off.</returns>
      public bool IsInputOn()
      {
         return _isOn;
      }

      /// <summary>
      /// Turns the Eload off (simulated).
      /// </summary>
      public void Enable()
      {
         _isOn = false;
      }

      /// <summary>
      /// Turns the Eload on (simulated).
      /// </summary>
      public void Disable()
      {
         _isOn = true;
      }

      /// <summary>
      /// Reads the current of the Eload.
      /// </summary>
      /// <returns>The current (simulated).</returns>
      public Current ReadCurrent()
      {
         const double MIN_CURRENT = 1.0;

         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         double currentToReturn = 0.0;

         if (_isOn)
         {
            double maxCurrent = _overCurrentProtection;

            Random rnd = new Random();

            double seed = rnd.NextDouble();

            currentToReturn = (seed * (maxCurrent - MIN_CURRENT)) + MIN_CURRENT;
         }

         return Current.FromAmps(currentToReturn);
      }

      /// <summary>
      /// Reads the mode of the Eload.
      /// </summary>
      /// <returns>The mode (simulated).</returns>
      public EloadModuleMode ReadMode()
      {
         return _mode;
      }

      /// <summary>
      /// Reads the overcurrent setting from an Eload.
      /// </summary>
      /// <returns>Overcurrent setting (simulated).</returns>
      public Current ReadOverCurrentProtection()
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         return Current.FromAmps(_overCurrentProtection);
      }

      /// <summary>
      /// Reads the overvoltage setting from an Eload.
      /// </summary>
      /// <returns>Overvoltage setting (simulated).</returns>
      public Voltage ReadOverVoltageProtection()
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         return Voltage.FromVolts(_overVoltageProtection);
      }

      /// <summary>
      /// Reads the resistance of the Eload.
      /// </summary>
      /// <returns>The resistance (simulated).</returns>
      public Resistance ReadResistance()
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         double resistanceToReturn = 0.0;

         if (_isOn)
         {
            double maxCurrent = _setpointVal + 1;
            double minCurrent = _setpointVal - 1;

            Random rnd = new Random();

            double seed = rnd.NextDouble();

            resistanceToReturn = (seed * (maxCurrent - minCurrent)) + minCurrent;
         }

         return Resistance.FromOhms(resistanceToReturn);
      }

      /// <summary>
      /// Reads the setpoint of the Eload.
      /// </summary>
      /// <returns>The setpoint (simulated).</returns>
      public double ReadSetpoint()
      {
         return _setpointVal;
      }

      /// <summary>
      /// Reads the voltage of the Eload.
      /// </summary>
      /// <returns>The voltage (simulated).</returns>
      public Voltage ReadVoltage()
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         double voltageToReturn = 0.0;

         if (_isOn)
         {
            double maxVoltage = _voltage + 1;
            double minVoltage = _voltage - 1;

            Random rnd = new Random();

            double seed = rnd.NextDouble();

            voltageToReturn = (seed * (maxVoltage - minVoltage)) + minVoltage;
         }

         return Voltage.FromVolts(voltageToReturn);
      }

      /// <summary>
      /// Reads the protection status from an Eload.
      /// </summary>
      /// <returns>Protection status (simulated).</returns>
      public ushort ReadProtectionStatus()
      {
         // just to provide a small delay 10ms for the sim
         Thread.Sleep(10);

         // The sim never triggers the protection status
         return 0;
      }

      /// <summary>
      /// Sets Initial Settings
      /// </summary>
      public void SetInitialSetting()
      {
         _mode = _originalMode;
         _setpointVal = _ini_setpointval;
      }

      /// <summary>
      /// Change the operation mode of the Eload.
      /// </summary>
      /// <param name="mode">The desired Eload mode.</param>
      public void SetMode(EloadModuleMode mode)
      {
         _mode = mode;
      }

      /// <summary>
      /// Change the setpoint of the Eload.
      /// </summary>
      /// <param name="newSetpoint">The desired setpoint of the Eload.</param>
      public void SetSetpoint(double newSetpoint, EloadModuleMode mode)
      {
         if (mode != _mode)
         {
            throw new Exception("the current mode and the specified mode do not match. Current Mode: " + _mode.ToString() + ", specified mode: " + mode.ToString());
         }

         _setpointVal = newSetpoint;
      }

      /// <summary>
      /// Dispose of this object's resources.
      /// </summary>
      /// <param name="disposing">True = currently disposing, False = not disposing.</param>
      protected virtual void Dispose(bool disposing)
      {
      }

      public bool ClearErrors()
      {
         return true;
      }

      public void Initialize()
      {
         SetInitialSetting();
      }

      public SelfTestResult PerformSelfTest()
      {
         throw new NotImplementedException();
      }

      public void Reset()
      {
         Disable();

         Enable();
      }

      public void Shutdown()
      {
         Dispose();
      }

      #endregion

   }
}