using GWMS.Data.DatabaseModels;
using GWMS.UI.Data;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using static GWMS.Data.IobObjects;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace GWMS.UI.Controllers
{
    /// <summary>
    /// COntroller principale x dichiaraizone da IOB-WIN x GWMS
    ///
    /// per la conf dei verb http:
    /// https://docs.microsoft.com/en-us/aspnet/core/mvc/controllers/routing?view=aspnetcore-5.0
    /// https://stormpath.com/blog/routing-in-asp-net-core
    ///
    /// </summary>

    [Route("api/[controller]")]
    [ApiController]
    public class IOBController : ControllerBase
    {
        #region Public Constructors

        public IOBController(GWMSDataService DataService)
        {
            _DataService = DataService;
        }

        #endregion Public Constructors

        #region Protected Properties

        protected GWMSDataService _DataService { get; set; }

        #endregion Protected Properties

        #region Public Methods

        /// <summary>
        /// SALVA x macchina KVP parametro/valore:
        ///
        /// GET: IOB/addOptPar/SIMUL_03?pName=PZREQ&pValue=1000
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <param name="pName"></param>
        /// <param name="pValue"></param>
        [HttpGet("addOptPar/{id}")]
        public string addOptPar(string id, string pName, string pValue)
        {
            return $"N.A. | {id} | {pName} | {pValue}";
        }

        /// <summary>
        /// AGGIUNGE TASK richiesto x macchina:
        ///
        /// GET: IOB/addTask2Exe/3010?taskName=startSetup&taskVal=T190406101512
        /// GET: IOB/addTask2Exe/3010?taskName=stopSetup&taskVal=T190406101512
        /// GET: IOB/addTask2Exe/SIMUL_03?taskName=setProg&taskVal=P00000001
        /// GET: IOB/addTask2Exe/SIMUL_03?taskName=setComm&taskVal=ODL_0000123
        /// GET: IOB/addTask2Exe/SIMUL_03?taskName=setArt&taskVal=ART_0000321
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <param name="taskName"></param>
        /// <param name="taskVal"></param>
        [HttpGet("addTask2Exe/{id}")]
        public string addTask2Exe(string id, string taskName, string taskVal)
        {
            return $"N.A. | {id} | {taskName} | {taskVal}";
        }

        /// <summary>
        /// Controllo status Alive
        ///
        /// GET: IOB/alive
        /// </summary>
        /// <returns></returns>
        [HttpGet("alive")]
        public string alive()
        {
            return $"OK";
        }

        // DELETE api/IOB/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }

        /// <summary>
        /// Verifica abilitazione PLANT
        ///
        /// GET: IOB/enabled/SIMUL_03
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("enabled/{id}")]
        public async Task<string> enabled(string id)
        {
            string answ = "ND";
            // se id nullo --> KO!
            if (id == null)
            {
                answ = "KO";
            }
            else
            {
                var currPlant = await _DataService.PlantsGetByCode(id);
                answ = (currPlant != null && currPlant.PlantId > 0) ? "OK" : "NO";
            }
            return answ;
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di un array Json di oggetti input (EVENTI)
        /// PUT: api/IOB/evListJson/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost("evListJson/{id}")]
        public string evListJson(string id, [FromBody] evJsonPayload rawData)
        {
            string answ = "N.A.";
#if false
            int insDone = 0;

            // se ho qualcosa da processare...
            if (fluxData != null)
            {
                // per ogni valore --> processo!
                try
                {
                    foreach (var item in receivedData.eventList)
                    {
                        if (memLayer.ML.CRI("_logLevel") > 6)
                        {
                            logger.lg.scriviLog($"Valori letti: idxMacchina: {id} | valore: {item.valore}", tipoLog.INFO);
                        }

                        // formato datetime come yyyyMMddHHmmssfff -->es: 20181223180600000
                        answ = DataLayerObj.processInput(id, item.valore, item.dtEve.ToString("yyyyMMddHHmmssfff"), item.dtCurr.ToString("yyyyMMddHHmmssfff"), item.cnt.ToString());
                        insDone++;
                    }
                    // se vuoto --> OK!
                    if (string.IsNullOrEmpty(answ))
                    {
                        answ = $"OK {insDone} processed";
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog($"Errore in fase invio valori inputJson{Environment.NewLine}{exc}");
                    answ = "NO";
                }
            }
#endif
            return answ;
        }

        /// <summary>
        /// Scrittura diretta di 1 singolo evento fluxLog
        ///
        /// GET: IOB/flog/SIMUL_03?flux=PROG&valore=P0001&dtEve=20161223180600000&dtCurr=20161223180600000&cnt=999
        /// </summary>
        /// <param name="id"></param>
        /// <param name="flux"></param>
        /// <param name="valore"></param>
        /// <param name="dtEve"></param>
        /// <param name="dtCurr"></param>
        /// <param name="cnt"></param>
        /// <returns></returns>
        [HttpGet("flog/{id}")]
        public string flog(string id, string flux, string valore, string dtEve, string dtCurr, string cnt)
        {
            bool fatto = false;
            // formato yyyymmddHHMMSSnnn ovvero da anno a millisecondi
            if (cnt == null)
            {
                cnt = "0";
            }
            try
            {
                // 2017.09.14 trimmo eventualmente lo zero finale dalle date SE supera i millisecondi...
                dtEve = dtEve.Length > 17 ? dtEve.Substring(0, 17) : dtEve;
                dtCurr = dtCurr.Length > 17 ? dtCurr.Substring(0, 17) : dtCurr;
                DateTime dataOraEvento = DateTime.Now;
                DateTime dtEvento, dtCorrente;
                // controllo: se ho valori dt x evento e orario DIVERSI per acquisitore IOB calcolo dataOraEvento corretto
                if (dtEve != dtCurr)
                {
                    Int64 delta = 0;
                    try
                    {
                        // se ho meno decimali x evento rispetto dtCorrente...
                        if (dtEve.Length < dtCurr.Length)
                        {
                            dtEve = dtEve.PadRight(dtCurr.Length, '0');
                        }
                        delta = Convert.ToInt64(dtCurr) - Convert.ToInt64(dtEve);
                        // se meno di 60'000 ms ...
                        if (delta < 59999)
                        {
                            dataOraEvento = dataOraEvento.AddMilliseconds(-delta);
                        }
                        else
                        {
                            // in questo caso elimino i MS dalle stringhe e converto i datetime....
                            CultureInfo provider = CultureInfo.InvariantCulture;
                            string format = "yyyyMMddHHmmssfff";
                            dtEvento = DateTime.ParseExact(dtEve, format, provider);
                            dtCorrente = DateTime.ParseExact(dtCurr, format, provider);
                            Int64 tiks = dtCorrente.Ticks - dtEvento.Ticks;
                            dataOraEvento = dataOraEvento.AddTicks(-tiks);
                        }
                    }
                    catch (Exception exc)
                    { }
                }

                // recupero plant!
                var currPlant = _DataService.PlantsGetByCode(id).Result;
                if (currPlant != null && currPlant.PlantId > 0)
                {
                    double valDbl = 0;
                    double.TryParse(valore, out valDbl);
                    // converto in plantLogModel...
                    PlantLogModel newItem = new PlantLogModel()
                    {
                        PlantId = currPlant.PlantId,
                        FluxType = flux,
                        ValNumber = valDbl,
                        ValString = valore,
                        DtEvent = dataOraEvento
                    };

                    List<PlantLogModel> newData = new List<PlantLogModel>();
                    newData.Add(newItem);
                    // insert!
                    fatto = _DataService.PlantLogInsert(newData);
                }
            }
            catch (Exception exc)
            {
                fatto = false;
            }

            if (fatto)
            {
                return "Ok";
            }
            else
            {
                return "NO";
            }
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di un array Json di oggetti fluxLog
        /// PUT: api/IOB/flogJson/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost("flogJson/{id}")]
        public string flogJson(string id, [FromBody] flogJsonPayload rawData)
        {
            bool fatto = false;
            // verifico ci sia valore
            if (rawData != null && !string.IsNullOrEmpty(id))
            {
                // recupero plant!
                var currPlant = _DataService.PlantsGetByCode(id).Result;
                if (currPlant != null && currPlant.PlantId > 0)
                {
                    // conversione dati
                    List<PlantLogModel> plData = rawData.fluxData.Select(l => _DataService.convertFluxToPL(1, l)).ToList();
                    //insert!
                    fatto = _DataService.PlantLogInsert(plData);
                }
            }
            if (fatto)
            {
                return "Ok";
            }
            else
            {
                return "NO";
            }
        }

        /// <summary>
        /// Chiude ODL precedente ed avvia uno nuovo (duplicandolo e sitemando quantità RIMANENTE), e CONFERMA produzione...
        ///
        /// GET: IOB/forceSplitOdl/SIMUL_03
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns>Esito chiamata (OK/vuoto)</returns>
        [HttpPost("forceSplitOdl/{id}")]
        public string forceSplitOdl(string id)
        {
            return "OK";
        }

        /// <summary>
        /// Chiude ODL precedente ed avvia uno nuovo (duplicandolo e sitemando quantità RIMANENTE), e CONFERMA produzione...
        ///
        /// GET: IOB/forceSplitOdl/SIMUL_03?doConfirm=true&qtyFromLast=true&roundStep=150&extOrderCode=ABCDE1234
        ///
        /// </summary>
        /// <param name="id">id impianto</param>
        /// <param name="doConfirm"></param>
        /// <param name="qtyFromLast"></param>
        /// <param name="roundStep"></param>
        /// <param name="keyRichiesta">Cod esterno da legare all'ODL x tracciare lotti prod</param>
        /// <returns>Esito chiamata (OK/vuoto)</returns>
        [HttpPost("forceSplitOdlFull/{id}")]
        public string forceSplitOdlFull(string id, bool doConfirm, bool qtyFromLast, int? roundStep, string keyRichiesta = "")
        {
            return "OK";
        }

        /// <summary>
        /// Classe di base usata come check alive
        ///
        /// GET: api/IOB
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string Get()
        {
            return "OK";
        }

        /// <summary>
        /// Classe di base usata come check alive
        ///
        /// GET api/IOB/PIZ08
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("{id}")]
        public string Get(int id)
        {
            return "OK";
        }

        /// <summary>
        /// Recupera COUNTER x macchina:
        ///
        /// GET: IOB/getCounter/5
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCounter/{id}")]
        public string getCounter(string id)
        {
            return "0";
        }

        /// <summary>
        /// Recupera COUNTER x macchina dal CONTEGGIO dei TCRecorded:
        ///
        /// GET: IOB/getCounterTCRec/5
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCounterTCRec/{id}")]
        public string getCounterTCRec(string id)
        {
            return "0";
        }

        /// <summary>
        /// Recupera DATI correnti x macchina:
        ///
        /// GET: IOB/getCurrData/SIMUL_03
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns>Json contenente la riga di stato macchina</returns>
        [HttpGet("getCurrData/{id}")]
        public string getCurrData(string id)
        {
            return $"{id}";
        }

        /// <summary>
        /// Recupera ODL corrente x macchina:
        ///
        /// GET: IOB/getCurrODL/SIMUL_03
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCurrODL/{id}")]
        public string getCurrODL(string id)
        {
            return "1";
        }

        /// <summary>
        /// Restituisce intera riga dell'odl correntemente in lavorazione sulla macchina...
        /// GET: IOB/getCurrOdlRow/SIMUL_01
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCurrOdlRow/{id}")]
        public string getCurrOdlRow(string id)
        {
            return "";
        }

        /// <summary>
        /// Restituisce data-ora inizio dell'odl correntemente in lavorazione sulla macchina...
        /// es: http://url_site/MP/IO/IOB/getCurrOdlStart/SIMUL_03
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCurrOdlStart/{id}")]
        public string getCurrOdlStart(string id)
        {
            return $"{DateTime.Now}";
        }

        /// <summary>
        /// Restituisce intera riga dello stato di macchina...
        /// GET: IOB/getCurrStatoRow/SIMUL_01
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getCurrStatoRow/{id}")]
        public string getCurrStatoRow(string id)
        {
            return "";
        }

        /// <summary>
        /// Restituisce un array JSon di files di una IOB
        /// PUT: IOB/getFiles/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns>Oggetto Json in formato MapoSDK.fileEmbed</returns>
        [HttpGet("getFiles/{id}")]
        public string getFiles(string id)
        {
            return "";
        }

        /// <summary>
        /// Restituisce il valore dello stato di IDLE della macchina, quindi SOLO SE NON é in lavoro e già convertito in minuti...
        /// GET: IOB/getIdlePeriod/SIMUL_01
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("getIdlePeriod/{id}")]
        public int getIdlePeriod(string id)
        {
            return 0;
        }

        /// <summary>
        /// Restituisce il (primo) codice IOB da dover gestire (se un IOBMAN chiede di gestirne uno in +...)
        /// </summary>
        /// <param name="GWIP">IP del Gateway</param>
        /// <returns></returns>
        [HttpGet("getIob2call/{id}")]
        public string getIob2call(string id)
        {
            return "";
        }

        /// <summary>
        /// Restituisce dati di associazione tra macchina, device IOB chiamante e sue info
        /// </summary>
        /// <param name="id">Id della macchina</param>
        /// <returns></returns>
        [HttpGet("getM2IOB/{id}")]
        public string getM2IOB(string id)
        {
            return "";
        }

        /// <summary>
        /// restituisce elenco parametri correnti come una List Json di oggetti objItem
        /// GET: IOB/getObjItems/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpGet("getObjItems/{id}")]
        public string getObjItems(string id)
        {
            return "";
        }

        /// <summary>
        /// Recupera TASK richiesto x macchina:
        ///
        /// GET: IOB/getTask2Exe/SIMUL_03
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns>Json contenente 1..n task da eseguire</returns>
        [HttpGet("getTask2Exe/{id}")]
        public string getTask2Exe(string id)
        {
            string answ = "";
#if false
            // scrivo keep alive!!! (se necessario, altrimenti è in cache...)
            MapoDb.MapoDb connDb = new MapoDb.MapoDb();
            DataLayer DataLayerObj = new DataLayer();
            connDb.scriviKeepAlive(id, DateTime.Now);
#endif
            try
            {
                // leggo da REDIS eventuale elenco task x macchina...
                Dictionary<string, string> valori = _DataService.mTaskMacchina(id).Result;
                answ = JsonConvert.SerializeObject(valori);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Input singolo valore
        /// </summary>
        /// <param name="id"></param>
        /// <param name="valore"></param>
        /// <param name="dtEve"></param>
        /// <param name="dtCurr"></param>
        /// <param name="cnt"></param>
        /// <returns></returns>
        // GET: IOB/input/SIMUL_03?valore=3&dtEve=20181206180600000&dtCurr=20181206180600000&cnt=999
        [HttpGet("input/{id}")]
        public string input(string id, string valore, string dtEve, string dtCurr, string cnt)
        {
            string answ = "OK";
#if false
            // formato yyyymmddHHMMSSnnn ovvero da anno a millisecondi
            if (cnt == null)
            {
                cnt = "0";
            }

            DateTime dataOraEvento = DateTime.Now;
            if (memLayer.ML.CRI("_logLevel") > 6)
            {
                logger.lg.scriviLog($"Valori letti: idxMacchina: {id} | valore: {valore}", tipoLog.INFO);
            }
            try
            {
                DataLayer DataLayerObj = new DataLayer();
                answ = DataLayerObj.processInput(id, valore, dtEve, dtCurr, cnt);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore in processInput{0}{1}", Environment.NewLine, exc));
                answ = "NO";
            }
#endif
            return answ;
        }

        // POST api/IOB
        [HttpPost]
        public void Post([FromBody] string value)
        {
        }

        // PUT api/IOB/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

#if false

        /// <summary>
        /// restituisce elenco parametri CHE RICHIEDONO scrittura su PLC come una List Json di oggetti objItem
        /// GET: IOB/getObjItems2Write/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        public string getObjItems2Write(string id)
        {
            string answ = "";
            if (string.IsNullOrWhiteSpace(id))
            {
                answ = "Missing IOB";
            }
            else
            {
                // procedo a recuperare l'oggetto...
                List<objItem> currParams = new List<objItem>();
                try
                {
                    DataLayer DataLayerObj = new DataLayer();
                    // deserializzo.
                    currParams = DataLayerObj.getCurrObjItemsPendigWrite(id);
                    // se != null --> salvo!
                    if (currParams != null)
                    {
                        answ = JsonConvert.SerializeObject(currParams);
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog($"Errore in getCurrParams{Environment.NewLine}{exc}");
                    answ = "NO";
                }
            }
            return answ;
        }

        /// <summary>
        /// Recupera TASK richiesto x macchina:
        ///
        /// GET: IOB/getOptPar/SIMUL_03
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns>Json contenente 1..n task da eseguire</returns>
        public string getOptPar(string id)
        {
            string answ = "";
            // scrivo keep alive!!! (se necessario, altrimenti è in cache...)
            MapoDb.MapoDb connDb = new MapoDb.MapoDb();
            connDb.scriviKeepAlive(id, DateTime.Now);
            try
            {
                // leggo da REDIS eventuale elenco task x macchina...
                DataLayer DataLayerObj = new DataLayer();
                Dictionary<string, string> valori = DataLayerObj.mOptParMacchina(id);
                answ = JsonConvert.SerializeObject(valori);
            }
            catch
            { }
            return answ;
        }

        // GET: IOB (è un check alive del server)
        public string Index()
        {
            if (memLayer.ML.CRB("IOB_RedEnab"))
            {
                // conto la richiesta nel contatore REDIS
                long nCall = memLayer.ML.setRCntI(DataLayer.mHash("COUNT:pCall:IOB_INDEX"));
                //... se == nCall2Log scrivo su log e resetto
                long nCall2Log = memLayer.ML.cdvi("nCall2Log");
                if (nCall >= nCall2Log)
                {
                    // loggo
                    logger.lg.scriviLog(string.Format("IOB_INDEX: effettuate {0} call", nCall), tipoLog.INFO);
                    // resetto!
                    memLayer.ML.resetRCnt(DataLayer.mHash("COUNT:pCall:IOB_INDEX"));
                }
            }
            return "OK";
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di un array Json di oggetti LIVE REC
        /// PUT: IOB/liveJson/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost]
        public string liveJson(string id)
        {
            string answ = "-";
            // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
            string content = "";
            System.Web.HttpContext.Current.Request.InputStream.Position = 0;
            using (var reader = new StreamReader(
                     Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
            {
                content = reader.ReadToEnd();
            }
            //Rest
            System.Web.HttpContext.Current.Request.InputStream.Position = 0;
            // procedo a deserializzare in blocco l'oggetto...
            try
            {
                // deserializzo.
                liveIOB receivedData = JsonConvert.DeserializeObject<liveIOB>(content);
                DataLayer DataLayerObj = new DataLayer();
                answ = DataLayerObj.processLiveJson(id, receivedData);
                // se vuoto --> OK!
                if (string.IsNullOrEmpty(answ))
                {
                    answ = "OK 1 done";
                }
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Errore in liveJson{Environment.NewLine}{exc}");
                answ = "NO";
            }
            return answ;
        }

        // GET: IOB/liveRec/SIMUL_03?&liveData=chiave1|valore1#chiave2|valore#|chiave3|valore3
        public string liveRec(string id, string liveData)
        {
            string answ = "";
            DateTime dataOraEvento = DateTime.Now;
            if (memLayer.ML.CRI("_logLevel") > 6)
            {
                logger.lg.scriviLog($"Valori Live:{Environment.NewLine}idxMacchina: {id}{Environment.NewLine}liveData: {liveData}", tipoLog.INFO);
            }
            try
            {
                DataLayer DataLayerObj = new DataLayer();
                answ = DataLayerObj.processLiveRec(id, liveData);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Errore in liveRec{Environment.NewLine}{exc}");
                answ = "NO";
            }
            return answ;
        }

        /// <summary>
        /// ELIMINA TASK richiesto x macchina:
        ///
        /// GET: IOB/remOptPar/SIMUL_03?pName=PZREQ
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <param name="pName"></param>
        public string remOptPar(string id, string pName)
        {
            string answ = "";
            // scrivo keep alive!!! (se necessario, altrimenti è in cache...)
            MapoDb.MapoDb connDb = new MapoDb.MapoDb();
            DataLayer DataLayerObj = new DataLayer();
            connDb.scriviKeepAlive(id, DateTime.Now);
            try
            {
                DataLayerObj.remOptPar4Machine(id, pName);
                answ = getOptPar(id);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// ELIMINA TASK richiesto x macchina:
        ///
        /// GET: IOB/remTask2Exe/SIMUL_03?taskName=T180326160502
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <param name="taskName"></param>
        public string remTask2Exe(string id, string taskName)
        {
            string answ = "";
            // scrivo keep alive!!! (se necessario, altrimenti è in cache...)
            MapoDb.MapoDb connDb = new MapoDb.MapoDb();
            DataLayer DataLayerObj = new DataLayer();
            connDb.scriviKeepAlive(id, DateTime.Now);
            try
            {
                // converto stringa in tipo task...
                taskType tName = taskType.nihil;
                bool fatto = Enum.TryParse(taskName, out tName);
                if (fatto)
                {
                    DataLayerObj.remTask4Machine(id, tName);
                }
                else
                {
                    logger.lg.scriviLog($"remTask2Exe: impossibile riconoscere il comando {taskName} come uno deitipi ammessi, NON aggiunto", tipoLog.ERROR);
                }
                answ = getTask2Exe(id);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Effettua RESET dell'ODL corrente x macchina:
        ///
        /// GET: IOB/resetCurrODL/5
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string resetCurrODL(string id)
        {
            DataLayer DataLayerObj = new DataLayer();
            return DataLayerObj.emptyCurrODL(id);
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di un array Json di oggetti di conf DataItems (es per MTC)
        /// PUT: IOB/saveDataItems/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost]
        public string saveDataItems(string id)
        {
            string answ = "";
            if (string.IsNullOrWhiteSpace(id))
            {
                answ = "Missing IOB";
            }
            else
            {
                // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
                string content = "";
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
                {
                    content = reader.ReadToEnd();
                }
                // Rest
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;

                // procedo a deserializzare in blocco l'oggetto...
                List<machDataItem> dataItems = null;
                try
                {
                    // deserializzo.
                    dataItems = JsonConvert.DeserializeObject<List<machDataItem>>(content);
                    // se != null --> salvo!
                    if (dataItems != null)
                    {
                        // chiamo metodo update direttamente!
                        MtcDataModelArchive.man.saveMachineDataItems(id, dataItems);
                        answ = "OK";
                    }
                }
                catch
                { }
            }
            return answ;
        }

        /// <summary>
        /// SALVA in blocco un incremento pezzi x macchina restituendo il valore appena inviato o, se mancasse chaive redis, del valore da DB
        ///
        /// GET: IOB/savePzCountInc/5?qty=10
        ///
        /// </summary>
        /// <param name="id">codice macchina</param>
        /// <param name="qty">num peziz da salvare in blocco</param>
        /// <returns></returns>
        public string savePzCountInc(string id, string qty)
        {
            string answ = "";
            DateTime dataOraEvento = DateTime.Now;
            // salvo SEMPRE log x questo tipo di dati!
            logger.lg.scriviLog($"Salvataggio incremento contapezzi:{Environment.NewLine}idxMacchina: {id}{Environment.NewLine}pezzi: {qty}", tipoLog.INFO);
            try
            {
                DataLayer DataLayerObj = new DataLayer();
                answ = DataLayerObj.saveCaricoPezzi(id, qty);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Errore in savePzCountInc{Environment.NewLine}{exc}");
                answ = "NO";
            }
            return answ;
        }

        /// <summary>
        /// Salva IP del gateway dopo il reboot
        /// </summary>
        /// <param name="GWIP">IP del Gateway</param>
        /// <returns></returns>
        public string sendRebootGateway(string GWIP)
        {
            string answ = "OK";

            // !!!FARE!!! deve salvare il riavvio dell'applicazione GATEWAY multiclient

            return answ;
        }

        /// <summary>
        /// SALVA Counter x macchina restituendo il valore appena inviato o, se mancasse chiave redis, del valore da DB
        ///
        /// GET: IOB/setCounter/5?counter=10
        ///
        /// </summary>
        /// <param name="id">cod macchina</param>
        /// <param name="counter">contapezzi da salvare</param>
        /// <returns></returns>
        public string setCounter(string id, string counter)
        {
            string answ = "-1";
            DateTime dataOraEvento = DateTime.Now;
            if (memLayer.ML.CRI("_logLevel") > 6)
            {
                logger.lg.scriviLog($"Salvataggio counter | idxMacchina: {id}", tipoLog.INFO);
            }
            try
            {
                DataLayer DataLayerObj = new DataLayer();
                answ = DataLayerObj.saveCounter(id, counter);
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore in counter (set){0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Salva associazione tra macchina, device IOB chiamante e sue info
        /// </summary>
        /// <param name="id">Id della macchina</param>
        /// <param name="IOB_name">Nome dell'IOB di acquisizione della macchina</param>
        /// <returns></returns>
        public string setM2IOB(string id, string IOB_name)
        {
            string answ = "";
            try
            {
                // recupero IP del client remoto
                string IPv4 = Request.UserHostName;
                string agent = Request.UserAgent;
                // creo oggetto IOB_data...
                IOB_data m2IOB = new IOB_data
                {
                    name = IOB_name,
                    IP = IPv4,
                    iType = IobType.ND,
                    typeCss = "fa fa-question-circle-o",
                    CNC_Counter = false
                };
                // imposto tipo ed icona come windows/linux secondo UserAgent...
                if (agent.IndexOf("WIN") >= 0)
                {
                    m2IOB.iType = IobType.WIN;
                    m2IOB.typeCss = "fa fa-windows";
                    m2IOB.CNC_Counter = true;
                }
                else if (agent.IndexOf("Python") >= 0)
                {
                    m2IOB.iType = IobType.rPi;
                    m2IOB.typeCss = "fa fa-linux";
                }
                // serializzo...
                string dataSer = JsonConvert.SerializeObject(m2IOB);
                // salvo in redis...
                string hM2IOB = DataLayer.hM2IOB(id);
                memLayer.ML.setRSV(hM2IOB, dataSer);
                // salvo tutto OK
                answ = "OK";
            }
            catch
            {
                answ = "KO";
            }
            return answ;
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di una List Json di oggetti objItem
        /// POST: IOB/setObjItems/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost]
        public string setObjItems(string id)
        {
            string answ = "";
            if (string.IsNullOrWhiteSpace(id))
            {
                answ = "Missing IOB";
            }
            else
            {
                // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
                string content = "";
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
                {
                    content = reader.ReadToEnd();
                }
                //Rest
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                // procedo a deserializzare in blocco l'oggetto...
                List<objItem> currParams = new List<objItem>();
                try
                {
                    // deserializzo.
                    currParams = JsonConvert.DeserializeObject<List<objItem>>(content);
                    // se != null --> salvo!
                    if (currParams != null)
                    {
                        DataLayer DataLayerObj = new DataLayer();
                        DataLayerObj.setCurrObjItems(id, currParams);
                        answ = "OK";
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog($"Errore in setCurrParams{Environment.NewLine}{exc}");
                    answ = "NO";
                }
            }
            return answ;
        }

        // GET: IOB/slog/SIMUL_03
        public string slog(string id)
        {
            string answ = "ND";
            // se id nullo --> KO!
            if (id == null)
            {
                answ = "KO";
            }
            else
            {
                try
                {
                    DataLayer DataLayerObj = new DataLayer();
                    // salvo risposta
                    answ = DataLayerObj.sLogEnab(id) ? "OK" : "NO";
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore in sLog{0}{1}", Environment.NewLine, exc));
                    answ = "NO";
                }
            }
            return answ;
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di una List Json di UNO O PIU' oggetti objItem
        /// POST: IOB/upsertObjItems/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost]
        public string upsertObjItems(string id)
        {
            string answ = "";
            if (string.IsNullOrWhiteSpace(id))
            {
                answ = "Missing IOB";
            }
            else
            {
                // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
                string content = "";
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
                {
                    content = reader.ReadToEnd();
                }
                //Rest
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                // procedo a deserializzare in blocco l'oggetto...
                List<objItem> innovazioni = new List<objItem>();
                try
                {
                    // deserializzo.
                    innovazioni = JsonConvert.DeserializeObject<List<objItem>>(content);
                    // se != null --> salvo!
                    if (innovazioni != null)
                    {
                        // salvo
                        DataLayer DataLayerObj = new DataLayer();
                        DataLayerObj.upsertCurrObjItems(id, innovazioni);
                        answ = "OK";
                    }
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog($"Errore in setCurrParams{Environment.NewLine}{exc}");
                    answ = "NO";
                }
            }
            return answ;
        }

#endif

        /// <summary>
        /// Processa una chiamata POST per l'invio di un array Json di oggetti plcMemConf
        /// PUT: IOB/saveConf/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost("saveConf/{id}")]
        public string saveConf(string id, [FromBody] plcMemMap rawData)
        {
            string answ = "OK";
#if false
            if (string.IsNullOrWhiteSpace(id))
            {
                answ = "Missing IOB";
            }
            else
            {
                // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
                string content = "";
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
                {
                    content = reader.ReadToEnd();
                }
                //Rest
                System.Web.HttpContext.Current.Request.InputStream.Position = 0;
                // procedo a deserializzare in blocco l'oggetto...
                plcMemMap currMemMap = null;
                try
                {
                    // deserializzo.
                    currMemMap = JsonConvert.DeserializeObject<plcMemMap>(content);
                    // se != null --> salvo!
                    if (currMemMap != null)
                    {
                        DataLayer DataLayerObj = new DataLayer();
                        DataLayerObj.setIobMemMap(id, currMemMap);
                        answ = "OK";
                    }
                }
                catch
                { }
            }
#endif
            return answ;
        }

        /// <summary>
        /// Salva IP e macchina
        /// </summary>
        /// <param name="GWIP">IP del Gateway</param>
        /// <returns></returns>
        [HttpGet("sendReboot")]
        public string sendReboot(string idxMacchina, string mac)
        {
            string answ = "";
            try
            {
                // registrazione startup IOB-WIN e macchina
                RebootLogModel newItem = new RebootLogModel()
                {
                    DtEvent = DateTime.Now,
                    Item = idxMacchina,
                    Payload = mac
                };
                _DataService.RebootLogInsert(newItem);
                answ = "OK";
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Processa una chiamata POST per l'invio di un SET di file "a nome" di un IOB, formato MapoSDK.fileEmbed
        /// PUT: IOB/uploadFile/SIMUL_03
        /// </summary>
        /// <param name="id">ID dell'IOB</param>
        /// <returns></returns>
        [HttpPost("uploadFile/{id}")]
        public string uploadFile(string id)
        {
            string answ = "";
#if false
            // questa classe è derivata da Controller.Response... x cui recupero lo stream in altro modo...
            string content = "";
            System.Web.HttpContext.Current.Request.InputStream.Position = 0;
            using (var reader = new StreamReader(Request.InputStream, System.Text.Encoding.UTF8, true, 4096, true))
            {
                content = reader.ReadToEnd();
            }
            //Rest
            System.Web.HttpContext.Current.Request.InputStream.Position = 0;
            // procedo a deserializzare in blocco l'oggetto...
            try
            {
                // deserializzo.
                fileEmbed receivedData = JsonConvert.DeserializeObject<fileEmbed>(content);
                // salvo nella cartella di Upload...
                string basePath = Server.MapPath(memLayer.ML.CRS("uploadFileDir"));
                string dirPath = $"{basePath}\\{id}";
                // fix directory...
                Directory.CreateDirectory(dirPath);
                foreach (var item in receivedData.fileList)
                {
                    // scrivo!
                    System.IO.File.WriteAllText($"{dirPath}\\{item.fileName}", item.content);
                }
                answ = "OK";
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Errore in uploadFile{Environment.NewLine}{exc}");
                answ = "NO";
            }
#endif
            return answ;
        }

        #endregion Public Methods
    }
}