using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;

namespace Iob.Core
{
    public static class ThreadsFunctions
    {
        //        public static int axisRtCounter = 0;
        //        public static int recipeRtCounter = 0;
        //        public static int modulesRtCounter = 0;
        //        public static bool reconnectionIsRunning = false;

        //        private static ConcurrentDictionary<string, long> Timers = new ConcurrentDictionary<string, long>();
        //        private static ConcurrentDictionary<string, long> Counter = new ConcurrentDictionary<string, long>();

        //        private static Thread ConnThread;
        //        /// <summary>
        //        /// restituisce il periodo di campionamento SE configurato, altrimenti 1000 ms
        //        /// </summary>
        //        /// <param name="threadName"></param>
        //        /// <returns></returns>
        //        private static int samplMsec(string threadName)
        //        {
        //            int answ = 500;
        //            if (ThreadSamplingConfig.ContainsKey(threadName))
        //            {
        //                answ = ThreadSamplingConfig[threadName];
        //            }
        //            return answ;
        //        }

        //        #region Functions

        //        public static void ManageWatchdog()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            int errorCounter = 0;
        //            try
        //            {
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Manage watchdog
        //                        libraryError = ncAdapter.ManageWatchdog();
        //                        if (libraryError == PLC_NOT_RUNNING_ERROR)
        //                        {
        //                            if (errorCounter < MAX_NUM_OF_WATCHDOG_ERROR)
        //                                errorCounter++;
        //                        }
        //                        else if (libraryError == NO_ERROR)
        //                            errorCounter = 0;
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("watchdog"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException ex)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        /// <summary>
        //        /// Manage status/command words for actions
        //        /// </summary>
        //        public static void ManageStatusCommand()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Manage status command
        //                        libraryError = ncAdapter.ManageStatusCommand();
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("statusCommand"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException ex)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        /// <summary>
        //        /// Manage action for conf request
        //        /// </summary>
        //        public static void ManageConfRequest()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Manage status command
        //                        libraryError = ncAdapter.ManageConfRequest();
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("confReq"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException ex)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadAlarms()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();
        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Alarms from NC
        //                        libraryError = ncAdapter.GetNcAlarms(out DTOAlarmsModel alarms);
        //                        if (libraryError.errorCode != 0)
        //                        {
        //                            ManageLibraryError(libraryError);
        //                        }
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_ALARMS, null, alarms);
        //                    }
        //                    else
        //                        RestoreConnection();
        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("alarms"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadPowerOnData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();
        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Data from NC
        //                        libraryError = ncAdapter.GetPowerOnData(out DTOPowerOnDataModel powerOnData);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_POWER_ON_DATA, null, powerOnData);
        //                    }
        //                    else
        //                        RestoreConnection();
        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("powerOn"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadProcessesPPStatus()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Data from NC
        //                        libraryError = ncAdapter.GetProcessesData(out DTOProcessesDataModel processesPPData);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                        {
        //                            // Send processes through signalR
        //                            MessageServices.Current.Publish(SEND_PROCESSES_DATA, null, processesPPData);
        //                        }
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(200, (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadEnabledFunctionality()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Data from NC
        //                        libraryError = ncAdapter.GetFunctionsMappedWithNC(out List<DTORuntimeFunctionalityModel> functionsAccessList);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_FUNCTIONALITY_DATA, null, functionsAccessList);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("functionEnab"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadExpiredMaintenances()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Data from database and PLC
        //                        libraryError = ncAdapter.GetExpiredMaintenances(out List<DTOExpiredMaintenanceModel> expiredMaintenances);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_EXPIRED_MAINTENANCES_DATA, null, expiredMaintenances);

        //                        // 2020.06.18 commentata da indicazione di Lucio Maranta (NON dovrebbe servire ora)
        //#if false
        //                    //Manage Candies
        //                    libraryError = ncAdapter.ManageCandies();
        //                    if (libraryError.errorCode != 0)
        //                        ManageLibraryError(libraryError);
        //#endif
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("expMan"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //            catch (Exception ex)
        //            {
        //            }
        //        }
        //        public static void ReadUserSoftKeysData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get softkey data from config and PLC
        //                        libraryError = ncAdapter.GetUserSoftKeys(out List<DTOUserSoftKeyModel> softKeys);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_USER_SOFTKEYS_DATA, null, softKeys);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("userSK"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        /// <summary>
        //        /// Lettura valori ASSI (tutti i disponibili)
        //        /// </summary>
        //        public static void ReadAxisInfoData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    // ogni n counter leggo anche dati NON RT
        //                    axisRtCounter--;
        //                    bool onlyRt = axisRtCounter > 0;
        //                    //check reset...
        //                    axisRtCounter = axisRtCounter < 0 ? 4 : axisRtCounter;

        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get Data from config and PLC
        //                        libraryError = ncAdapter.ReadAxisData(onlyRt, out Dictionary<int, DTOAxisInfoModel> axisData);
        //                        if (libraryError.errorCode != 0)
        //                            ManageLibraryError(libraryError);
        //                        else
        //                            // Send through signalR
        //                            MessageServices.Current.Publish(SEND_AXIS_INFO, null, axisData);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("axis"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadScadaData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        List<ScadaSchemaModel> scadaToRead = ProductionScadaSchema.Concat(SubscribedScada).ToList();

        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadScadasData(scadaToRead, out List<DTOScadaModel> scadas);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_SCADA_DATA, null, scadas);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("scada"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadGaugeData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadGaugeData(out Dictionary<string, DTOThermoProd> currentLiveProd);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_GAUGE_DATA, null, currentLiveProd);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("gauges"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadProdPanelData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC (and log if changed...)
        //                        libraryError = ncAdapter.ReadProdPanel(out DTOThermoPanelProd currentProdPanel);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_PROD_PANEL_DATA, null, currentProdPanel);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait 500 ms
        //                    Thread.Sleep(CalcSleepTime(samplMsec("prodPanel"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadProdInfoData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC (and log if changed...)
        //                        libraryError = ncAdapter.ReadProdInfoData(out DTOProdInfo prodInfoData);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_PROD_INFO_DATA, null, prodInfoData);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("prodInfo"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadProdCycleData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadProdCycleData(out ThermoModels.ProdCycleModel prodCycleData);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_PROD_CYCLE_DATA, null, prodCycleData);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("prodCycle"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadRecipeData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    // ogni n counter leggo anche dati NON RT
        //                    recipeRtCounter--;
        //                    bool onlyRt = recipeRtCounter > 0;
        //                    //check reset...
        //                    recipeRtCounter = recipeRtCounter < 0 ? 4 : recipeRtCounter;

        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadRecipeData(onlyRt, false, out Dictionary<string, DTORecipeParam> currRecipe);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_RECIPE_FULL, null, currRecipe);

        //                        // ora gestisco la overview!
        //                        libraryError = ncAdapter.GetRecipeOverview(out Dictionary<RecipeSection, RecipeCatStatus> currOverview);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_RECIPE_OVERWIEW, null, currOverview);

        //                        // ora gestisco la lettura della overview di "modificata
        //                        DTORecipeStatus message = new DTORecipeStatus()
        //                        {
        //                            recipeName = NcAdapter.RecipeLiveData.RecipeName,
        //                            hasChanged = NcAdapter.RecipeLiveData.hasChanged
        //                        };

        //                        MessageServices.Current.Publish(SEND_THERMO_RECIPE_CHANGED, null, message);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    // Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("recipe"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadWarmersData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadWarmers(out Dictionary<int, DTOWarmers> currWarmers);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);
        //                        // pubblico
        //                        MessageServices.Current.Publish(SEND_THERMO_WARMERS_DATA, null, currWarmers);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    // Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("warmers"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadAreaData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC... info x area lastra... la % di X / Y
        //                        libraryError = ncAdapter.GetWarmMaterialArea(out Dictionary<string, double> currAreaPerc);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);
        //                        // pubblico
        //                        MessageServices.Current.Publish(SEND_THERMO_AREA_DATA, null, currAreaPerc);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    // Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("area"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadModulesData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();
        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // Get new data from PLC
        //                        libraryError = ncAdapter.ReadModulesBlock(out Dictionary<int, DTOModulesBlock> currModules);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        MessageServices.Current.Publish(SEND_THERMO_MODULE_DATA, null, currModules);
        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    // Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);
        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("modules"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadMComandsData()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        // solo x S7Net...
        //                        if (NcConfig.NcVendor == NC_VENDOR.S7NET)
        //                        {
        //                            libraryError = ncAdapter.GetM156Data(out List<DTOM156InputModel> m156Data);
        //                            if (libraryError.IsError())
        //                                ManageLibraryError(libraryError);
        //                            else
        //                                MessageServices.Current.Publish(SEND_M156_DATA, null, m156Data);
        //                        }

        //                    }
        //                    else
        //                        RestoreConnection();

        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("mCommands"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void ReadM154Data()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            Stopwatch sw = new Stopwatch();

        //            try
        //            {
        //                // Try connection
        //                CmsError libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode != 0)
        //                    ManageLibraryError(libraryError);

        //                while (true)
        //                {
        //                    sw.Restart();

        //                    // Check if client is connected
        //                    if (ncAdapter.numericalControl.NC_IsConnected())
        //                    {
        //                        libraryError = ncAdapter.GetM154Data(out List<M154DataModel> data, out bool MTCStatus);
        //                        if (libraryError.IsError())
        //                            ManageLibraryError(libraryError);

        //                        string ApplicationPath = ServerStartupConfig.MTCFolderPath + "\\" + ServerStartupConfig.MTCApplicationName + ".exe";
        //                        if (ServerStartupConfig.MTCFolderPath != "")
        //                        {
        //                            // Check if process exists
        //                            Process[] processes = Process.GetProcessesByName(ServerStartupConfig.MTCApplicationName);
        //                            if (!MTCStatus)
        //                            {
        //                                // Kill if is running
        //                                if (processes.Count() > 0)
        //                                    processes[0].Kill();
        //                            }
        //                            else
        //                            {
        //                                // if is already running ignore
        //                                if (processes.Count() == 0)
        //                                    if (File.Exists(ApplicationPath))
        //                                    {
        //                                        ProcessStartInfo PSI = new ProcessStartInfo(ApplicationPath);
        //                                        var directory = new FileInfo(ApplicationPath).Directory;
        //                                        if (directory != null)
        //                                        {
        //                                            PSI.WorkingDirectory = directory.FullName;
        //                                            Process.Start(PSI);
        //                                        }
        //                                    }
        //                            }
        //                        }

        //                        foreach (M154DataModel m154 in data)
        //                        {
        //                            //if (CmsConnectConfig.Enabled)
        //                            if (ServerStartupConfig.CmsConnectReady)
        //                            {
        //                                if (m154.Parameters.Count() >= 2 && m154.Parameters[0] == "SOUR")
        //                                {
        //                                    // Convert tag string in Pascal Case and add to result string
        //                                    switch (m154.Parameters[1].ToLower())
        //                                    {
        //                                        case "currprog":
        //                                            if (m154.Parameters.Count() < 3)
        //                                                return;
        //                                            RedisController.WriteProductionName(m154.Process, m154.Parameters[2]);
        //                                            break;

        //                                        case "repstarget":
        //                                            if (m154.Parameters.Count() < 3)
        //                                                return;
        //                                            RedisController.WriteProductionRepsTarget(m154.Process, m154.Parameters[2]);
        //                                            break;

        //                                        case "repsdone":
        //                                            if (m154.Parameters.Count() < 3)
        //                                                return;
        //                                            RedisController.WriteProductionRepsDone(m154.Process, m154.Parameters[2]);
        //                                            break;

        //                                        default:
        //                                            string notif = m154.Parameters[1];
        //                                            if (m154.Parameters.Count() > 2)
        //                                                notif += m154.Parameters[2];
        //                                            RedisController.WriteProductionNotification(m154.Process, notif);
        //                                            break;
        //                                    }
        //                                }

        //                                // Write ack
        //                                libraryError = ncAdapter.WriteM154Ack((int)m154.Process);
        //                                if (libraryError.IsError())
        //                                    ManageLibraryError(libraryError);
        //                            }
        //                            else //MTC
        //                            {
        //                                string stringVal = "Path_0" + m154.Process + "_";
        //                                string val = "";

        //                                // Check if command is MTC
        //                                if (m154.Parameters[0] == "MTC")
        //                                {
        //                                    // Convert tag string in Pascal Case and add to result string
        //                                    switch (m154.Parameters[1].ToLower())
        //                                    {
        //                                        case "currprog":
        //                                            stringVal += "CurrProg";
        //                                            break;

        //                                        case "partid":
        //                                            stringVal += "PartId";
        //                                            break;

        //                                        default:
        //                                            stringVal += m154.Parameters[1];
        //                                            break;
        //                                    }
        //                                    // Set value
        //                                    if (m154.Parameters.Count() > 2)
        //                                        val = m154.Parameters[2];

        //                                    // Create MTC Directory if not exist
        //                                    if (!Directory.Exists(ServerStartupConfig.MTCFolderPath))
        //                                        Directory.CreateDirectory(ServerStartupConfig.MTCFolderPath);

        //                                    string outputFileName = ServerStartupConfig.MTCFolderPath + "\\DATA\\CmsGeneralStatus.mtc";
        //                                    // Create file if not exits
        //                                    if (!File.Exists(outputFileName))
        //                                        using (var f = File.Create(outputFileName)) { };
        //                                    // Read file
        //                                    List<string> fileLines = File.ReadAllLines(outputFileName).ToList();
        //                                    string[] parametersInLine;
        //                                    bool found = false;
        //                                    for (int i = 0; i < fileLines.Count() && !found; i++)
        //                                    {
        //                                        // Get tag & value from row
        //                                        parametersInLine = fileLines[i].Split('|');
        //                                        if (parametersInLine[0] == stringVal)
        //                                        {
        //                                            found = true;
        //                                            fileLines[i] = stringVal + "|" + val;
        //                                        }
        //                                    }
        //                                    // If tag doesn't exists, append new line
        //                                    if (!found)
        //                                        fileLines.Add(stringVal + "|" + val);

        //                                    // Write file
        //                                    File.WriteAllLines(outputFileName, fileLines.ToArray());

        //                                    // Write ack
        //                                    libraryError = ncAdapter.WriteM154Ack((int)m154.Process);
        //                                    if (libraryError.IsError())
        //                                        ManageLibraryError(libraryError);
        //                                }
        //                            }
        //                        }
        //                    }
        //                    else
        //                        RestoreConnection();
        //                    sw.Stop();

        //                    //Update thread timer
        //                    UpdateStat(MethodBase.GetCurrentMethod().Name, sw.ElapsedMilliseconds);

        //                    // Wait
        //                    Thread.Sleep(CalcSleepTime(samplMsec("m154"), (int)sw.ElapsedMilliseconds));
        //                }
        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }
        //        public static void SetupCmsConnect()
        //        {
        //            NcAdapter ncAdapter = new NcAdapter();
        //            try
        //            {
        //                List<DTOLanguageModel> availableLanguages = LanguageController.GetLanguageListFromDirectory();
        //                if (availableLanguages == null)
        //                    return;

        //                ICollection<CultureInfo> cultureInfos = new List<CultureInfo>();

        //                // Get nc available language
        //                CmsError libraryError = ncAdapter.numericalControl.NC_GetAvailableLanguages(ref cultureInfos);
        //                if (libraryError.IsError())
        //                    ManageLibraryError(libraryError);

        //                // Filter available language with
        //                availableLanguages = availableLanguages.Where(x => cultureInfos.Any(y => y.TwoLetterISOLanguageName == x.IsoId)).ToList();

        //                // Fill redis DB
        //                int count = 1;
        //                Dictionary<string, string> defAlarmsNamesEn = null;
        //                Dictionary<string, string> defAlarmsNamesIt = null;
        //                foreach (DTOLanguageModel lang in availableLanguages)
        //                {
        //                    Dictionary<string, string> alarmsNames = GetPlcAlarmsTranslations(lang.IsoId);

        //                    if (lang.IsoId.ToLower() == "en")
        //                    {
        //                        defAlarmsNamesEn = alarmsNames;
        //                        if (!RedisController.WriteAlarmsConfigEn(alarmsNames))
        //                            ManageError(ERROR_LEVEL.FATAL, CMS_CONNECT_SETUP_ALARM_MESSAGE);
        //                    }
        //                    else if (lang.IsoId.ToLower() == "it")
        //                    {
        //                        defAlarmsNamesIt = alarmsNames;
        //                        if (!RedisController.WriteAlarmsConfigIt(alarmsNames))
        //                            ManageError(ERROR_LEVEL.FATAL, CMS_CONNECT_SETUP_ALARM_MESSAGE);
        //                    }
        //                    else
        //                        if (!RedisController.WriteAlarmsConfigCurr(alarmsNames))
        //                        ManageError(ERROR_LEVEL.FATAL, CMS_CONNECT_SETUP_ALARM_MESSAGE);

        //                    if (count == 3)
        //                        break;
        //                    else
        //                        count++;
        //                }

        //                if (availableLanguages.Count < 3 && defAlarmsNamesEn != null)
        //                    if (!RedisController.WriteAlarmsConfigCurr(defAlarmsNamesEn))
        //                        ManageError(ERROR_LEVEL.FATAL, CMS_CONNECT_SETUP_ALARM_MESSAGE);
        //                    else if (availableLanguages.Count < 3 && defAlarmsNamesIt != null)
        //                        if (!RedisController.WriteAlarmsConfigCurr(defAlarmsNamesIt))
        //                            ManageError(ERROR_LEVEL.FATAL, CMS_CONNECT_SETUP_ALARM_MESSAGE);

        //            }
        //            catch (ThreadAbortException)
        //            {
        //                ncAdapter.Dispose();
        //            }
        //        }

        //        #endregion Functions

        //        #region SupportFunctions

        //        private static void TryNcConnection()
        //        {
        //            // Stop all the NC threads
        //            ThreadsHandler.Stop();
        //            StatReset();
        //            NcAdapter ncAdapter = new NcAdapter();
        //            CmsError libraryError = NO_ERROR;
        //            // Run loop until NC is connected
        //            while (!ncAdapter.numericalControl.NC_IsConnected())
        //            {
        //                // Try reconnection
        //                libraryError = ncAdapter.Connect();
        //                if (libraryError.errorCode == CMS_ERROR_CODES.SIEMENS_ENVIRONMENT_NOT_FOUND || libraryError.errorCode == CMS_ERROR_CODES.SIEMENS_HMI_NOT_RUNNING || libraryError.errorCode == CMS_ERROR_CODES.OSAI_TT_FOLDER_NOT_FOUND)
        //                    ManageLibraryError(libraryError);
        //                else if (libraryError.errorCode != CMS_ERROR_CODES.OK)
        //                {
        //                    ncAdapter.Dispose();
        //                }

        //                // Send status to UI
        //                MessageServices.Current.Publish(SEND_NC_STATUS_UI, null, ncAdapter.numericalControl.NC_IsConnected());
        //                // Send status to signalr
        //                MessageServices.Current.Publish(SEND_NC_STATUS, null, ncAdapter.numericalControl.NC_IsConnected());

        //                Thread.Sleep(1000);
        //            }

        //            if (!libraryError.IsError())
        //            {
        //                if (ServerStartupConfig.AutoOpenCmsClient)
        //                    StartCMSClient();

        //                // Start/Restart NC threads
        //                ThreadsHandler.StartWorkers();
        //                reconnectionIsRunning = false;
        //            }
        //        }
        //        public static void RestoreConnection()
        //        {
        //            if (reconnectionIsRunning == false)
        //            {   // Set thread as running state
        //                reconnectionIsRunning = true;

        //                // Start reconnection thread
        //                ConnThread = new Thread(() =>
        //                            TryNcConnection()
        //                );

        //                ConnThread.Start();
        //            }
        //        }
        //        public static void AbortNcConnection()
        //        {
        //            if (ConnThread != null && ConnThread.IsAlive)
        //                ConnThread.Abort();
        //        }
        //        public static void ManageLibraryError(CmsError libraryError)
        //        {
        //            switch (libraryError.errorCode)
        //            {
        //                case CMS_ERROR_CODES.NC_PROD_ERROR:
        //                    ManageError(ERROR_LEVEL.WARNING, libraryError.localizationKey);
        //                    break;

        //                case CMS_ERROR_CODES.NOT_CONNECTED:
        //                    RestoreConnection(); // If not connected try reconnection
        //                    break;

        //                case CMS_ERROR_CODES.SIEMENS_ENVIRONMENT_NOT_FOUND:
        //                case CMS_ERROR_CODES.OSAI_TT_FOLDER_NOT_FOUND:
        //                case CMS_ERROR_CODES.OPTION_NOT_CONSISTENT:
        //                    ManageError(ERROR_LEVEL.FATAL, libraryError.localizationKey);
        //                    break;

        //                case CMS_ERROR_CODES.SIEMENS_HMI_NOT_RUNNING:
        //                    ManageError(ERROR_LEVEL.FATAL, "SIEMENS HMI NOT RUNNING");
        //                    break;

        //                case CMS_ERROR_CODES.SELECTED_PROCESS:
        //                    ManageError(ERROR_LEVEL.WARNING, libraryError.localizationKey);
        //                    break;

        //                case CMS_ERROR_CODES.INTERNAL_ERROR:
        //                    ManageException(ERROR_LEVEL.FATAL, libraryError.exception);
        //                    break;
        //            }
        //        }
        //        internal static void UpdateStat(string functionName, long timer)
        //        {
        //            if (!Timers.ContainsKey(functionName))
        //                Timers.TryAdd(functionName, timer);
        //            else
        //                Timers[functionName] += timer;

        //            if (!Counter.ContainsKey(functionName))
        //                Counter.TryAdd(functionName, 1);
        //            else
        //                Counter[functionName]++;
        //        }
        //        internal static void StatThread()
        //        {
        //            while (true)
        //            {
        //                foreach (var value in Counter)
        //                {
        //                    if (ThreadsHandler.RunningThreadStatus.ContainsKey(value.Key) && Counter[value.Key] != 0)
        //                    {
        //                        ThreadsHandler.RunningThreadStatus[value.Key] = $"{(Timers[value.Key] / Counter[value.Key])} ms x {Counter[value.Key]}";
        //                        Timers[value.Key] = 0;
        //                        Counter[value.Key] = 0;
        //                    }
        //                }

        //                MessageServices.Current.Publish(SEND_THREADS_STATUS, null, ThreadsHandler.RunningThreadStatus);

        //                Thread.Sleep(2000);
        //            }
        //        }
        //        private static void StatReset()
        //        {
        //            foreach (var value in Counter)
        //            {
        //                Timers[value.Key] = 0;
        //                Counter[value.Key] = 0;
        //            }
        //        }
        //        private static int CalcSleepTime(int maxSleep, int execTime)
        //        {
        //            int sleep = 0;
        //            // Check if the execution time is greater than the half of the max sleep time
        //            if (maxSleep - execTime < maxSleep / 2)
        //            {
        //                sleep = maxSleep;
        //            }
        //            else
        //            {
        //                sleep = maxSleep - execTime;
        //            }

        //            return sleep;
        //        }
        //        public static void StartCMSClient()
        //        {
        //            //Setup the Path Variable
        //            if (!ClientIsRunning())
        //            {
        //                ThreadsHandler.StartClient = new Thread(() => clientProcess());
        //                ThreadsHandler.StartClient.Start();
        //            }
        //        }
        //        private static void clientProcess()
        //        {
        //            string CMSClientPath = "";
        //            // Check if the system is 64/32 bit
        //            if (Environment.Is64BitOperatingSystem && File.Exists(CLIENT_PATH_64))
        //                CMSClientPath = CLIENT_PATH_64;
        //            else if (File.Exists(CLIENT_PATH_86))
        //                CMSClientPath = CLIENT_PATH_86;

        //            if (!String.IsNullOrEmpty(CMSClientPath))
        //            {
        //                Process pr = Process.Start(CMSClientPath, null);

        //                if (ServerStartupConfig.AutoOpenCmsClient)
        //                {
        //                    pr.WaitForExit();
        //                    MessageServices.Current.Publish(SEND_STOP_SERVER);
        //                }
        //            }
        //        }
        //        private static bool ClientIsRunning()
        //        {
        //            Process[] p = Process.GetProcessesByName(CLIENT_EXE_NAME_NOEXT);
        //            foreach (Process pr in p)
        //            {
        //                if (pr.MainWindowHandle != IntPtr.Zero)
        //                {
        //                    ShowWindow(pr.MainWindowHandle, 9);
        //                    SetForegroundWindow(pr.MainWindowHandle);
        //                    return true;
        //                }
        //            }
        //            return false;
        //        }
        //        private static Dictionary<string, string> GetPlcAlarmsTranslations(string language)
        //        {
        //            using (NcAdapter ncAdapter = new NcAdapter())
        //            {
        //                Dictionary<string, string> returnValue = new Dictionary<string, string>();

        //                Dictionary<int, string> messages = new Dictionary<int, string>();
        //                // Read data from CN
        //                ncAdapter.numericalControl.NC_GetTranslatedPlcMessages(language, ref messages); // Avoid checking error because in the worst case "messages" is empty

        //                // Id start from 1
        //                for (int i = 1; i <= 1024; i++)
        //                {
        //                    // Get configurated alarms
        //                    var tmpAlarmConfig = InitialAlarmsConfig.Where(x => x.PlcId == i).FirstOrDefault();
        //                    // Default string
        //                    string message = string.Format(NOT_CONFIGURATED_ALARM_MESSAGE, i);
        //                    // If is configurated
        //                    if (tmpAlarmConfig != null)
        //                    {
        //                        // Find translated string
        //                        message = messages.Where(x => x.Key == tmpAlarmConfig.AlarmId).FirstOrDefault().Value;
        //                        if (message == null)
        //                            message = string.Format(NOT_FOUND_ALARM_MESSAGE, i);
        //                    }
        //                    // Add to dictionary
        //                    returnValue.Add(i.ToString("D6") + "|900", message);
        //                }
        //                return returnValue;
        //            }
        //        }

        //        [DllImport("user32.dll")]
        //        static extern bool SetForegroundWindow(IntPtr hWnd);

        //        [DllImport("user32.dll")]
        //        [return: MarshalAs(UnmanagedType.Bool)]
        //        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        //        #endregion SupportFunctions
    }
}