tbf/TBF/Rig/RegisterReaders/GenesisRegReader/communication/OptoHeadTest.cs

using System;
using System.Threading.Tasks;
using Common;
using GenesisCordonelInterface.API;
using log4net;
using TBF.Rig.BridgeComponents.GciBridge;
using TBF.Rig.RegisterReaders.GenesisRegReader.implementations;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed;


namespace TBF.Rig.RegisterReaders.GenesisRegReader.communication
{
    public class OptoHeadTest : IDisposable
    {
        //protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData");
        private static readonly ILog log = LogManager.GetLogger(typeof(OptoHeadTest));
        
        private GenesisSmartReader genesisHead;
        //private SerialDriver serialDriver;

        public void BuildConnection(GenesisSmartReader genesidHead)
        {
            GciPublicModels.GciInitSlotRequest request = new GciPublicModels.GciInitSlotRequest
            {
                SlotId = genesidHead.GetSlotNr,
                ConfigSource = GciPublicModels.GciConfigSource.InterfaceInputConfig,
                PasswordSource = GciPublicModels.GciPasswordSource.InterfaceInputPassword,
                RequestPort = new GciPublicModels.GciPortConfig{ PortName = $"COM{genesidHead.RfidComPortNr}"/*, Type = "COM"*/},
                StreamingPort = new GciPublicModels.GciPortConfig{ PortName = $"COM{genesidHead.OptoComPortNr}"/*, Type = "COM"*/}
            };
            genesidHead?.CommInterfaceBridge.InitSlotAsync(request);
            slotDefined = true;
        }
        
        public OptoHeadTest(GenesisSmartReader genesisHead)
        {
            this.genesisHead = genesisHead;
        }
        
        public void CloseConnection()
        {
            genesisHead?.CommInterfaceBridge?.DisconnectAsync(genesisHead.GetSlotNr);
            DisposeSlot();

            // if (serialDriver != null)
            //     serialDriver.CloseConnection();
            // serialDriver = null;
        }

        private bool slotDefined = false;

        public bool IsSlotDefined { get => slotDefined; }

       
        public void DisposeSlot()
        {
            slotDefined = false;
        }
        
        public async Task<bool> ReadSerialNrAsync()
        {
            try
            {
                if (genesisHead == null)
                    return false;

                if (string.IsNullOrEmpty(genesisHead.CommInterface))
                    return false;

                if (genesisHead.CommInterfaceBridge == null)
                    return false;

                if (!IsSlotDefined)
                    BuildConnection(genesisHead);

                GciBridge gciBridge = genesisHead.CommInterfaceBridge;

                gciBridge.GciBridgeCfg.EnableExternalAccess = true;
                gciBridge.GciBridgeCfg.EnableGuiAccess = false;
                gciBridge.Initialize();

                RadioService headService = new RadioService(gciBridge);

                string pcbId = await headService.ReadRequest_PCBAsync(genesisHead);

                return !string.IsNullOrEmpty(pcbId);
            }
            catch (Exception ex)
            {
                log.Error($"ReadSerialNr(COM{genesisHead?.RfidComPortNr}) - Exception: {ex}");
                return false;
            }
        }

        public string ReadRequest_PCB()
        {
            // if (genesisHead.DebugLevel == DebugMode.Simulate)
            // {
            //     log.Debug("ReadRequest_PCB() - Simulated response");
            //     return "-OK Simulated response-";
            // }

            try
            {
                log.Debug("ReadRequest_PCB called for iHead: " + genesisHead.ToString());
                if (genesisHead == null)
                    return string.Empty;

                if (string.IsNullOrEmpty(genesisHead.CommInterface))
                    return string.Empty;

                if (genesisHead.CommInterfaceBridge == null)
                    return string.Empty;
                
                if (!IsSlotDefined) { BuildConnection(genesisHead); }

                GciBridge gciBridge = genesisHead.CommInterfaceBridge;
                log.Debug("ReadRequest_PCB() - GciBridge created");

                gciBridge.GciBridgeCfg.EnableExternalAccess = true;
                gciBridge.GciBridgeCfg.EnableGuiAccess = false;
                gciBridge.Initialize();
                log.Debug("ReadRequest_PCB() - GciBridge initialized");

                
                RadioService headService = new RadioService(gciBridge);
                string serialNo = headService.ReadRequest_PCB(ref genesisHead);
                log.Info(
                    $"PCB Number: {serialNo} on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr} serialDriver: {genesisHead?.CommInterfaceBridge}");
                return serialNo;
            }
            catch (Exception ex)
            {
                log.Error("ReadRequest_PCB() - Exception:" + ex.StackTrace);
                return (ex.Message.ToString());
            }
        }

