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 Constructors

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

        #endregion Public Constructors

#if false
        /// <summary>
        /// Create record on DB
        /// </summary>
        /// <param name="newProdId"></param>
        /// <param name="Description"></param>
        /// <returns></returns>
        public ProdModel Create(int newProdId, string Description)
        {
            ProdModel newProd = new ProdModel() { ProdId = newProdId, Description = Description };

            try
            {
                // Add to database
                dbCtx.ProdList.Add(newProd);
                // Commit changes
                dbCtx.SaveChanges();
            }
            catch
            { }

            return newProd;
        }

        /// <summary>
        /// Get paginated data from DB (ASC ordered)
        /// </summary>
        /// <param name="ProdDbIdStart"></param>
        /// <param name="numRecord"></param>
        /// <returns></returns>
        public List<ProdModel> GetPaginatedAsc(int ProdDbIdStart, int numRecord)
        {
            int numEnd = ProdDbIdStart - numRecord;
            // check numEnd
            if (numEnd < 0)
                numEnd = 0;
            // retrieve
            return dbCtx
                .ProdList
                .Where(x => x.ProdDbId <= ProdDbIdStart)
                .OrderBy(x => x.ProdDbId)
                .Take(numRecord)
                .ToList();
        }

        /// <summary>
        /// Get paginated data from DB (DESC ordered)
        /// </summary>
        /// <param name="PartDbIdStart"></param>
        /// <param name="numRecord"></param>
        /// <returns></returns>
        public List<ProdModel> GetPaginatedDesc(int PartDbIdStart, int numRecord)
        {
            int numEnd = PartDbIdStart - numRecord;
            // check numEnd
            if (numEnd < 0)
                numEnd = 0;
            // retrieve
            return dbCtx
                .ProdList
                .Where(x => x.ProdDbId <= PartDbIdStart)
                .OrderByDescending(x => x.ProdDbId)
                .Take(numRecord)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by ProdectId (ASC ordered)
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public List<ProdModel> GetByProdAsc(int ProdDbId)
        {
            // retrieve
            return dbCtx
                .ProdList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderBy(x => x.ProdDbId)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by ProdectId (DESC ordered)
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public List<ProdModel> GetByProdDesc(int ProdDbId)
        {
            // retrieve
            return dbCtx
                .ProdList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderByDescending(x => x.ProdDbId)
                .ToList();
        }

        /// <summary>
        /// Get record by RawPartDbId
        /// </summary>
        /// <param name="RawPartDbId"></param>
        /// <returns></returns>
        public ProdModel FindByRawPartDbId(int RawPartDbId)
        {
            var rawPart = dbCtx
                   .RawPartList
                   .Where(x => x.RawPartDbId == RawPartDbId)
                   .SingleOrDefault();

            return FindByProdDbId(rawPart.ProdDbId);
        }

        /// <summary>
        /// Get record by RawPartId
        /// </summary>
        /// <param name="RawPartId "></param>
        /// <returns></returns>
        public ProdModel FindByRawPartId(int RawPartId)
        {
            var rawPart = dbCtx
                   .RawPartList
                   .Where(x => x.RawPartId == RawPartId)
                   .SingleOrDefault();

            return FindByProdDbId(rawPart.ProdDbId);
        }
#endif

        #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;

            // salvo
            dbCtx.SaveChanges();

            return done;
        }

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

            var currProd = FindByProdId(ProdId);

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

            try
            {
                // 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)
        {
            return dbCtx
                .ProdList
                .Where(x => x.ProdDbId == ProdDbId)
                .SingleOrDefault();
        }

        /// <summary>
        /// Get record by ProdId
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public ProdModel FindByProdId(int ProdId)
        {
            return dbCtx
                .ProdList
                .Where(x => x.ProdId == ProdId)
                .SingleOrDefault();
        }

        /// <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;

            // Commit changes
            dbCtx.SaveChanges();

            return nextId;
        }

        /// <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();
            currProd.Locked = Locked;

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

            currProj.ForEach(x => x.Locked = Locked);

            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
        /// </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);

            // converto le MachGroup
            List<MachGroupModel> itemsMG2add = MachGroupList.Select(x => MachGroupController.ConvertFromCore(x, currData.ProdDbId)).ToList();

            // sel delle BTLParts da proj
            IQueryable<MachGroupModel> itemsMG2del = dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == currData.ProdDbId);

            try
            {
                // per ogni itemsMG2del rimuovo Part
                foreach (var item in itemsMG2del)
                {
                    PartController.man.DeleteByMachGroup(item.MachGroupDbId);
                }

                // elimino dal DB i MG
                dbCtx.MachGroupList.RemoveRange(itemsMG2del.ToList());
                // aggiungo le nuove
                dbCtx.MachGroupList.AddRange(itemsMG2add);

                // Commit changes
                dbCtx.SaveChanges();

                // per ogni item in MachGroupList aggiungo Part
                foreach (var item in MachGroupList)
                {
                    int MachGroupDbId = MachGroupController.man.FindByMachGroupId(item.Id).MachGroupDbId;
                    // converto le corePartList
                    List<PartModel> PartList2Add = item.PartMList.Select(x => PartController.ConvertFromCore(x, MachGroupDbId)).ToList();

                    // aggiungo
                    dbCtx.PartList.AddRange(PartList2Add);
                }

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

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

            return currData;
        }

        /// <summary>
        /// Update record su DB x elenco MachGroupDB
        /// </summary>
        /// <param name="ProdId">Id del Prod</param>
        /// <param name="MachGroupList">Elenco MachGroup da associare</param>
        /// <returns></returns>
        public ProdModel UpdateMachGroupDB(int ProdId, List<MachGroupModel> itemsMG2add, List<PartModel> PartList2Add)
        {
            // Recupero il PROD
            ProdModel currData = FindByProdId(ProdId);

            // sel delle BTLParts da proj
            IQueryable<MachGroupModel> itemsMG2del = dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == currData.ProdDbId);

            try
            {
                // per ogni itemsMG2del rimuovo Part
                foreach (var item in itemsMG2del)
                {
                    PartController.man.DeleteByMachGroup(item.MachGroupDbId);
                }

                // elimino dal DB i MG
                dbCtx.MachGroupList.RemoveRange(itemsMG2del.ToList());
                // aggiungo le nuove
                dbCtx.MachGroupList.AddRange(itemsMG2add);

                // Commit changes
                dbCtx.SaveChanges();

                // aggiungo Parts
                dbCtx.PartList.AddRange(PartList2Add);

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

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

            return currData;
        }

        #endregion Public Methods
    }
}