using EgtBEAMWALL.DataLayer.DatabaseModels;
using EgwProxy.MagMan.DTO;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;

namespace EgtBEAMWALL.DataLayer.Controllers
{
    public class LogMachineController : IDisposable
    {
        #region Public Constructors

        public LogMachineController()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Helper conversione a LogMachineDTO
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public static LogMachineDTO ConvToItemDto(LogMachineModel currRec)
        {
            LogMachineDTO answ = new LogMachineDTO()
            {
                DtEvent = currRec.DtEvent,
                EvType = (EgwProxy.MagMan.MachLogTypes)currRec.EvType,
                ProjCloudId = currRec.ProjCloudId,
                SupervId = currRec.SupervId,
                VarValue = currRec.VarValue
            };
            return answ;
        }

        /// <summary>
        /// Conversion of base class to DB model class
        /// </summary>
        /// <param name="coreMacLog"></param>
        /// <returns></returns>
        public LogMachineModel ConvertFromCore(Core.MachLog coreMacLog)
        {
            int projCloudId = 0;
            // calcolo projCloudId da ProdId...
            using (var localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // Add to database
                var projRec = localDbCtx.ProdList.Where(x => x.ProdId == coreMacLog.ProdId).FirstOrDefault();
                if (projRec != null)
                {
                    projCloudId = projRec.ProjCloudId;
                }
            }
            // converto!
            LogMachineModel answ = new LogMachineModel();
            if (coreMacLog != null)
            {
                answ = new LogMachineModel()
                {
                    EvType = coreMacLog.EventType,
                    DtEvent = coreMacLog.AlarmDateTime,
                    SupervId = coreMacLog.VarAddress,
                    VarValue = coreMacLog.VarValue,
                    ProdId = coreMacLog.ProdId,
                    ProjCloudId = projCloudId
                };
            }
            return answ;
        }

        /// <summary>
        /// Conversion from DB to Core class
        /// </summary>
        /// <param name="dbLog"></param>
        /// <returns></returns>
        public Core.MachLog ConvertToCore(LogMachineModel dbLog)
        {
            var newRecord = (Core.MachLog)Core.MachLog.CreateMachLog(dbLog.EvType, dbLog.DtEvent, dbLog.VarValue, dbLog.ProdId, dbLog.SupervId);
            return newRecord;
        }