        /// <summary>
        /// Set Test mode
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        public bool SetTestMode()
        {
            if (!IsSlotDefined) { BuildConnection(genesisHead); }
            log.Debug("SetTestMode called for iHead: " + genesisHead.ToString());
            bool activityModeActive = SetActivityMode_Active();
            bool optActiveMode = SetOptTestMode();
            
            log.Debug("SetTestMode result: optoMod-> " + optActiveMode + " meterModeActive ->" + activityModeActive);
            return (optActiveMode && activityModeActive);
        }
        
        /// <summary>
        /// Set Active mode
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        public bool SetActiveMode()
        {
            if (!IsSlotDefined) { BuildConnection(genesisHead); }
            log.Debug("SetActiveMode called for iHead: " + genesisHead.ToString());
            bool optActiveMode = SetOptActiveMode(genesisHead);
            //bool activityModeIdle = SetActivityMode_Idle();
            
            return optActiveMode;
        }
        
        /// <summary>
        /// Set Idle mode - only
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        public bool SetIdleMode()
        {
            log.Debug("SetIdleMode called for iHead: " + genesisHead.ToString());
            bool activityModeIdle = SetActivityMode_Idle();
            
            return activityModeIdle;
        }
        
        /// <summary>
        /// Set Test mode - string response
        /// </summary>
        /// <param name="iHead"></param>
        /// <param name="isTestModeSuccessful"></param>
        /// <returns></returns>
        public string SetTestMode(ref bool isTestModeSuccessful)
        {
            if (genesisHead.DebugLevel == DebugMode.Simulate)
            {
                isTestModeSuccessful = true;
                return "-OK Simulated response-";
            }

            try
            {
                bool testMode = SetTestMode();
                isTestModeSuccessful = testMode;
                return testMode ? "Set Test Mode - OK" : "Set Test Mode - FAILED";
            }catch (Exception ex)
            {
                log.Error("SetTestMode() - Exception:" + ex.StackTrace);
                return "Set Test Mode - Exception";
            }
        }

        

        /// <summary>
        /// Set Optical -> Test mode
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        private bool SetOptTestMode()
        {
            
            if (genesisHead.DebugLevel == DebugMode.Simulate)
            {
                return true;
            }

            // try
            // {
            //     if (genesisHead != null)
            //     {
            //         if(genesisHead.RfidComPortNr != 0 && !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
            //             BuildConnection(genesisHead);
            //         
            //         
            //         RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
            //         bool optTestMode = headService.SetOptTestMode(genesisHead);
            //         if (genesisHead.ConfigStruct != null)
            //             genesisHead.ConfigStruct.OpthoStatusMode = optTestMode ? DiagnosticLedState.State4 : DiagnosticLedState.StatusUnknown;
            //         return optTestMode;
            //     }
            // }
            // catch (Exception ex)
            // {
            //     log.Error("SetOptTestMode() - Exception:" + ex.StackTrace);
            // }
            
            return false;
            
           
        }

