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

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

        public ProjController()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Helper conversione a ProjectDTO
        /// </summary>
        /// <param name="currRec">record in formato ProjModel</param>
        /// <returns></returns>
        public static ProjectDTO ConvToDto(ProjModel currRec)
        {
            // ho valori mancanti che saranno calcolati dal cloud e valori messi a zero di default
            ProjectDTO answ = new ProjectDTO()
            {
                ProjCloudId = currRec.ProjCloudId,
                ProjLocalId = currRec.ProjDbId,
                ProjExtId = currRec.ProjId,
                // è calcolato sul cloud, da token --> machine ID
                MachineCloudId = 0,
                // è calcolato sul cloud, da token --> KeyNum
                KeyNum = 0,
                BTLFileName = currRec.BTLFileName,
                PType = (EgwProxy.MagMan.BWType)currRec.PType,
                Machine = currRec.Machine,
                ProjDescription = currRec.ProjDescription,
                DtCreated = currRec.DtCreated,
                DtLastAction = DateTime.MinValue,
                DtSchedule = DateTime.MinValue,
                DtStartProd = DateTime.MinValue,
                ListName = currRec.ListName,
                ProcTimeEst = 0,
                ProcTimeReal = 0,
                IsActive = currRec.IsActive,
                IsArchived = currRec.IsArchived
            };
            return answ;
        }

        /// <summary>
        /// Helper conversione a ProjModel
        /// </summary>
        /// <param name="currRec"></param>
        /// <param name="isActive"></param>
        /// <returns></returns>
        public static ProjModel ConvToModel(ProjectDTO currRec, bool isActive)
        {
            ProjModel answ = new ProjModel()
            {
                ProjCloudId = currRec.ProjCloudId,
                ProjDbId = currRec.ProjLocalId,
                ProjId = currRec.ProjExtId,
                //MachineID = currRec.MachineCloudId,
                //KeyNum = currRec.KeyNum,
                BTLFileName = currRec.BTLFileName,
                PType = (BWType)currRec.PType,
                Machine = currRec.Machine,
                ProjDescription = currRec.ProjDescription,
                DtCreated = currRec.DtCreated,
                //DtLastAction = currRec.DtLastAction,
                //DtSchedule = currRec.DtSchedule,
                //DtStartProd = currRec.DtStartProd,
                ListName = currRec.ListName,
                //ProcTimeEst = currRec.ProcTimeEst,
                //ProcTimeReal = currRec.ProcTimeReal,
                IsActive = currRec.IsActive,
                IsArchived = currRec.IsArchived
            };
            return answ;
        }

        /// <summary>
        /// Search for already imported BTL from FileName (only)
        /// =0 : NOT found &gt;0 : ProdId (already present) for overwrite
        /// </summary>
        /// <param name="BTLFileName"></param>
        /// <returns></returns>
        public int AlreadyImported(string BTLFileName)
        {
            int answ = 0;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var dbResult = localDbCtx
                       .ProjList
                       .Where(x => x.BTLFileName == BTLFileName)
                       //valutare se usare solo attivi...
                       //.Where(x => x.BTLFileName == BTLFileName && x.IsActive == true)
                       .FirstOrDefault();

                //se avesse trovato-- > riporto id...
                if (dbResult != null && dbResult.ProjId > 0)
                {
                    answ = dbResult.ProjId;
                }
            }
            return answ;
        }

        /// <summary>
        /// Helper conversione modelli
        /// </summary>
        /// <param name="currRec">record in formato ProjModel</param>
        /// <returns></returns>
        public Core.ProjFileM ConvToCore(ProjModel currRec)
        {
            Core.ProjFileM answ = null;
            if (currRec != null)
            {
                answ = Core.ProjFileM.CreateProjFileM(currRec.ProjId, ProdIdByProdDbId(currRec.ProdDbId), currRec.DtCreated, currRec.DtExported, currRec.ListName, currRec.BTLFileName, currRec.ProjDescription, currRec.IsNew, currRec.Locked, currRec.PType, currRec.Machine, currRec.IsActive, currRec.IsArchived, currRec.ProjCloudId);
            }
            return answ;
        }

        /// <summary>
        /// Delete Proj logically / on DB by ProdId
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="IsLogical"></param>
        /// <returns></returns>
        public bool DeleteProj(int ProjId, bool IsLogical)
        {
            bool done = false;

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var currProj = localDbCtx
                                .ProjList
                                .Where(x => x.ProjId == ProjId)
                                .SingleOrDefault();

                if (IsLogical)
                {
                    try
                    {
                        currProj.IsActive = false;
                        // Commit changes
                        localDbCtx.SaveChanges();
                        done = true;
                    }
                    catch (Exception exc)
                    {
                        string errMessage = $"EXCEPTION on Proj.DeleteProj (logical only): {Environment.NewLine}{exc}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                else
                {
                    // sel delle BTLParts da proj
                    var parts2del = localDbCtx
                                        .BTLPartList
                                        .Where(x => x.ProjDbId == currProj.ProjDbId);

                    try
                    {
                        // remove from database
                        localDbCtx.BTLPartList.RemoveRange(parts2del);
                        localDbCtx.ProjList.Remove(currProj);
                        // Commit changes
                        localDbCtx.SaveChanges();
                        done = true;
                    }
                    catch (Exception exc)
                    {
                        string errMessage = $"EXCEPTION on Proj.DeleteProj (on DB): {Environment.NewLine}{exc}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
            }
            return done;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Get records filtered by BtlPartName matching regexp BtlFileName[_number]
        /// </summary>
        /// <param name="BtlFileName">Base name to search for (=starts by BtlFileName%)</param>
        /// <param name="OnlyActive">Solo i record attivi (senza cancellazione logica)</param>
        /// <returns></returns>
        public List<ProjModel> FindByBtlFileName(string BtlFileName, bool OnlyActive)
        {
            List<ProjModel> searchResult = new List<ProjModel>();
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // in primi cerco il record "parent" generale, se non ci fosse inutile proseguire...
                ProjModel parentRec = localDbCtx
                        .ProjList
                        .Where(x => x.BTLFileName == BtlFileName && (!OnlyActive || x.IsActive))
                        .FirstOrDefault();
                if (parentRec != null && parentRec.ProjId > 0)
                {
                    // inserisco nei risultati
                    searchResult.Add(parentRec);
                    // cerco eventuali dati "child" puliti
                    var childRec = localDbCtx
                            .ProjList
                            .Where(x => x.BTLFileName.StartsWith(BtlFileName + "_") && (!OnlyActive || x.IsActive))
                            .ToList();
                    // faccio filtro con ricerca regexp x scartare "falsi positivi" come BtlFileName_nonNumero...
                    if (childRec.Count > 0)
                    {
                        // ciclo nei risultati x verificare se si tratti di PURO NUMERO...
                        foreach (var item in childRec)
                        {
                            string maybeNumber = item.BTLFileName.Replace($"{BtlFileName}_", "");
                            int index = 0;
                            bool isNumber = int.TryParse(maybeNumber, out index);
                            if (isNumber)
                            {
                                searchResult.Add(item);
                            }
                        }
                    }
                }
            }
            return searchResult;
        }

        /// <summary>
        /// Get record by ProjDbId
        /// </summary>
        /// <param name="ProjDbId"></param>
        /// <returns></returns>
        public ProjModel FindByProjDbId(int ProjDbId)
        {
            ProjModel answ = new ProjModel();
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    answ = localDbCtx
                            .ProjList
                            .Where(x => x.ProjDbId == ProjDbId)
                            .SingleOrDefault();
                }
                catch
                { }
            }
            return answ;
        }

        /// <summary>
        /// Get record by ProdId
        /// </summary>
        /// <param name="ProjId"></param>
        /// <returns></returns>
        public ProjModel FindByProjId(int ProjId)
        {
            ProjModel answ = new ProjModel();
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    answ = localDbCtx
                   .ProjList
                    .Where(x => x.ProjId == ProjId)
                    .SingleOrDefault();
                }
                catch
                { }
            }
            return answ;
        }

        /// <summary>
        /// Get record by ProdId converted
        /// </summary>
        /// <param name="ProjId"></param>
        /// <returns></returns>
        public Core.ProjFileM FindByProjIdConv(int ProjId)
        {
            return ConvToCore(FindByProjId(ProjId));
        }

        /// <summary>
        /// Get filtered data by ProdId (ASC ordered)
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetByProdAsc(int ProdId)
        {
            List<Core.ProjFileM> answ = new List<Core.ProjFileM>();
            int ProdDbId = 0;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    var currProd = localDbCtx
                        .ProdList
                        .Where(x => x.ProdId == ProdId)
                        .FirstOrDefault();
                    if (currProd != null)
                    {
                        ProdDbId = currProd.ProdDbId;
                    }
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on Proj.GetByProdAsc: {Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
                // retrieve
                var dbRes = localDbCtx
                    .ProjList
                    .Where(x => x.ProdDbId == ProdDbId)
                    .OrderBy(x => x.ProdDbId)
                    .ToList();
                // conversione
                answ = dbRes.Select(x => ConvToCore(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Get filtered data by ProdId (DESC ordered)
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetByProdDesc(int ProdId)
        {
            List<Core.ProjFileM> answ = new List<Core.ProjFileM>();
            int ProdDbId = 0;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    var currProd = localDbCtx
                                    .ProdList
                                    .Where(x => x.ProdId == ProdId)
                                    .FirstOrDefault();
                    if (currProd != null)
                    {
                        ProdDbId = currProd.ProdDbId;
                    }
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on Proj.GetByProdDesc: {Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
                // retrieve
                var dbRes = localDbCtx
                            .ProjList
                            .Where(x => x.ProdDbId == ProdDbId)
                            .OrderByDescending(x => x.ProdDbId)
                            .ToList();
                // conversione
                answ = dbRes.Select(x => ConvToCore(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Restitusice conteggio di item (dato BtlPartId) nello stato richiesto per il project richeisto...
        /// </summary>
        /// <param name="ProjId">Id progetto</param>
        /// <param name="BtlPartId">Id BTL Part</param>
        /// <param name="StateReq">Stato richeisto (enum Core)</param>
        /// <returns></returns>
        public int getCountItemState(int ProjId, int BtlPartId, Core.ItemState StateReq)
        {
            int numItem = 0;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                numItem = localDbCtx
                    .PartList
                    .Where(x => x.BTLPart.PartId == BtlPartId && x.BTLPart.Project.ProjId == ProjId && x.State == StateReq)
                    .Count();
            }
            return numItem;
        }

        /// <summary>
        /// Elenco progetti
        /// </summary>
        /// <param name="dtStart">Inizio periodo estrazione (per export date)</param>
        /// <param name="dtEnd">Fine periodo estrazione (per export date)</param>
        /// <param name="numRecord">Num max record da recuperare</param>
        /// <param name="OnlyActive">Solo i record attivi (senza cancellazione logica)</param>
        /// <param name="ShowArchived">Se true: mostra anche archiviati (default li nasconde)</param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetLastByExpDesc(DateTime dtStart, DateTime dtEnd, int numRecord, bool OnlyActive, bool ShowArchived = false)
        {
            List<Core.ProjFileM> answ = new List<Core.ProjFileM>();

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // se numRecord = 0 --> passo tutti
                if (numRecord == 0)
                {
                    numRecord = localDbCtx.ProjList.Count();
                }
                // retrieve
                var dbRes = localDbCtx
                                .ProjList
                                .Where(x => (!x.IsArchived || ShowArchived) && (x.DtExported >= dtStart && x.DtExported <= dtEnd) && (!OnlyActive || x.IsActive))
                                .OrderByDescending(x => x.ProjId)
                                .Take(numRecord)
                                .ToList();
                // conversione
                answ = dbRes.Select(x => ConvToCore(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Elenco progetti
        /// </summary>
        /// <param name="numRecord">Num max record da recuperare</param>
        /// <param name="OnlyActive">Solo i record attivi (senza cancellazione logica)</param>
        /// <param name="ShowArchived">Se true: mostra anche archiviati (default li nasconde)</param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetLastDesc(int numRecord, bool OnlyActive, bool ShowArchived = false)
        {
            List<Core.ProjFileM> answ = new List<Core.ProjFileM>();

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // se numRecord = 0 --> passo tutti
                if (numRecord == 0)
                {
                    numRecord = localDbCtx.ProjList.Count();
                }
                // retrieve
                var dbRes = localDbCtx
                                .ProjList
                                .Where(x => (!x.IsArchived || ShowArchived) && (!OnlyActive || x.IsActive))
                                .OrderByDescending(x => x.ProjId)
                                .Take(numRecord)
                                .ToList();
                // conversione
                answ = dbRes.Select(x => ConvToCore(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Elenco progetti
        /// </summary>
        /// <param name="dtStart">Inizio periodo estrazione</param>
        /// <param name="dtEnd">Fine periodo estrazione</param>
        /// <param name="numRecord">Num max record da recuperare</param>
        /// <param name="OnlyActive">Solo i record attivi (senza cancellazione logica)</param>
        /// <param name="ShowArchived">Se true: mostra anche archiviati (default li nasconde)</param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetLastDesc(DateTime dtStart, DateTime dtEnd, int numRecord, bool OnlyActive, bool ShowArchived = false)
        {
            List<Core.ProjFileM> answ = new List<Core.ProjFileM>();

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // se numRecord = 0 --> passo tutti
                if (numRecord == 0)
                {
                    numRecord = localDbCtx.ProjList.Count();
                }
                // retrieve
                var dbRes = localDbCtx
                                .ProjList
                                .Where(x => (!x.IsArchived || ShowArchived) && (x.DtCreated >= dtStart && x.DtCreated <= dtEnd) && (!OnlyActive || x.IsActive))
                                .OrderByDescending(x => x.ProjId)
                                .Take(numRecord)
                                .ToList();
                // conversione
                answ = dbRes.Select(x => ConvToCore(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Fornisce nuovo indice VUOTO da usare (allocando sul DB)
        /// </summary>
        /// <param name="UserKey">User ID / Key number</param>
        /// <returns></returns>
        public int GetNextIndex(string UserKey = "USER01")
        {
            int nextId = 0;

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // cerco se ne ho ALMENO 1....
                var numRec = localDbCtx.ProjList.Count();
                if (numRec == 0)
                {
                    nextId = 1;
                }
                else
                {
                    // retrieve ultimo...
                    var maxRecord = localDbCtx
                                    .ProjList
                                    .OrderByDescending(x => x.ProjId)
                                    .Take(1)
                                    .FirstOrDefault();
                    // incremento
                    nextId = maxRecord.ProjId + 1;
                }

                // creo nuovo...
                var newRec = localDbCtx
                    .ProjList
                    .Add(new ProjModel()
                    {
                        ProjId = nextId,
                        BTLFileName = "",
                        ProjDescription = "",
                        IsNew = true,
                        Locked = true,
                        LockedBy = UserKey,
                        LockDate = DateTime.Now,
                        DtCreated = DateTime.Now
                    });

                // Commit changes
                localDbCtx.SaveChanges();
            }
            return nextId;
        }

        /// <summary> Manage Lock by ProdId (proj & prod) </summary> <param name="ProjId">ID
        /// Proj</param> <param name="Locked">Stato Lock da impostare</param> <param
        /// name="UserKey">User ID / Key number</param> <returns></returns>
        public Core.ProjFileM LockByProjId(int ProjId, bool Locked, string UserKey = "USER01")
        {
            ProjModel currProj;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currProj = localDbCtx
                            .ProjList
                            .Where(x => x.ProjId == ProjId)
                            .SingleOrDefault();
                // aggiorno stato del proj
                currProj.Locked = Locked;
                currProj.LockDate = DateTime.Now;
                currProj.LockedBy = Locked ? UserKey : "";
                localDbCtx.Entry(currProj).State = System.Data.Entity.EntityState.Modified;

                // seleziono il prod e lo blocco...
                var currProd = localDbCtx
                                .ProdList
                                .Where(x => x.ProdDbId == currProj.ProdDbId)
                                .SingleOrDefault();

                if (currProd != null)
                {
                    // blocco prod corrente
                    currProd.Locked = Locked;
                    currProd.LockDate = DateTime.Now;
                    currProd.LockedBy = Locked ? UserKey : "";
                    localDbCtx.Entry(currProd).State = System.Data.Entity.EntityState.Modified;

                    // ora blocco altri proj del prod...
                    var currProjs = localDbCtx
                                       .ProjList
                                       .Where(x => x.ProdDbId == currProd.ProdDbId && x.ProjId != ProjId)
                                       .ToList();

                    //currProjs.ForEach(x => x.Locked = Locked);
                    foreach (var item in currProjs)
                    {
                        //item.ProdDbId = currProd.ProdDbId;
                        item.Locked = Locked;
                        item.LockDate = DateTime.Now;
                        item.LockedBy = Locked ? UserKey : "";
                        localDbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
                    }
                }
                // salvataggio
                localDbCtx.SaveChanges();
            }
            return ConvToCore(currProj);
        }

        /// <summary>
        /// Reinizializzaizone del controller
        /// </summary>
        public void ResetController()
        {
        }

        /// <summary>
        /// Reimposta come NEW
        /// </summary>
        /// <param name="ProjId">ProjID</param>
        /// <param name="Locked">Stato Lock da impostare</param>
        /// <returns></returns>
        public Core.ProjFileM ResetNew(int ProjId)
        {
            ProjModel currProj;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currProj = localDbCtx
                            .ProjList
                            .Where(x => x.ProjId == ProjId)
                            .SingleOrDefault();

                // aggiorno stato
                currProj.IsNew = false;
                localDbCtx.SaveChanges();
            }
            return ConvToCore(currProj);
        }

        /// <summary>
        /// Update single PROJ
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool Update(ProjModel updItem)
        {
            bool done = false;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                var item2update = localDbCtx
                                    .ProjList
                                    .Where(x => x.ProjId == updItem.ProjId)
                                    .SingleOrDefault();
                if (item2update != null)
                {
                    try
                    {
                        updItem.ProjDbId = item2update.ProjDbId;
                        // update, vers 1...
                        localDbCtx.Entry(item2update).CurrentValues.SetValues(updItem);

                        //// update, vers 2
                        //dbCtx.PartList.Remove(item2del);
                        //dbCtx.PartList.Add(updItem);

                        // Commit changes
                        localDbCtx.SaveChanges();
                        done = true;
                    }
                    catch (Exception exc)
                    {
                        string errMessage = $"EXCEPTION on Part.Update{Environment.NewLine}{exc}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                else
                {
                    string errMessage = $"ERROR on Proj.Update: req item was not found | ProdId {updItem.ProjId} | ProjDbId {updItem.ProjDbId} | ProdDbId {updItem.ProdDbId}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return done;
        }

        /// <summary>
        /// Update record su DB x elenco BTLParts
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="BtlPartList"></param>
        /// <returns></returns>
        public ProjModel UpdateBtlParts(int ProjId, List<Core.BTLPartM> BtlPartList)
        {
            // record del proj corrente
            var currData = FindByProjId(ProjId);

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // 2021.05.03 modifica update: esistenti le MODIFICO, nuove aggiungo, inesistenti
                // elimino in cascata con Part

                // sel delle BTLParts del proj
                List<BTLPartModel> oldBtlParts = localDbCtx
                                                    .BTLPartList
                                                    .Where(x => x.ProjDbId == currData.ProjDbId)
                                                    .ToList();
                if (oldBtlParts != null)
                {
                    var locBtlCtrl = new BTLPartController();
                    // converto le BtlParts da core --> DB
                    List<BTLPartModel> newBtlParts = BtlPartList.Select(x => locBtlCtrl.ConvertFromCore(x, currData.ProjDbId)).ToList();

                    try
                    {
                        // elementi BtlPartId NON + presenti da eliminare
                        List<int> bpi2rem = oldBtlParts.Select(x => x.PartId).Except(newBtlParts.Select(y => y.PartId)).ToList();
                        List<int> bpi2add = newBtlParts.Select(x => x.PartId).Except(oldBtlParts.Select(y => y.PartId)).ToList();
                        List<int> bpiExis = newBtlParts.Select(x => x.PartId).Intersect(oldBtlParts.Select(y => y.PartId)).ToList();

                        // aggiorno existing...
                        foreach (var currPartId in bpiExis)
                        {
                            // recupero item da aggiornare...
                            var oldItem = oldBtlParts.Where(x => x.PartId == currPartId).FirstOrDefault();
                            // dati nuovo item
                            var newItem = newBtlParts.Where(x => x.PartId == currPartId).FirstOrDefault();
                            if (newItem != null && oldItem != null)
                            {
                                oldItem.CALC_State = newItem.CALC_State;
                                oldItem.CNT = newItem.CNT;
                                oldItem.DO = newItem.DO;
                                oldItem.H = newItem.H;
                                oldItem.L = newItem.L;
                                oldItem.W = newItem.W;
                                oldItem.Material = newItem.Material;
                                oldItem.NAM = newItem.NAM;
                                oldItem.PDN = newItem.PDN;
                            }
                        }

                        // aggiungo le nuove part
                        foreach (var newPartId in bpi2add)
                        {
                            var newItem = newBtlParts.Where(x => x.PartId == newPartId).FirstOrDefault();
                            localDbCtx.BTLPartList.Add(newItem);
                        }

                        // elimino dal DB i non + esistenti
                        foreach (var oldPartId in bpi2rem)
                        {
                            // elimino parts nei MachGroup
                            var oldIstPartList = localDbCtx.PartList.Where(x => x.BTLPart.PartId == oldPartId).ToList();
                            localDbCtx.PartList.RemoveRange(oldIstPartList);
                            // elimino BtlParts
                            var oldItem = oldBtlParts.Where(x => x.PartId == oldPartId).FirstOrDefault();
                            localDbCtx.BTLPartList.Remove(oldItem);
                        }
                    }
                    catch
                    { }

                    // aggiorno valore isNew a false
                    currData.IsNew = false;

                    // Commit changes
                    localDbCtx.SaveChanges();
                }
                else
                {
                    string errMessage = $"ERROR on Proj.UpdateBtlParts: req item was not found | ProdId {ProjId} | BtlPartList {BtlPartList.Count} items";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return currData;
        }

        /// <summary>
        /// Update record su DB x Description
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="Description"></param>
        /// <returns></returns>
        public Core.ProjFileM UpdateDescription(int ProjId, string Description)
        {
            // cerco specifico Proj
            ProjModel currData;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currData = localDbCtx
                               .ProjList
                               .Where(x => x.ProjId == ProjId)
                               .SingleOrDefault();
                if (currData != null)
                {
                    try
                    {
                        // aggiorno valore BTL
                        currData.ProjDescription = Description;

                        // Commit changes
                        localDbCtx.SaveChanges();
                    }
                    catch (Exception exc)
                    {
                        string errMessage = $"EXCEPTION on Proj.UpdateDescription:{Environment.NewLine}{exc}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                else
                {
                    string errMessage = $"ERROR on Proj.UpdateDescription: req item was not found | ProdId {ProjId} | Description {Description}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }

            return ConvToCore(currData);
        }

        /// <summary>
        /// Update record su DB x nomeBTL, ListName, ExportDate
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="BTLFileName"></param>
        /// <param name="Description"></param>
        /// <param name="ListName"></param>
        /// <param name="DtExported"></param>
        /// <param name="PType"></param>
        /// <param name="Machine"></param>
        /// <returns></returns>
        public Core.ProjFileM UpdateInfo(int ProjId, string BTLFileName, string Description, string ListName, DateTime DtExported, BWType PType, string Machine)
        {
            // cerco specifico Proj
            ProjModel currData;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currData = localDbCtx
                               .ProjList
                               .Where(x => x.ProjId == ProjId)
                               .SingleOrDefault();
                if (currData != null)
                {
                    try
                    {
                        // 2022.01.24: verifico UNIVOCITA' nel nome del file: SE fosse duplicato -->
                        // nuovo nome, nel formato nomeOriginale_idx, dove idx è il contatore libero
                        // successivo 2023.06.08: lasciato come prima, anche NON attivi
                        // (cancellazione logica)
                        var duplicateList = FindByBtlFileName(BTLFileName, false);
                        // devo verificare SOLO SE la lista non è vuota
                        if (duplicateList != null && duplicateList.Count > 0)
                        {
                            // se ne ho esattamente 1 nel DB allora DEVE essere il record Parent
                            if (duplicateList.Count == 1)
                            {
                                // verifico se ProdId variato
                                if (!duplicateList[0].ProjId.Equals(currData.ProjId))
                                {
                                    // in questo caso ho il PRIMO duplicato
                                    BTLFileName = $"{BTLFileName}_1";
                                }
                            }
                            // se ne ho + di 1 --> so che il maxId interno avrò il valore ULTIMO x
                            // prendere il successivo
                            else
                            {
                                var lastRec = duplicateList.OrderByDescending(x => x.ProjDbId).FirstOrDefault();
                                // cerco indice
                                string maybeNumber = lastRec.BTLFileName.Replace($"{BTLFileName}_", "");
                                int index = 0;
                                bool isNumber = int.TryParse(maybeNumber, out index);
                                // fasccio comunque verifica sia numerico
                                if (isNumber)
                                {
                                    // in questo caso ho il l'ULTIMO duplicato e faccio +1
                                    BTLFileName = $"{BTLFileName}_{index + 1}";
                                }
                            }
                        }

                        // aggiorno valore BTL
                        currData.BTLFileName = BTLFileName;
                        // aggiorno il resto
                        currData.ProjDescription = Description;
                        currData.DtExported = DtExported;
                        currData.ListName = ListName;
                        currData.PType = PType;
                        currData.Machine = Machine;

                        // Commit changes
                        localDbCtx.SaveChanges();
                    }
                    catch (Exception exc)
                    {
                        string errMessage = $"EXCEPTION on Part.UpdateInfo:{Environment.NewLine}{exc}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                else
                {
                    string errMessage = $"ERROR on Proj.UpdateInfo: req item was not found | ProdId {ProjId} | Description {BTLFileName} | ListName {ListName} | DtExported {DtExported} | PType {PType} | Machine {Machine}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }

            return ConvToCore(currData);
        }

        /// <summary>
        /// Update record su DB x nomeBTL, ListName, ExportDate
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="ListName"></param>
        /// <returns></returns>
        public Core.ProjFileM UpdateListName(int ProjId, string ListName)
        {
            ProjModel currData = new ProjModel();
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    currData = localDbCtx
                                   .ProjList
                                   .Where(x => x.ProjId == ProjId)
                                   .SingleOrDefault();
                    if (currData != null)
                    {
                        // aggiorno valore BTL
                        currData.ListName = ListName;

                        // Commit changes
                        localDbCtx.SaveChanges();
                    }
                    else
                    {
                        string errMessage = $"ERROR on Proj.UpdateListName: req item was not found | ProdId {ProjId} | ListName {ListName}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on Part.UpdateListName:{Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return ConvToCore(currData);
        }

        /// <summary>
        /// Update record su DB x PType
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="Machine"></param>
        /// <returns></returns>
        public Core.ProjFileM UpdateMachine(int ProjId, String Machine)
        {
            ProjModel currData = new ProjModel();
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                try
                {
                    currData = localDbCtx
                               .ProjList
                               .Where(x => x.ProjId == ProjId)
                               .SingleOrDefault();

                    if (currData != null)
                    {
                        // aggiorno valore BTL
                        currData.Machine = Machine;

                        // Commit changes
                        localDbCtx.SaveChanges();
                    }
                    else
                    {
                        string errMessage = $"ERROR on Proj.UpdateMachine: req item was not found | ProdId {ProjId} | Machine {Machine}";
                        Console.WriteLine(errMessage);
                        Log.Error(errMessage);
                    }
                }
                catch (Exception exc)
                {
                    string errMessage = $"EXCEPTION on Part.UpdateMachine:{Environment.NewLine}{exc}";
                    Console.WriteLine(errMessage);
                    Log.Error(errMessage);
                }
            }
            return ConvToCore(currData);
        }

        #endregion Public Methods

        #region Protected Methods

        /// <summary>
        /// Get LAST paginated data from DB (DESC ordered)
        /// </summary>
        /// <param name="numRecord"></param>
        /// <returns></returns>
        protected List<ProjModel> GetLastDbModelDesc(int numRecord)
        {
            // se numRecord = 0 --> passo tutti
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                if (numRecord == 0)
                {
                    numRecord = localDbCtx.ProjList.Count();
                }
                // retrieve
                return localDbCtx
                        .ProjList
                        .OrderByDescending(x => x.ProjId)
                        .Take(numRecord)
                        .ToList();
            }
        }

        /// <summary>
        /// Get ProdId by ProdDbId, 0 se non trovato
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        protected int ProdIdByProdDbId(int? ProdDbId)
        {
            int answ = 0;

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                if (ProdDbId != null)
                {
                    var prodRecord = localDbCtx
                                        .ProdList
                                        .Where(x => x.ProdDbId == ProdDbId)
                                        .SingleOrDefault();

                    if (prodRecord != null)
                    {
                        answ = prodRecord.ProdId;
                    }
                }
            }
            return answ;
        }

        #endregion Protected Methods

        #region Private Fields

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

        #endregion Private Fields
    }
}