using MagMan.Data.Admin.DbModels;
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;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace MagMan.Data.Admin.Controllers
{
    public class MTAdminController : IDisposable
    {
        #region Public Constructors

        public MTAdminController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        #endregion Public Constructors

        #region Public Methods


        /// <summary>
        /// Elimina item AuthKey
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool AuthKeyDelete(AuthKeyModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetAuthKey
                        .Where(x => x.AuthKeyID == updItem.AuthKeyID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetAuthKey
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in AuthKeyDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco AuthKey dato Customer
        /// </summary>
        /// <param name="CustomerId">0 = tutti</param>
        /// <returns></returns>
        public List<AuthKeyModel> AuthKeyByCustId(int CustomerId)
        {
            List<AuthKeyModel> dbResult = new List<AuthKeyModel>();
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                dbResult = dbCtx
                            .DbSetAuthKey
                            .Where(x => CustomerId == 0 || x.CustomerID == CustomerId)
                            .Include(c => c.CustomerNav)
                            .OrderBy(x => x.KeyNum)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiunge/Modifica un item AuthKey
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool AuthKeyUpdate(AuthKeyModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetAuthKey
                        .Where(x => x.AuthKeyID == updItem.AuthKeyID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.KeyNum = updItem.KeyNum;
                        currData.KeyValue = updItem.KeyValue;
                        currData.Note = updItem.Note;
                        currData.CustomerID = updItem.CustomerID;
                        currData.IsActive = updItem.IsActive;
                        currData.DtActivation = updItem.DtActivation;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetAuthKey
                            .Add(updItem);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in AuthKeyUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }


        /// <summary>
        /// Elimina item Customer
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool CustomerDelete(CustomerModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetCustomers
                        .Where(x => x.CustomerID == updItem.CustomerID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetCustomers
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in CustomerDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco clienti
        /// </summary>
        /// <returns></returns>
        public List<CustomerModel> CustomerGetAll()
        {
            List<CustomerModel> dbResult = new List<CustomerModel>();
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                dbResult = dbCtx
                            .DbSetCustomers
                            .Select(s => new CustomerModel
                            {
                                CustomerID = s.CustomerID,
                                DtActivation = s.DtActivation,
                                IsActive = s.IsActive,
                                RestToken = s.RestToken,
                                Name = s.Name,
                                Note = s.Note,
                                MainKey = s.MainKey,
                                HasDb = s.HasDb,
                                HasChildren = s.MachineNav.Any()
                            })
                            .OrderBy(x => x.Name)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiunge/Modifica un item Customer
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool CustomerUpdate(CustomerModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetCustomers
                        .Where(x => x.CustomerID == updItem.CustomerID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.Name = updItem.Name;
                        currData.Note = updItem.Note;
                        currData.IsActive = updItem.IsActive;
                        currData.DtActivation = updItem.DtActivation;
                        currData.RestToken = updItem.RestToken;
                        currData.MainKey = updItem.MainKey;
                        currData.HasDb = updItem.HasDb;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetCustomers
                            .Add(updItem);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in CustomerUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

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

        /// <summary>
        /// Elimina item Machine
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool MachineDelete(MachineModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetMachines
                        .Where(x => x.MachineID == updItem.MachineID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        dbCtx
                            .DbSetMachines
                            .Remove(currData);
                        dbCtx.SaveChanges();
                        done = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in MachineDelete{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Elenco Machine dato Customer
        /// </summary>
        /// <param name="CustomerId">0 = tutti</param>
        /// <returns></returns>
        public List<MachineModel> MachineGetByCustId(int CustomerId)
        {
            List<MachineModel> dbResult = new List<MachineModel>();
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                dbResult = dbCtx
                            .DbSetMachines
                            .Where(x => CustomerId == 0 || x.CustomerID == CustomerId)
                            .OrderBy(x => x.Name)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Aggiunge/Modifica un item Machine
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool MachineUpdate(MachineModel updItem)
        {
            bool done = false;
            using (MultiTenantContext dbCtx = new MultiTenantContext())
            {
                try
                {
                    var currData = dbCtx
                        .DbSetMachines
                        .Where(x => x.MachineID == updItem.MachineID)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.Name = updItem.Name;
                        currData.Note = updItem.Note;
                        currData.CustomerID = updItem.CustomerID;
                        currData.IsActive = updItem.IsActive;
                        currData.DtActivation = updItem.DtActivation;
                        currData.MainKey = updItem.MainKey;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetMachines
                            .Add(updItem);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in MachineUpdate{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        #endregion Public Methods

        #region Private Fields

        private static IConfiguration _configuration = null!;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}