using EgtBEAMWALL.DataLayer.DatabaseModels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static EgtBEAMWALL.Core.ConstBeam;

namespace EgtBEAMWALL.DataLayer.Controllers
{
    public class ProjController : IDisposable
    {
        #region Private Fields


        #endregion Private Fields

        #region Public Constructors

        public ProjController()
        {
        }

        #endregion Public Constructors

        #region Protected Methods

        /// <summary>
        /// Helper conversione modelli
        /// </summary>
        /// <param name="currProj"></param>
        /// <returns></returns>
        protected Core.ProjFileM coreConv(ProjModel currProj)
        {
            Core.ProjFileM answ = null;
            if (currProj != null)
            {
                answ = Core.ProjFileM.CreateProjFileM(currProj.ProjId, ProdIdByProdDbId(currProj.ProdDbId), currProj.DtCreated, currProj.DtExported, currProj.ListName, currProj.BTLFileName, currProj.IsNew, currProj.Locked, currProj.PType, currProj.Machine);
            }
            return answ;
        }

        /// <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 Public Methods

        /// <summary>
        /// Search for already imported BTL from FileName (only)
        /// =0 : NOT found
        /// >0 : ProjId (already rpesent) 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)
                       .FirstOrDefault();

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

        public bool DeleteProj(int ProjId)
        {
            bool done = false;

            var currProj = FindByProjId(ProjId);

            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                // 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)
                {
                    Console.WriteLine($"EXCEPTION on DeleteProj: {exc}");
                }
            }
            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>
        /// <returns></returns>
        public List<ProjModel> FindByBtlFileName(string BtlFileName)
        {
            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)
                        .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 + "_"))
                            .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;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                answ = localDbCtx
                        .ProjList
                        .Where(x => x.ProjDbId == ProjDbId)
                        .SingleOrDefault();
            }
            return answ;
        }

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

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

        /// <summary>
        /// Get filtered data by ProdId (ASC ordered)
        /// </summary>
        /// <param name="ProdDbId"></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)
                {
                    Console.WriteLine($"EXCEPTION on GetByProdAsc: {exc}");
                }
                // retrieve
                var dbRes = localDbCtx
                    .ProjList
                    .Where(x => x.ProdDbId == ProdDbId)
                    .OrderBy(x => x.ProdDbId)
                    .ToList();
                // conversione
                answ = dbRes.Select(x => coreConv(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)
                {
                    Console.WriteLine($"EXCEPTION on GetByProdAsc: {exc}");
                }
                // retrieve
                var dbRes = localDbCtx
                            .ProjList
                            .Where(x => x.ProdDbId == ProdDbId)
                            .OrderByDescending(x => x.ProdDbId)
                            .ToList();
                // conversione
                answ = dbRes.Select(x => coreConv(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="numRecord"></param>
        /// <returns></returns>
        public List<Core.ProjFileM> GetLastDesc(int numRecord)
        {
            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
                                .OrderByDescending(x => x.ProjId)
                                .Take(numRecord)
                                .ToList();
                // conversione
                answ = dbRes.Select(x => coreConv(x)).ToList();
            }
            return answ;
        }

        /// <summary>
        /// Fornisce nuovo indice VUOTO da usare (allocando sul DB)
        /// </summary>
        /// <returns></returns>
        public int GetNextIndex()
        {
            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 = "", IsNew = true, Locked = true, DtCreated = DateTime.Now });

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

        /// <summary>
        /// Manage Lock by ProjId (proj & prod)
        /// </summary>
        /// <param name="ProjId">ProjID</param>
        /// <param name="Locked">Stato Lock da impostare</param>
        /// <returns></returns>
        public Core.ProjFileM LockByProjId(int ProjId, bool Locked)
        {
            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;
                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;
                    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;
                        localDbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
                    }
                }
                // salvataggio
                localDbCtx.SaveChanges();
            }
            return coreConv(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 coreConv(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();
                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 ex)
                { }
            }
            return done;
        }

        /// <summary>
        /// Update record su DB x elenco BTLParts
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="newBTLFileName"></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();

                // converto le BtlParts da core --> DB
                List<BTLPartModel> newBtlParts = BtlPartList.Select(x => BTLPartController.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();
            }
            return currData;
        }

        /// <summary>
        ///  Update record su DB x nomeBTL, ListName, ExportDate
        /// </summary>
        /// <param name="ProjId"></param>
        /// <param name="BTLFileName"></param>
        /// <param name="ListName"></param>
        /// <param name="DtExported"></param>
        /// <returns></returns>
        public Core.ProjFileM UpdateInfo(int ProjId, string BTLFileName, 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();

                // 2022.01.24: verifico UNIVOCITA' nel nome del file: SE fosse duplicato --> nuovo nome, nel formato nomeOriginale_idx, dove idx è il contatore libero successivo
                var duplicateList = FindByBtlFileName(BTLFileName);
                // 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 ProjId 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;
                currData.DtExported = DtExported;
                currData.ListName = ListName;
                currData.PType = PType;
                currData.Machine = Machine;

                // Commit changes
                localDbCtx.SaveChanges();
            }

            return coreConv(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;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currData = localDbCtx
                               .ProjList
                               .Where(x => x.ProjId == ProjId)
                               .SingleOrDefault();
                // aggiorno valore BTL
                currData.ListName = ListName;

                // Commit changes
                localDbCtx.SaveChanges();
            }
            return coreConv(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;
            using (DatabaseContext localDbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING))
            {
                currData = localDbCtx
                               .ProjList
                               .Where(x => x.ProjId == ProjId)
                               .SingleOrDefault();
                // aggiorno valore BTL
                currData.Machine = Machine;

                // Commit changes
                localDbCtx.SaveChanges();
            }
            return coreConv(currData);
        }

        #endregion Public Methods
    }
}