using CMS_CORE_Library.Models;
using Step.CmsConnectManager;
using Step.Config;
using Step.Core;
using Step.Database.Controllers;
using Step.Model.DTOModels;
using Step.Model.DTOModels.AlarmModels;
using Step.Model.DTOModels.Scada;
using Step.Model.DTOModels.ToolModels;
using Step.NC;
using Step.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
using TeamDev.SDK.MVVM;
using static CMS_CORE_Library.Models.DataStructures;
using static Step.Config.ServerConfig;
using static Step.Model.Constants;
using static Step.Utils.ExceptionManager;
using static Step.Core.ThreadsSupportFunctions;

namespace Step.Core.ThreadsFunctions
{
    public static class NcFunctions
    {
        #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();

                    //if(errorCounter == MAX_NUM_OF_WATCHDOG_ERROR)
                    //{

                    //} 

                    // 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(500, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                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(200, (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(400, (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
                        {
                            // Get softkey data from config and PLC
                            libraryError = ncAdapter.GetNcSoftKeys(out List<DTONcSoftKeyModel> ncSoftKeys);
                            if (libraryError.errorCode != 0)
                                ManageLibraryError(libraryError);
                            else
                            {
                                // Send processes through signalR
                                MessageServices.Current.Publish(SEND_PROCESSES_DATA, null, processesPPData);
                                // Send ncSoftKeys through signalR
                                MessageServices.Current.Publish(SEND_NC_SOFTKEYS_DATA, null, ncSoftKeys);
                            }
                        }
                    }
                    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 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())
                    {

                        libraryError = ncAdapter.GetM155Data(out List<DTOM155InputModel> m155Data);
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                        else
                        {
                            // Send m155 through signalR
                            MessageServices.Current.Publish(SEND_M155_DATA, null, m155Data);

                            if (NcConfig.NcVendor != NC_VENDOR.SIEMENS)
                            {
                                libraryError = ncAdapter.GetM156Data(out List<DTOM156InputModel> m156Data);
                                if (libraryError.IsError())
                                    ManageLibraryError(libraryError);
                                else
                                    MessageServices.Current.Publish(SEND_M156_DATA, null, m156Data);
                            }

                            // Read & send M157 data
                            //libraryError = ncAdapter.GetM157Data(out List<DTOM157DataModel> m157Data);
                            //if (libraryError.IsError())
                            //    ManageLibraryError(libraryError);
                            //else
                            //    MessageServices.Current.Publish(SEND_M157_DATA, null, m157Data);
                        }

                    }
                    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(200, (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);

                        //Manage Candies                    
                        libraryError = ncAdapter.ManageCandies();
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(30000);
                }
            }
            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(200, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void ReadHeadsData()
        {
            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 config and PLC
                        libraryError = ncAdapter.GetHeadsData(out List<DTOHeadModel> heads);
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                        else
                            // Send through signalR
                            MessageServices.Current.Publish(SEND_HEADS_DATA, null, heads);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(500, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void ReadAxesNamesData()
        {
            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 config and PLC
                        libraryError = ncAdapter.ReadAxisData(out List<DTOAxisNameModel> axes);
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                        else
                            // Send through signalR
                            MessageServices.Current.Publish(SEND_AXIS_NAMES_DATA, null, axes);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(800, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void ReadAxesPositionsData()
        {
            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.GetAxesPositionsBySelectedProcess(out DTOAxesModel axesPositions);
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                        else
                            // Send through signalR
                            MessageServices.Current.Publish(SEND_AXES, null, axesPositions);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(100, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void ReadMagazinesStatus()
        {
            SiemensToolTableAdapter ncAdapter = new SiemensToolTableAdapter();
            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 config and PLC
                        libraryError = ncAdapter.GetMagazineStatus(out DTOMagazineActionModel magazineStatus);
                        if (libraryError.errorCode != 0)
                            ManageLibraryError(libraryError);
                        else
                            // Send through signalR
                            MessageServices.Current.Publish(SEND_MAGAZINES_STATUS, null, magazineStatus);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(1000, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void ReadActiveProgramData()
        {
            NcFileAdapter ncAdapter = new NcFileAdapter();
            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 config and PLC
                        libraryError = ncAdapter.GetActiveProgramInfo(out DTOActiveProgramDataModel active);

                        if (libraryError.IsError())
                            ManageLibraryError(libraryError);
                        else
                            // Send through signalR
                            MessageServices.Current.Publish(SEND_ACTIVE_PROGRAM_DATA, null, active);
                    }
                    else
                        RestoreConnection();

                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(400, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }

        public static void UpdateToolsData()
        {
            NcToolTableAdapter ncAdapter = new NcToolTableAdapter();
            Stopwatch sw = new Stopwatch();

            if (NcConfig.NcVendor != NC_VENDOR.SIEMENS)
            {
                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.GetUpdatedToolsData(out Dictionary<int, byte> updatedStatus, out Dictionary<int, uint> updatedLives);
                            if (libraryError.IsError())
                                ManageLibraryError(libraryError);

                            MessageServices.Current.Publish(UPDATE_TOOLS_DATA, null,
                            new DTONewToolDataModel
                            {
                                UpdatedStatus = updatedStatus,
                                UpdatedLives = updatedLives
                            });
                        }
                        else
                            RestoreConnection();
                        sw.Stop();

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

                        // Wait
                        Thread.Sleep(CalcSleepTime(1000, (int)sw.ElapsedMilliseconds));
                    }
                }
                catch (ThreadAbortException)
                {
                    ncAdapter.Dispose();
                }
            }
        }

        public static void ReadNcMagazineActive()
        {
            if (NcConfig.NcVendor != NC_VENDOR.SIEMENS)
            {
                NcToolTableAdapter ncAdapter = new NcToolTableAdapter();
                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.GetNcMagazineStatus(out Dictionary<int, bool> status);
                            if (libraryError.IsError())
                                ManageLibraryError(libraryError);

                            MessageServices.Current.Publish(NC_MAGAZINE_IS_ACTIVE, null, status);

                            libraryError = ncAdapter.ReadAssistedToolingProcedure(out DTOAssistedToolingEndValueModel data);
                            if (libraryError.IsError())
                                ManageLibraryError(libraryError);

                            MessageServices.Current.Publish(ASSISTED_TOOLING_DATA, null, data);
                        }
                        else
                            RestoreConnection();
                        sw.Stop();

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

                        // Wait
                        Thread.Sleep(CalcSleepTime(500, (int)sw.ElapsedMilliseconds));
                    }
                }
                catch (ThreadAbortException)
                {
                    ncAdapter.Dispose();
                }
            }
        }

        public static void ReadPartProgramQueueData()
        {
            NcFileAdapter ncAdapter = new NcFileAdapter();
            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())
                    {
                        // Read data
                        libraryError = ncAdapter.UpdateQueue();
                        if (libraryError.IsError())
                            ManageLibraryError(libraryError);

                        libraryError = ncAdapter.GetSelectedProcessQueue(out List<DTOQueueModel> queue);
                        if (libraryError.IsError())
                            ManageLibraryError(libraryError);

                        MessageServices.Current.Publish(SEND_QUEUE_DATA, null, queue);
                    }
                    else
                        RestoreConnection();
                    sw.Stop();

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

                    // Wait
                    Thread.Sleep(CalcSleepTime(500, (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(500, (int)sw.ElapsedMilliseconds));
                }
            }
            catch (ThreadAbortException)
            {
                ncAdapter.Dispose();
            }
        }
    }
    #endregion Functions
}