        /// <summary>
        /// Create machine LOG record
        /// </summary>
        /// <param name="newLogMac"></param>
        /// <returns></returns>
        public bool Create(LogMachineModel newLogMac)
        {
            bool done = false;
            try
            {
                using (var locDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
                {
                    // Add to database
                    locDbCtx.LogMachineList.Add(newLogMac);
                    // Commit changes
                    locDbCtx.SaveChanges();
                    done = true;
                }
            }
            catch (Exception exc)
            {
                string errMessage = $"EXCEPTION on LogMachine.Create: {Environment.NewLine}{exc}";
                Console.WriteLine(errMessage);
                Log.Error(errMessage);
            }
            return done;
        }

        /// <summary>
        /// Create machine LOG record (da modello dati CORE)
        /// </summary>
        /// <param name="newLogMac">Record Log</param>
        /// <param name="projDbId">ProjID da DB (locale)</param>
        /// <returns></returns>
        public bool Create(Core.MachLog newMachLog)
        {
            // converto record
            var dbLogModel = ConvertFromCore(newMachLog);
            return Create(dbLogModel);
        }

        /// <summary>
        /// Delete by key
        /// </summary>
        /// <param name="LogDbId"></param>
        /// <returns></returns>
        public bool DeleteByKey(int LogDbId)
        {
            bool done = false;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var items2del = localDbCtx
                .LogMachineList
                .Where(x => x.LogDbId == LogDbId);
                try
                {
                    // Add to database
                    localDbCtx.LogMachineList.RemoveRange(items2del);
                    // Commit changes
                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on LogMachine.DeleteByKey: {Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return done;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Get record by LogDbId
        /// </summary>
        /// <param name="LogDbId"></param>
        /// <returns></returns>
        public LogMachineModel FindByDbId(int LogDbId)
        {
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                return localDbCtx
                        .LogMachineList
                        .Where(x => x.LogDbId == LogDbId)
                        .SingleOrDefault();
            }
        }

        /// <summary>
        /// Get paginated data from DB (ASC ordered)
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public List<LogMachineModel> GetAsc(DateTime dtStart, DateTime dtEnd)
        {
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // retrieve
                return localDbCtx
                        .LogMachineList
                        .Where(x => x.DtEvent >= dtStart && x.DtEvent <= dtEnd)
                        .OrderBy(x => x.DtEvent)
                        .ToList();
            }
        }

        /// <summary>
        /// Get paginated data from DB (ASC ordered) in "core format"
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public List<Core.MachLog> GetCoreAsc(DateTime dtStart, DateTime dtEnd)
        {
            var rawData = GetAsc(dtStart, dtEnd);
            var coreData = rawData.Select(x => ConvertToCore(x)).ToList();
            return coreData;
        }

        /// <summary>
        /// Get paginated data from DB (DESC ordered) in "core format"
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public List<Core.MachLog> GetCoreDesc(DateTime dtStart, DateTime dtEnd)
        {
            var rawData = GetDesc(dtStart, dtEnd);
            var coreData = rawData.Select(x => ConvertToCore(x)).ToList();
            return coreData;
        }

        /// <summary>
        /// Get paginated data from DB (DESC ordered)
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public List<LogMachineModel> GetDesc(DateTime dtStart, DateTime dtEnd)
        {
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // retrieve
                return localDbCtx
                        .LogMachineList
                        .Where(x => x.DtEvent >= dtStart && x.DtEvent <= dtEnd)
                        .OrderByDescending(x => x.DtEvent)
                        .ToList();
            }
        }

        /// <summary>
        /// Recupero i dati NON sincronizzati in ordine crescente fino al num max indicato
        /// </summary>
        /// <param name="numMax"></param>
        /// <returns></returns>
        public List<LogMachineModel> GetUnsentAsc(int numMax)
        {
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // retrieve
                return localDbCtx
                        .LogMachineList
                        .Where(x => (x.DtSent == null || x.DtSent < x.DtEvent) && x.ProjCloudId > 0)
                        .OrderBy(x => x.DtEvent)
                        .Take(numMax)
                        .ToList();
            }
        }

        /// <summary>
        /// Creazione LOG record di avvio programma
        /// </summary>
        /// <returns></returns>
        public bool RecordAppStartup()
        {
            bool done = false;
            try
            {
                using (var locDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
                {
                    // cerco ultimo record registrato
                    var lastRec = locDbCtx
                                        .LogMachineList
                                        .OrderByDescending(x => x.DtEvent)
                                        .FirstOrDefault();

                    // cerco ultimo evento chiusura
                    var lastRecClose = locDbCtx
                                        .LogMachineList
                                        .Where(x => x.EvType == Core.MachLog.MachLogTypes.APPLICATION
                                                    && x.VarValue == "0")
                                        .OrderByDescending(x => x.DtEvent)
                                        .FirstOrDefault();

                    // preparo nuovo record avvio!
                    LogMachineModel recStartApp = new LogMachineModel()
                    {
                        DtEvent = DateTime.Now.AddSeconds(-1),
                        EvType = Core.MachLog.MachLogTypes.APPLICATION,
                        VarValue = "1",
                        ProdId = lastRec != null ? lastRec.ProdId : 0,
                        ProjCloudId = lastRec != null ? lastRec.ProjCloudId : 0,
                        SupervId = lastRec != null ? lastRec.SupervId : "1"
                    };

                    // verifico esistenza record chiusura...
                    if (lastRecClose != null && lastRec != null)
                    {
                        // se l'ultimo record registrato NON fosse di chiusura... lo genero!
                        if (lastRecClose.DtEvent < lastRec.DtEvent)
                        {
                            var recCloseApp = new LogMachineModel()
                            {
                                DtEvent = lastRec.DtEvent.AddSeconds(1),
                                EvType = recStartApp.EvType,
                                VarValue = "0",
                                ProdId = lastRec != null ? lastRec.ProdId : 0,
                                ProjCloudId = lastRec != null ? lastRec.ProjCloudId : 0,
                                SupervId = lastRec != null ? lastRec.SupervId : "1"
                            };
                            // aggiungo rec chiusura
                            locDbCtx.LogMachineList.Add(recCloseApp);
                        }
                    }

                    // aggiungo rec avvio
                    locDbCtx.LogMachineList.Add(recStartApp);
                    // salvataggio
                    locDbCtx.SaveChanges();
                    done = true;
                }
            }
            catch (Exception exc)
            {
                string errMessage = $"EXCEPTION on LogMachine.RecordAppStartup: {Environment.NewLine}{exc}";
                Console.WriteLine(errMessage);
                Log.Error(errMessage);
            }
            return done;
        }

        /// <summary>
        /// Aggiorna i record indicati inserendo dataora corrente x DtSent
        /// </summary>
        /// <param name="rec2upd"></param>
        /// <returns></returns>
        public bool SetDtSent(List<LogMachineModel> rec2upd)
        {
            bool done = false;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                DateTime adesso = DateTime.Now;
                foreach (var item in rec2upd)
                {
                    var currRec = localDbCtx
                        .LogMachineList
                        .Where(x => (x.DtSent == null || x.DtSent < x.DtEvent) && x.LogDbId == item.LogDbId)
                        .FirstOrDefault();
                    if (currRec != null)
                    {
                        currRec.DtSent = adesso;
                        // indico modificato
                        localDbCtx.Entry(currRec).State = System.Data.Entity.EntityState.Modified;
                    }
                }
                // Salvataggio finale
                localDbCtx.SaveChanges();
            }
            return done;
        }