        /// <summary>
        /// Set Active mode - string response
        /// </summary>
        /// <param name="iHead"></param>
        /// <param name="isTestModeSuccessful"></param>
        /// <returns></returns>
        public string SetActiveMode(ref bool isTestModeSuccessful)
        {
            if (genesisHead.DebugLevel == DebugMode.Simulate)
            {
                isTestModeSuccessful = true;
                return "-OK Simulated response-";
            }

            // try
            // {
            //     bool activeMode = SetActiveMode();
            //     isTestModeSuccessful = activeMode;
            //     return activeMode ? "Set Active Mode - OK" : "Set Active Mode - FAILED";
            // }
            // catch (Exception ex)
            // {
            //     log.Error("SetActiveMode() - Exception:" + ex.StackTrace);
            //     return "Set Active Mode - Exception";     
            // }
            
            return "Set Active Mode - No Implemented Exception";
        }
        /// <summary>
        /// Set Optical -> Active mode
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        private bool SetOptActiveMode(GenesisSmartReader iHead)
        {
            // try
            // {
            //     if (iHead != null)
            //     {
            //         if(genesisHead.RfidComPortNr != 0 && !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
            //             BuildConnection(genesisHead);
            //         
            //         RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
            //         return headService.SetOptActiveMode(iHead);
            //     }
            // }
            // catch (Exception ex)
            // {
            //     log.Error("SetOptActiveMode() - Exception:" + ex.StackTrace);
            // }
            
            return false;
        }
        
        /// <summary>
        /// Set activity mode to active
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        private bool SetActivityMode_Active()
        {
            
            // try
            // {
            //     if (genesisHead != null)
            //     {
            //         if (genesisHead.RfidComPortNr != 0 &&
            //             !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
            //             BuildConnection(genesisHead);
            //        
            //         log.Debug("SetActivityMode_Active called for iHead: " + genesisHead.ToString());
            //         RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
            //         return headService.SetActivityMode_Active(genesisHead);
            //     }
            // }
            // catch (Exception ex)
            // {
            //     log.Error("SetActivityMode_Active() - Exception:" + ex.StackTrace);
            // }
            
            return false;
        }
        
        /// <summary>
        /// Set activity mode to idle
        /// </summary>
        /// <param name="iHead"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        private bool SetActivityMode_Idle()
        {
            // try
            // {
            //     if (genesisHead != null)
            //     {
            //         if (genesisHead.RfidComPortNr != 0 &&
            //             !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
            //             BuildConnection(genesisHead);
            //         
            //         log.Debug("SetActivityMode_Idle called for iHead: " + genesisHead.ToString());
            //        
            //         RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
            //         return headService.SetActivityMode_Idle(genesisHead);
            //     }
            // }
            // catch (Exception ex)
            // {
            //     log.Error("SetActivityMode_Idle() - Exception:" + ex.StackTrace);
            // }
            
            return false;
        }

        
        public void Dispose()
        {
            CloseConnection();
        }
        
        /// <summary>
        /// Read configuration from iHead
        /// DiagnosticLedState is not readable, mus only be set!
        /// </summary>
        /// <param name="iHead"></param>
        /// <param name="ledState"></param>
        /// <returns></returns>
        public bool ReadConfiguration(DiagnosticLedState ledState )
        {
            if (genesisHead.DebugLevel == DebugMode.Simulate)
            {
                return true;
            }

            try
            {

                // if (genesisHead != null)
                // {
                //     genesisHead.ConfigStruct = new ConfigStruct();
                //
                //     if (genesisHead.RfidComPortNr != 0 &&
                //         !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
                //         BuildConnection(genesisHead);
                //
                //     RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
                //     genesisHead.ConfigStruct.PCBNumberString = headService.ReadRequest_PCB(ref genesisHead);
                //     genesisHead.ConfigStruct.StatusMode = headService.GetActivityStatusMode(genesisHead);
                //     genesisHead.ConfigStruct.Unit = headService.GetUnit(genesisHead);
                //     
                //     if (ledState != DiagnosticLedState.StatusUnknown) // do set
                //     {
                //         genesisHead.ConfigStruct.OpthoStatusMode = headService.SetOptoStatusMode(genesisHead, ledState);
                //     }
                //     else
                //     {
                //         genesisHead.ConfigStruct.OpthoStatusMode = DiagnosticLedState.StatusUnknown;
                //     }
                //
                //     genesisHead.ConfigStruct.Version = headService.GetVersion(genesisHead);
                //
                //     return true;
                // }
                //
                // else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
    }
}