using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NKC.Data.DbModels;
using NKC.Data.DTO;
using NLog;

namespace NKC.Data.Controllers
{
    public class NKCController : IDisposable
    {
        #region Private Fields

        private static IConfiguration _configuration = null!;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Public Constructors

        public NKCController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        #endregion Public Constructors

        #region Public Methods

        public bool DbForceMigrate()
        {
            bool answ = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                try
                {
                    localDbCtx.DbForceMigrate();
                    answ = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in DbForceMigrate{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        public void Dispose()
        {
            Log.Info("Dispose di NKCController");
        }

        public List<MaterialDTO> MaterialsGetAll()
        {
            List<MaterialDTO> dbResult = new List<MaterialDTO>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetMaterials
                .Where(x => x.MatID > 0)
                .Select(x => new MaterialDTO()
                {
                    MatID = x.MatID,
                    MatExtCode = x.MatExtCode,
                    MatDesc = x.MatDesc,
                    LMm = x.LMm,
                    WMm = x.WMm,
                    TMm = x.TMm,
                    ApprovUser = x.ApprovUser,
                    ApprovDate = x.ApprovDate,
                    NumSize = x.RemnantNav == null ? 0 : x.RemnantNav.Count,
                    TotQty = x.RemnantNav == null ? 0 : x.RemnantNav.Sum(r => r.QtyAvail)
                }
                )
                .ToList();
            }
            return dbResult;
        }

        public List<MovMagModel> MovMagGetFilt(int RemnId, int numShow)
        {
            List<MovMagModel> dbResult = new List<MovMagModel>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetMovMag
                .Where(x => x.RemnID == RemnId)
                .OrderByDescending(o => o.DtRec)
                //.Include(m => m.RemnantNav)
                .Take(numShow)
                .ToList();
            }
            return dbResult;
        }

        public bool AddPrintJob(string tipoReport, string keyParam, string prtName)
        {
            bool done = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                try
                {
                    DateTime adesso = DateTime.Now;
                    PrintJobQueue newRec = new PrintJobQueue()
                    {
                        TipoReport = tipoReport,
                        KeyParam = keyParam,
                        PrtName = prtName,
                        Stato = 0,
                        DtStart = adesso,
                        DtLastTry = adesso
                    };

                    localDbCtx.DbSetPrintJobQueues.Add(newRec);

                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in AddPrintJob:{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        public List<RemnantsModel> RemnantsGetAll()
        {
            List<RemnantsModel> dbResult = new List<RemnantsModel>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetRemnants
                .ToList();
            }
            return dbResult;
        }
        public RemnantsModel RemnantGetByid(int RemnId)
        {
            RemnantsModel? dbResult = new RemnantsModel();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetRemnants
                .Where(x => x.RemnID == RemnId)
                .Include(m => m.MaterialNav)
                .FirstOrDefault();
            }
            if (dbResult == null)
            {
                dbResult = new RemnantsModel();
            }
            return dbResult;
        }

        public List<RemnantsModel> RemnantsGetFilt(int matId, int minQty)
        {
            List<RemnantsModel> dbResult = new List<RemnantsModel>();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetRemnants
                .Where(x => (x.MatID == matId || matId == 0) && (x.QtyAvail >= minQty || minQty == 0))
                //.OrderBy(o => o.Area)d6
                .Include(m => m.MaterialNav)
                .ToList();
            }
            return dbResult;
        }

        public RemnantsModel RemnantGetByQr(string QrCode)
        {
            RemnantsModel? dbResult = new RemnantsModel();
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                var rawList = localDbCtx
                                .DbSetRemnants
                                .Include(m => m.MaterialNav)
                                .ToList();

                dbResult = rawList
                            .Where(x => x.RemDtmx == QrCode)
                            .FirstOrDefault();
                if (dbResult == null && QrCode.Contains("-"))
                {
                    // split materiale/dimensione
                    var decodedData = QrCode.Split('-');
                    if (decodedData != null && decodedData.Length > 1)
                    {
                        // calcolo il codice ext
                        int MatExtCode = 0;
                        _=int.TryParse(decodedData[0].Replace("MT",""), out MatExtCode);
                        // cerco il materiale
                        var matRow = localDbCtx
                                        .DbSetMaterials
                                        .Where(x => x.MatExtCode == MatExtCode)
                                        .FirstOrDefault();
                        if (matRow != null)
                        {
                            // calcolo lunghezza...
                            decimal actLmm = decimal.Parse(decodedData[1])/1000;

                            // creo il record...
                            dbResult = new RemnantsModel()
                            {
                                DtMod = DateTime.Now,
                                Location = "MAG",
                                MatID = matRow.MatID,
                                WMm = matRow.WMm,
                                TMm = matRow.TMm,
                                LMm = actLmm,
                                QtyAvail = 0
                            };

                            // salvo sul DB
                            localDbCtx.DbSetRemnants.Add(dbResult);
                            localDbCtx.SaveChanges();
                        }
                    }
                }
            }
            if (dbResult == null)
            {
                dbResult = new RemnantsModel();
            }
            return dbResult;
        }

        public bool RemnantsUpsert(RemnantsModel updItem, string userId)
        {
            bool done = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {

                try
                {
                    RemnantsModel? currData = localDbCtx
                                               .DbSetRemnants
                                               .Where(x => x.RemnID == updItem.RemnID)
                                               .FirstOrDefault();
                    if (currData != null)
                    {
                        // aggiungo record variazione quantità...
                        int delta = updItem.QtyAvail - currData.QtyAvail;
                        if (delta != 0)
                        {
                            MovMagModel recMovMag = new MovMagModel()
                            {
                                DtRec = DateTime.Now,
                                RemnID = updItem.RemnID,
                                QtyRec = delta,
                                UserId = userId
                            };
                            localDbCtx.DbSetMovMag.Add(recMovMag);
                        }

                        // aggiorno valori
                        currData.MatID = updItem.MatID;
                        currData.DtMod = updItem.DtMod;
                        currData.Location = updItem.Location;
                        currData.Note = updItem.Note;
                        currData.QtyAvail = updItem.QtyAvail;
                        currData.LMm = updItem.LMm;
                        currData.WMm = updItem.WMm;
                        currData.TMm = updItem.TMm;
                        localDbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        // aggiungo record variazione quantità...
                        MovMagModel recMovMag = new MovMagModel()
                        {
                            DtRec = DateTime.Now,
                            RemnID = updItem.RemnID,
                            QtyRec = updItem.QtyAvail
                        };
                        localDbCtx.DbSetMovMag.Add(recMovMag);

                        // aggiungo record puntuale
                        currData = new RemnantsModel()
                        {
                            MatID = updItem.MatID,
                            DtMod = updItem.DtMod,
                            Location = updItem.Location,
                            Note = updItem.Note,
                            QtyAvail = updItem.QtyAvail,
                            LMm = updItem.LMm,
                            WMm = updItem.WMm,
                            TMm = updItem.TMm
                        };
                        localDbCtx
                            .DbSetRemnants
                            .Add(currData);
                    }
                    localDbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in PlantUpdate:{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Annulla modifiche su una specifica entity (cancel update)
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool rollBackEntity(object item)
        {
            bool answ = false;
            using (NKCContext localDbCtx = new NKCContext(_configuration))
            {
                try
                {
                    if (localDbCtx.Entry(item).State == EntityState.Deleted || localDbCtx.Entry(item).State == EntityState.Modified)
                    {
                        localDbCtx.Entry(item).Reload();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        #endregion Public Methods
    }
}