        /// <summary>
        /// Cerca di sistemare gli ID di Prod e ProjCloud mancanti
        /// </summary>
        /// <returns></returns>
        public bool TryFixProjCloudId()
        {
            // init vars
            bool fatto = false;
            int prodId = 0;
            // vado sul DB
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // retrieve
                var list2proc = localDbCtx
                        .LogMachineList
                        .Where(x => x.ProjCloudId == 0 && (x.EvType == Core.MachLog.MachLogTypes.PART_STATUS || x.EvType == Core.MachLog.MachLogTypes.MACHGROUP_STATUS))
                        .OrderBy(x => x.DtEvent)
                        .ToList();
                // se ci sono...
                if (list2proc != null && list2proc.Count > 0)
                {
                    // recupero elenco PROD
                    List<ProdModel> prodList = localDbCtx
                                                .ProdList
                                                .AsNoTracking()
                                                .ToList();

                    foreach (var item in list2proc)
                    {
                        prodId = 0;
                        // cerco valore
                        string[] dataList = item.VarValue.Split(';');
                        if (dataList != null && dataList.Count() > 0)
                        {
                            int.TryParse(dataList[0], out prodId);
                            // se trovato
                            if (prodId > 0)
                            {
                                // salvo il valore prodId
                                item.ProdId = prodId;
                                // cerco il projCloudId in elenco
                                var projRec = prodList.Where(x => x.ProdId == prodId).FirstOrDefault();
                                if (projRec != null)
                                {
                                    item.ProjCloudId = projRec.ProjCloudId;
                                }
                                // indico modificato
                                localDbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
                            }
                        }
                    }
                    // salvo
                    localDbCtx.SaveChanges();
                    // registro
                    fatto = true;
                }
            }
            // risultato
            return fatto;
        }

        /// <summary>
        /// Update single LogMachineModel
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool Update(LogMachineModel updItem)
        {
            bool done = false;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var item2update = localDbCtx
                .LogMachineList
                .Where(x => x.LogDbId == updItem.LogDbId)
                .SingleOrDefault();
                try
                {
                    // update, vers 1...
                    localDbCtx.Entry(item2update).CurrentValues.SetValues(updItem);

                    // Commit changes
                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on LogMachine.Update: {Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return done;
        }

        #endregion Public Methods

        #region Private Fields

        /// <summary>
        /// Istanza logger
        /// </summary>
        private NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}