using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EgtBEAMWALL.DataLayer.DatabaseModels;

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

        private DatabaseContext dbCtx;

        #endregion Private Fields

        #region Public Fields

        public static ProdController man = new ProdController();

        #endregion Public Fields

        #region Public Constructors

        public ProdController()
        {
            // Initialize database context
            dbCtx = new DatabaseContext(DbConfig.CONNECTION_STRING);
        }

        #endregion Public Constructors

        #region Protected Methods

        /// <summary>
        /// Get LAST paginated data from DB (DESC ordered)
        /// </summary>
        /// <param name="numRecord"></param>
        /// <returns></returns>
        protected List<ProdModel> GetLastDbModelDesc(int numRecord)
        {
            // se numRecord = 0 --> passo tutti
            if (numRecord == 0)
            {
                numRecord = dbCtx.ProdList.Count();
            }
            // retrieve
            return dbCtx
                .ProdList
                .OrderByDescending(x => x.ProdId)
                .Take(numRecord)
                .ToList();
        }

        protected List<int> ProjIdByProd(int ProdId)
        {
            return DbManager.obj.ProjCtr.GetByProdAsc(ProdId).Select(y => y.ProjId).ToList();
        }

        #endregion Protected Methods

        #region Public Methods

        /// <summary>
        /// Aggiunta di un PROJ ad un PROD
        /// </summary>
        /// <param name="ProdId"></param>
        /// <param name="ProjId"></param>
        /// <returns></returns>
        public bool AddProj(int ProdId, int ProjId)
        {
            bool done = false;

            // cerco Prod
            var currProd = dbCtx
                .ProdList
                .Where(x => x.ProdId == ProdId)
                .FirstOrDefault();

            // cerco Proj
            var currProj = dbCtx
                .ProjList
                .Where(x => x.ProjId == ProjId)
                .FirstOrDefault();

            // lo aggiorno
            currProj.ProjDbId = currProd.ProdDbId;
            currProj.Locked = true;

            // salvo
            dbCtx.SaveChanges();

            return done;
        }

        public bool DeleteProd(int ProdId)
        {
            bool done = false;

            var currProd = FindByProdId(ProdId);

            // sel dei proj da aggiornare...
            var proj2update = dbCtx
                .ProjList
                .Where(x => x.ProdDbId == currProd.ProdDbId)
                .ToList();

            // sel delle BTLParts da proj
            var machGroup2del = dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == currProd.ProdDbId)
                .ToList();

            try
            {
                // update proj...
                foreach (var item in proj2update)
                {
                    item.ProdDbId = null;
                }
                //// salvo
                //dbCtx.SaveChanges();
                // remove from database
                dbCtx.MachGroupList.RemoveRange(machGroup2del);
                dbCtx.ProdList.Remove(currProd);
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on DeleteProd: {exc}");
            }
            return done;
        }

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
        }

        /// <summary>
        /// Get record by ProdDbId
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public ProdModel FindByProdDbId(int ProdDbId)
        {
            var answ = dbCtx
                .ProdList
                .Where(x => x.ProdDbId == ProdDbId)
                .SingleOrDefault();
            // forzo rilettura
            if (answ != null)
            {
                dbCtx.Entry(answ).Reload();
            }
            return answ;
        }

        /// <summary>
        /// Get record by ProdId
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public ProdModel FindByProdId(int ProdId)
        {
            var answ = dbCtx
                .ProdList
                .Where(x => x.ProdId == ProdId)
                .SingleOrDefault();
            // forzo rilettura
            if (answ != null)
            {
                dbCtx.Entry(answ).Reload();
            }
            return answ;
        }

        /// <summary>
        /// Get record by ProdId ass Core.ProdFileM
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public Core.ProdFileM FindCoreByProdId(int ProdId)
        {
            var currProd = FindByProdId(ProdId);

            return Core.ProdFileM.CreateProdFileM(currProd.ProdId, ProjIdByProd(ProdId), currProd.DtCreated, currProd.Description);
        }

        /// <summary>
        /// Elenco progetti
        /// </summary>
        /// <param name="numRecord"></param>
        /// <returns></returns>
        public List<Core.ProdFileM> GetLastDesc(int numRecord)
        {
            List<Core.ProdFileM> result = new List<Core.ProdFileM>();
            var dbResult = GetLastDbModelDesc(numRecord);
            // conversione
            result = dbResult.Select(x => Core.ProdFileM.CreateProdFileM(x.ProdId, ProjIdByProd(x.ProdId), x.DtCreated, x.Description)).ToList();
            return result;
        }

        /// <summary>
        /// Fornisce nuovo indice VUOTO da usare (allocando sul DB)
        /// </summary>
        /// <param name="ProjId"></param>
        /// <returns></returns>
        public int GetNextIndex(int ProjId)
        {
            int nextId = 0;

            // cerco se ne ho ALMENO 1....
            var numRec = dbCtx.ProdList.Count();
            if (numRec == 0)
            {
                nextId = 1;
            }
            else
            {
                // retrieve ultimo...
                var maxRecord = dbCtx
                    .ProdList
                    .OrderByDescending(x => x.ProdId)
                    .Take(1)
                    .FirstOrDefault();
                // incremento
                nextId = maxRecord.ProdId + 1;
            }

            // creo nuovo PROD...
            var newProd = dbCtx
                .ProdList
                .Add(new ProdModel() { ProdId = nextId, Locked = true, DtCreated = DateTime.Now });

            // cerco Proj
            var currProj = dbCtx
                .ProjList
                .Where(x => x.ProjId == ProjId)
                .FirstOrDefault();

            // aggiungo proj-prod
            currProj.ProdDbId = newProd.ProdDbId;
            currProj.Locked = true;

            // Commit changes
            dbCtx.SaveChanges();

            return nextId;
        }

        /// <summary>
        /// Verifica prod assegnato a supervisor:
        /// ...se c'e' anche un solo machgroup del prod assegnato ad un supervisor o in stato 0 (dovrebbe essere la stessa cosa?)
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public bool IsAnyInSupervisor(int ProdId)
        {
            // cerco se ci siano assegnati a supervisor
            var numAssigned = dbCtx
                .MachGroupList
                .Where(x => x.Prod.ProdId == ProdId && (!string.IsNullOrEmpty(x.SupervisorId) || x.State >= 0))
                .Count();

            return numAssigned > 0;
        }

        /// <summary>
        /// Manage Lock by ProdId (proj & prod)
        /// </summary>
        /// <param name="ProdId">ProjID</param>
        /// <param name="Locked">Stato Lock da impostare</param>
        /// <returns></returns>
        public ProdModel LockByProdId(int ProdId, bool Locked)
        {
            // seleziono il prod...
            var currProd = dbCtx
                .ProdList
                .Where(x => x.ProdId == ProdId)
                .SingleOrDefault();

            if (currProd != null)
            {
                currProd.Locked = Locked;
                dbCtx.Entry(currProd).State = System.Data.Entity.EntityState.Modified;

                var currProj = dbCtx
                    .ProjList
                    .Where(x => x.ProdDbId == currProd.ProdDbId)
                    .ToList();

                //currProj.ForEach(x => x.Locked = Locked);
                foreach (var item in currProj)
                {
                    item.Locked = Locked;
                    dbCtx.Entry(item).State = System.Data.Entity.EntityState.Modified;
                }
            }

            dbCtx.SaveChanges();

            return currProd;
        }

        /// <summary>
        /// Update single PROD
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool Update(ProdModel updItem)
        {
            bool done = false;
            var item2update = dbCtx
                .ProdList
                .Where(x => x.ProdDbId == updItem.ProdDbId)
                .SingleOrDefault();
            try
            {
                // update, vers 1...
                dbCtx.Entry(item2update).CurrentValues.SetValues(updItem);

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

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
            }
            catch
            { }
            return done;
        }

        /// <summary>
        /// Update record su DB x elenco MachGroup:
        /// - NON vengono eliminati record (se ce ne son altri sul DB non saranno toccati)
        /// - i record ESISTENTI (per MachGroup.ID) saranno aggiornati (tranne start/end/status)
        /// - i record NON ESISTENTI (per MachGroup.ID) saranno AGGIUNTI (tranne start/end/status)
        /// </summary>
        /// <param name="ProdId">Id del Prod</param>
        /// <param name="MachGroupList">Elenco MachGroup da associare</param>
        /// <returns></returns>
        public ProdModel UpdateMachGroup(int ProdId, List<Core.MyMachGroupM> MachGroupList)
        {
            // Recupero il PROD
            ProdModel currData = FindByProdId(ProdId);

            try
            {
                // preparo elenco
                List<MachGroupModel> itemsMG2Add = new List<MachGroupModel>();
                List<Core.MyMachGroupM> MachGroupList2Add = new List<Core.MyMachGroupM>();
                List<PartModel> PartList2Add = new List<PartModel>();
                // cerco le MG esistenti --> aggiorno
                foreach (var item in MachGroupList)
                {
                    var currMG = dbCtx
                        .MachGroupList
                        .Where(x => x.Prod.ProdId == ProdId && x.MachGroupId == item.Id)
                        .SingleOrDefault();
                    var convCurrMG = MachGroupController.ConvertFromCore(item, currData.ProdDbId);
                    if (currMG != null)
                    {
                        // se non identico x equality limitata a ViewOptim...
                        if (!currMG.ViewOptimEquals(convCurrMG))
                        {
                            // aggiorno con nuovi valori ricevuti
                            currMG.H = convCurrMG.H;
                            currMG.L = convCurrMG.L;
                            currMG.W = convCurrMG.W;
                            currMG.Material = convCurrMG.Material;
                            currMG.Name = convCurrMG.Name;
                            // salvo
                            dbCtx.SaveChanges();
                        }
                    }
                    else
                    {
                        itemsMG2Add.Add(convCurrMG);
                    }
                }
                // aggiungo MachGroup
                dbCtx.MachGroupList.AddRange(itemsMG2Add);
                // Commit changes
                dbCtx.SaveChanges();

                // verifico di nuovo l'elenco delle MG x le relative PART...
                foreach (var item in MachGroupList)
                {
                    int MachGroupDbId = MachGroupController.man.FindByMachGroupId(item.Id).MachGroupDbId;
                    // verifico se uguali o meno...
                    foreach (var currPartM in item.PartMList)
                    {
                        var currPart = dbCtx
                          .PartList
                          .Where(x => x.MachGroup.Prod.ProdId == ProdId && x.MachGroup.MachGroupId == item.Id && x.PartId == currPartM.nPartId)
                          .SingleOrDefault();
                        var convCurrPartM = PartController.ConvertFromCore(currPartM, MachGroupDbId);
                        if (currPart != null)
                        {
                            // se non identico x equality limitata a ViewOptim...
                            if (!currPart.ViewOptimEquals(convCurrPartM))
                            {
                                // aggiorno con nuovi valori ricevuti
                                currPart.H = convCurrPartM.H;
                                currPart.L = convCurrPartM.L;
                                currPart.W = convCurrPartM.W;
                                currPart.Material = convCurrPartM.Material;
                                currPart.CALC_State = convCurrPartM.CALC_State;
                                currPart.ROT = convCurrPartM.ROT;
                                currPart.PDN = convCurrPartM.PDN;
                                currPart.NAM = convCurrPartM.NAM;
                                // salvo
                                dbCtx.SaveChanges();
                            }
                        }
                        else
                        {
                            PartList2Add.Add(convCurrPartM);
                        }
                    }
                }

                // aggiungo PartList
                dbCtx.PartList.AddRange(PartList2Add);
                // Commit changes
                dbCtx.SaveChanges();

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

                // Commit changes
                dbCtx.SaveChanges();
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateMachGroup: {exc}");
            }

            return currData;
        }

        #endregion Public Methods
    }
}