using MagMan.Data.Tenant.DbModels;
using MagMan.Data.Tenant.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MagMan.Data.Tenant.Controllers
{
    public class TenantController : IDisposable
    {
        #region Public Constructors

        public TenantController()
        {
        }

        #endregion Public Constructors

        #region Public Methods

        public async Task<bool> DatabaseMigrate(string connString)
        {
            bool answ = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                await dbCtx.Database.MigrateAsync();
                answ = true;
            }
            return answ;
        }

        public void Dispose()
        {
            // Clear database context
            Log.Info("Dispose di TenantController");
        }

        /// <summary>
        /// Elimina Item da magazzino
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2del">Item da eliminare</param>
        /// <returns></returns>
        public bool ItemDelete(string connString, RawItemModel rec2del)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetItems
                        .Where(x => x.RawItemId == rec2del.RawItemId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetItems
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ItemDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco Items gestiti a magazzino (all)
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <returns></returns>
        public List<RawItemModel> ItemGetAll(string connString)
        {
            List<RawItemModel> dbResult = new List<RawItemModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                dbResult = dbCtx
                            .DbSetItems
                            //.Where(x => CustomerId == 0 || x.CustomerID == CustomerId)
                            .Include(c => c.MaterialNav)
                            .OrderBy(x => x.MatId)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Items gestiti a magazzino dato Materiale
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="matID">ID del materiale x cui filtrare, 0 = tutti</param>
        /// <returns></returns>
        public List<RawItemModel> ItemGetByMat(string connString, int matID)
        {
            List<RawItemModel> dbResult = new List<RawItemModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                dbResult = dbCtx
                            .DbSetItems
                            .Where(x => matID == 0 || x.MatId == matID)
                            .Include(c => c.MaterialNav)
                            //.OrderBy(x => x.MatId)
                            .OrderBy(x => x.WMm)
                            .ThenBy(x => x.HMm)
                            .ThenBy(x => x.LMm)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary> Aggiunge/Modifica un item in magazzino </summary> <param
        /// name="connString">Stringa connessione (variabile x cliente)</param> <param
        /// name="rec2upd">Record da aggiornare</param> <param name="deltaQty">quantità da
        /// aggiornare (se <0 è consumo)</param> <returns></returns>
        public bool ItemModQty(string connString, RawItemModel rec2upd, int deltaQty)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    /*
                     * Verifica se esistesse: deve essere valido TUTTO
                     * - stesso materiale
                     * - stesse dimensioni
                     * */
                    var currData = dbCtx
                        .DbSetItems
                        .Where(x => (x.RawItemId == rec2upd.RawItemId) ||
                                    (x.MatId == rec2upd.MatId && (x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm)))
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.QtyAvail += deltaQty;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ItemModQty{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Aggiunge/Modifica un item in magazzino
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2upd">Record da aggiungere/aggiornare</param>
        /// <returns></returns>
        public bool ItemUpdate(string connString, RawItemModel rec2upd)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    /*
                     * Verifica se esistesse: deve essere valido TUTTO
                     * - stesso materiale
                     * - stesse dimensioni
                     * */
                    var currData = dbCtx
                        .DbSetItems
                        .Where(x => (x.RawItemId == rec2upd.RawItemId) ||
                                    (x.MatId == rec2upd.MatId && (x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm)))
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.MatId = rec2upd.MatId;
                        currData.QtyAvail = rec2upd.QtyAvail;
                        currData.IsActive = rec2upd.IsActive;
                        currData.IsRemn = rec2upd.IsRemn;
                        currData.Location = rec2upd.Location;
                        currData.LMm = rec2upd.LMm;
                        currData.HMm = rec2upd.HMm;
                        currData.WMm = rec2upd.WMm;
                        currData.Note = rec2upd.Note;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetItems
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ItemUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elimina Materiale da magazzino
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2del">Item da eliminare</param>
        /// <returns></returns>
        public bool MaterialDelete(string connString, MaterialModel rec2del)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetMaterials
                        .Where(x => x.MatId == rec2del.MatId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetMaterials
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in MaterialDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco Materiali gestiti a magazzino
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <returns></returns>
        public List<MaterialModel> MaterialGetAll(string connString, bool withChild)
        {
            List<MaterialModel> dbResult = new List<MaterialModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                if (withChild)
                {
                    dbResult = dbCtx
                                .DbSetMaterials
                                .Include(x => x.RawItemList)
                                .OrderBy(x => x.MatDesc)
                                .ThenBy(x => x.WMm)
                                .ThenBy(x => x.HMm)
                                .ThenBy(x => x.LMm)
                                .ToList();
                }
                else
                {
                    dbResult = dbCtx
                                .DbSetMaterials
                                .OrderBy(x => x.MatDesc)
                                .ThenBy(x => x.WMm)
                                .ThenBy(x => x.HMm)
                                .ThenBy(x => x.LMm)
                                .ToList();
                }
            }
            return dbResult;
        } /// <summary>

          /// Elenco Materiali gestiti a magazzino </summary> <param name="connString">Stringa
          /// connessione (variabile x cliente)</param> <param name="numKey">Materiale richiesto, 0
          /// = tutti</param> <param name="withChild">Se true allora include record child
          /// (Items)</param> <returns></returns>
        public List<MaterialModel> MaterialGetFilt(string connString, int matID, bool withChild)
        {
            List<MaterialModel> dbResult = new List<MaterialModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                if (withChild)
                {
                    dbResult = dbCtx
                                .DbSetMaterials
                                .Where(x => matID == 0 || x.MatId == matID)
                                .Include(x => x.RawItemList)
                                .OrderBy(x => x.MatDesc)
                                .ThenBy(x => x.WMm)
                                .ThenBy(x => x.HMm)
                                .ThenBy(x => x.LMm)
                                .ToList();
                }
                else
                {
                    dbResult = dbCtx
                                .DbSetMaterials
                                .Where(x => matID == 0 || x.MatId == matID)
                                .OrderBy(x => x.MatDesc)
                                .ThenBy(x => x.WMm)
                                .ThenBy(x => x.HMm)
                                .ThenBy(x => x.LMm)
                                .ToList();
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiunge/Modifica un Materiale in magazzino
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2upd">Record da aggiungere/aggiornare</param>
        /// <returns></returns>
        public bool MaterialUpdate(string connString, MaterialModel rec2upd)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    /*
                     * Ricerca equal: corrisponde se
                     * - MatId identico
                     * - se Uguali + NonNulli [MatCode oppure MatDescript] + uguali [W/H/L]...
                    */
                    var currData = dbCtx
                        .DbSetMaterials
                        .Where(x => (rec2upd.MatId > 0 && x.MatId == rec2upd.MatId) ||
                                    ((x.WMm == rec2upd.WMm && x.HMm == rec2upd.HMm && x.LMm == rec2upd.LMm) &&
                                        ((!string.IsNullOrEmpty(rec2upd.MatCode) && x.MatCode == rec2upd.MatCode) || (!string.IsNullOrEmpty(rec2upd.MatDesc) && x.MatDesc == rec2upd.MatDesc))
                                    ))
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.MatCode = rec2upd.MatCode;
                        currData.MatDesc = rec2upd.MatDesc;
                        currData.LMm = rec2upd.LMm;
                        currData.HMm = rec2upd.HMm;
                        currData.WMm = rec2upd.WMm;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetMaterials
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in MaterialUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elimina record Project
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2del">Item da eliminare</param>
        /// <returns></returns>
        public bool ProjectDelete(string connString, ProjModel rec2del)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetProjects
                        .Where(x => x.ProjDbId == rec2del.ProjDbId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetProjects
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ProjectDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco Projects (all)
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <returns></returns>
        public List<ProjModel> ProjectGetAll(string connString)
        {
            List<ProjModel> dbResult = new List<ProjModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                dbResult = dbCtx
                            .DbSetProjects
                            .OrderBy(x => x.DtCreated)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Items gestiti a magazzino dato Materiale
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="numKey">ID del materiale x cui filtrare, 0 = tutti</param>
        /// <returns></returns>
        public List<ProjModel> ProjectGetByNumKey(string connString, int numKey)
        {
            List<ProjModel> dbResult = new List<ProjModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                dbResult = dbCtx
                            .DbSetProjects
                            .Where(x => numKey == 0 || x.KeyNum == numKey)
                            .OrderBy(x => x.DtCreated)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Items gestiti a magazzino dato Materiale
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="numKey">ID master key, 0 = tutti</param>
        /// <param name="numKey">periodo x filtraggio</param>
        /// <returns></returns>
        public List<ProjModel> ProjectGetFilt(string connString, int numKey, SelectData period)
        {
            List<ProjModel> dbResult = new List<ProjModel>();
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                dbResult = dbCtx
                            .DbSetProjects
                            .Where(x => (numKey == 0 || x.KeyNum == numKey) &&
                                ((x.DtCreated >= period.DateStart && x.DtCreated <= period.DateEnd)
                                    || (x.DtSchedule >= period.DateStart && x.DtSchedule <= period.DateEnd)
                                    || (x.DtLastAction >= period.DateStart && x.DtLastAction <= period.DateEnd)
                                ))
                            .OrderBy(x => x.DtCreated)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiunge/Modifica un record Project
        /// </summary>
        /// <param name="connString">Stringa connessione (variabile x cliente)</param>
        /// <param name="rec2upd">Record da aggiungere/aggiornare</param>
        /// <returns></returns>
        public bool ProjectUpdate(string connString, ProjModel rec2upd)
        {
            bool done = false;
            using (MagManContext dbCtx = new MagManContext(connString))
            {
                try
                {
                    /*
                     * Ricerca:
                     * - DbId corrisponde
                     * - Key + Id remoti corrispondono
                     * */
                    var currData = dbCtx
                        .DbSetProjects
                        .Where(x => (x.ProjDbId == rec2upd.ProjDbId) ||
                                    (x.ProjExtDbId == rec2upd.ProjExtDbId && x.KeyNum == rec2upd.KeyNum) ||
                                    (x.ProjExtId == rec2upd.ProjExtId && x.KeyNum == rec2upd.KeyNum))
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.MachineID = rec2upd.MachineID;
                        currData.KeyNum = rec2upd.KeyNum;
                        currData.ProjExtDbId = rec2upd.ProjExtDbId;
                        currData.ProjExtId = rec2upd.ProjExtId;
                        currData.BTLFileName = rec2upd.BTLFileName;
                        currData.PType = rec2upd.PType;
                        currData.Machine = rec2upd.Machine;
                        currData.ProjDescription = rec2upd.ProjDescription;
                        currData.DtCreated = rec2upd.DtCreated;
                        currData.DtLastAction = rec2upd.DtLastAction;
                        currData.DtSchedule = rec2upd.DtSchedule;
                        currData.DtStartProd = rec2upd.DtStartProd;
                        currData.ListName = rec2upd.ListName;
                        currData.ProcTimeEst = rec2upd.ProcTimeEst;
                        currData.ProcTimeReal = rec2upd.ProcTimeReal;
                        currData.IsActive = rec2upd.IsActive;
                        currData.IsArchived = rec2upd.IsArchived;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetProjects
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ItemUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        #endregion Public Methods

        #region Private Fields

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}