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

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

        private DatabaseContext dbCtx;

        #endregion Private Fields

        #region Public Fields

        public static MachGroupController man = new MachGroupController();

        #endregion Public Fields

        #region Public Constructors

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

        #endregion Public Constructors

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

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

#endif

        #region Public Methods

        /// <summary>
        /// Conversion of base class to DB model class
        /// </summary>
        /// <param name="coreMachGroup"></param>
        /// <param name="currProdDbId"></param>
        /// <returns></returns>
        public static MachGroupModel ConvertFromCore(Core.MyMachGroup coreMachGroup, int currProdDbId)
        {
            MachGroupModel answ = new MachGroupModel();
            if (coreMachGroup != null)
            {
                answ = new MachGroupModel()
                {
                    Assign = "",
                    Name = coreMachGroup.Name,
                    Locked = true,
                    MachGroupId = coreMachGroup.Id,
                    ProdDbId = currProdDbId,
                    State = Core.ItemState.ND,
                    H = coreMachGroup.dH,
                    L = coreMachGroup.dL,
                    W = coreMachGroup.dW,
                    Material = coreMachGroup.sMATERIAL
                };
            }
            return answ;
        }

        /// <summary>
        /// Create record on DB
        /// </summary>
        /// <param name="newMachGroupId"></param>
        /// <param name="Name"></param>
        /// <returns></returns>
        public MachGroupModel Create(int newMachGroupId, string Name)
        {
            MachGroupModel newMachGroup = new MachGroupModel() { MachGroupId = newMachGroupId, Name = Name, State = Core.ItemState.ND };

            try
            {
                // Add to database
                dbCtx.MachGroupList.Add(newMachGroup);
                // Commit changes
                dbCtx.SaveChanges();
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on Create: {exc}");
            }

            return newMachGroup;
        }

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

        /// <summary>
        /// Get record by MachGroupDbId
        /// </summary>
        /// <param name="MachGroupDbId"></param>
        /// <returns></returns>
        public MachGroupModel FindByMachGroupDbId(int MachGroupDbId)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.MachGroupDbId == MachGroupDbId)
                .SingleOrDefault();
        }

        /// <summary>
        /// Get record by MachGroupId
        /// </summary>
        /// <param name="MachGroupId"></param>
        /// <returns></returns>
        public MachGroupModel FindByMachGroupId(int MachGroupId)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.MachGroupId == MachGroupId)
                .SingleOrDefault();
        }

        /// <summary>
        /// Get filtered data by Assign (ASC ordered)
        /// </summary>
        /// <param name="Assign"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByAssign(string Assign)
        {
            return dbCtx
                .MachGroupList
                .Where(x => x.Assign == Assign)
                .OrderBy(x => x.Order)
                .ThenBy(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by ProdId (ASC ordered)
        /// </summary>
        /// <param name="ProdId"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByProdAsc(int ProdId)
        {
            // recupero
            int ProdDbId = 0;
            try
            {
                var currProd = dbCtx
                    .ProdList
                    .Where(x => x.ProdId == ProdId)
                    .FirstOrDefault();
                if (currProd != null)
                {
                    ProdDbId = currProd.ProdDbId;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on GetByProdAsc: {exc}");
            }
            return dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderBy(x => x.Order)
                .ThenBy(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Get filtered data by MachGroupectId (DESC ordered)
        /// </summary>
        /// <param name="ProdDbId"></param>
        /// <returns></returns>
        public List<MachGroupModel> GetByProdDesc(int ProdId)
        {
            // recupero
            int ProdDbId = 0;
            try
            {
                var currProd = dbCtx
                    .ProdList
                    .Where(x => x.ProdId == ProdId)
                    .FirstOrDefault();
                if (currProd != null)
                {
                    ProdDbId = currProd.ProdDbId;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on GetByProdDesc: {exc}");
            }
            return dbCtx
                .MachGroupList
                .Where(x => x.ProdDbId == ProdDbId)
                .OrderByDescending(x => x.Order)
                .ThenByDescending(x => x.MachGroupId)
                .ToList();
        }

        /// <summary>
        /// Update single MachGroup
        /// </summary>
        /// <param name="updItem">Item to update (with updated values)</param>
        /// <returns></returns>
        public bool Update(MachGroupModel updItem)
        {
            bool done = false;
            var item2update = dbCtx
                .MachGroupList
                .Where(x => x.MachGroupDbId == updItem.MachGroupDbId)
                .SingleOrDefault();
            try
            {
                // update, vers 1...
                dbCtx.Entry(item2update).CurrentValues.SetValues(updItem);

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

                // Commit changes
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on Update: {exc}");
            }
            return done;
        }

        /// <summary>
        /// Set Status for MachGroup
        /// </summary>
        /// <param name="newAssign"></param>
        /// <param name="newState"></param>
        /// <returns></returns>
        public bool UpdateAssign(int MachGroupId, string newAssign)
        {
            bool done = false;
            try
            {
                // aggiorno
                var currRecord = dbCtx
                .MachGroupList
                .Where(x => x.MachGroupId == MachGroupId)
                .FirstOrDefault();

                currRecord.Assign = newAssign;
                currRecord.State = Core.ItemState.Assigned;

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

            return done;
        }

        /// <summary>
        /// Set Status for MachGroup
        /// </summary>
        /// <param name="MachGroupId"></param>
        /// <param name="newState"></param>
        /// <returns></returns>
        public bool UpdateStatus(int MachGroupId, Core.ItemState newState)
        {
            bool done = false;
            try
            {
                // aggiorno
                dbCtx
                .MachGroupList
                .Where(x => x.MachGroupId == MachGroupId)
                .FirstOrDefault()
                .State = newState;
                // Commit changes
                dbCtx.SaveChanges();
                done = true;
            }
            catch (Exception exc)
            {
                Console.WriteLine($"EXCEPTION on UpdateStatus: {exc}");
            }

            return done;
        }

        #endregion Public Methods
    }
}