using MagMan.Core;
using MagMan.Core.Services;
using MagMan.Data.Admin.Controllers;
using MagMan.Data.Admin.DbModels;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.VisualBasic;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;

namespace MagMan.Data.Admin.Services
{
    public class MTAdminService : BaseServ
    {
        #region Public Constructors

        public MTAdminService(IConfiguration configuration, IConnectionMultiplexer redisConnMult, IEmailSender emailSender, UserManager<IdentityUser> userManager)
        {
            Log.Info("MTAdminService starting...");
            _configuration = configuration;
            _emailSender = emailSender;
            _userManager = userManager;
            // Conf cache
            redisConn = redisConnMult;
            redisDb = this.redisConn.GetDatabase();

            // json serializer... FIX errore loop circolare https://www.ryadel.com/en/jsonserializationexception-self-referencing-loop-detected-error-fix-entity-framework-asp-net-core/
            JSSettings = new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };

            // cod app
            CodApp = _configuration["CodApp"];
            dbController = new MTAdminController(configuration);

            // chiudo log
            Log.Info("MTAdminService started!");
            _userManager = userManager;
        }

        #endregion Public Constructors

        #region Public Properties

        public string CodApp { get; set; } = "";

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Lista AuthKey
        /// </summary>
        /// <param name="CustomerId">0 = tutti</param>
        /// <returns></returns>
        public async Task<List<AuthKeyModel>> AuthKeyByCustId(int CustomerId)
        {
            string source = "DB";
            List<AuthKeyModel>? dbResult = new List<AuthKeyModel>();
            try
            {
                string currKey = $"{Const.rKeyConfig}:Admin:AuthKeyList:{CustomerId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<AuthKeyModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<AuthKeyModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.AuthKeyByCustId(CustomerId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, LongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<AuthKeyModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"AuthKeyByCustId | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Error during AuthKeyByCustId:{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        /// <summary>
        /// Delete record AuthKey + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> AuthKeyDelete(AuthKeyModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.AuthKeyDelete(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during AuthKeyDelete:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Lista AuthKey da Rest Token
        /// </summary>
        /// <param name="RestToken">token di auth del cliente</param>
        /// <returns></returns>
        public async Task<List<AuthKeyModel>> AuthKeyGetByToken(string RestToken)
        {
            List<AuthKeyModel>? dbResult = new List<AuthKeyModel>();
            // cerco in primis customer ID...
            int CustomerId = await CustomerIdByToken(RestToken);
            if (CustomerId >= 0)
            {
                dbResult = await AuthKeyByCustId(CustomerId);
            }
            return dbResult;
        }

        /// <summary>
        /// Update record AuthKey + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> AuthKeyUpdate(AuthKeyModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.AuthKeyUpdate(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during AuthKeyUpdate:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Delete record customer + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> CustomerDelete(CustomerModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.CustomerDelete(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during CustomerDelete:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Lista Customers
        /// </summary>
        /// <returns></returns>
        public async Task<List<CustomerModel>> CustomerGetAll()
        {
            string source = "DB";
            List<CustomerModel>? dbResult = new List<CustomerModel>();
            try
            {
                string currKey = $"{Const.rKeyConfig}:Admin:CustomersList";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<CustomerModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<CustomerModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.CustomerGetAll();
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, LongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<CustomerModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"CustomerGetAll | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Error during CustomerGetAll:{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        /// <summary>
        /// Recupera CustomerID dal dizionario dei token noti o cercando sul DB
        /// </summary>
        /// <param name="RestToken"></param>
        /// <returns></returns>
        public async Task<int> CustomerIdByToken(string RestToken)
        {
            int answ = -1;
            string currKey = $"{Const.rKeyConfig}:Admin:Dict:Token2CustID";
            answ = RedisHashGetInt(currKey, RestToken);
            if (answ <= 0)
            {
                // cerco nel DB
                var custList = await CustomerGetAll();
                var custRow = custList.FirstOrDefault(x => x.RestToken == RestToken);
                // se trovato salvo
                if (custRow != null)
                {
                    answ = custRow.CustomerID;
                    RedisHashSet(currKey, RestToken, $"{answ}");
                    Log.Info($"Token2CustID: added {RestToken} --> {answ}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Update record customer + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> CustomerUpdate(CustomerModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.CustomerUpdate(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during CustomerUpdate:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Refresh globale cache redis
        /// </summary>
        /// <returns></returns>
        public async Task<bool> FlushRedisCache()
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Const.rKeyConfig}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            stopWatch.Stop();
            Log.Debug($"FlushRedisCache in {stopWatch.Elapsed.TotalMilliseconds} ms");
            return answ;
        }

        /// <summary>
        /// Delete record Machine + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> MachineDelete(MachineModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.MachineDelete(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during MachineDelete:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Lista Macchine
        /// </summary>
        /// <param name="CustomerId">0 = tutti</param>
        /// <returns></returns>
        public async Task<List<MachineModel>> MachineGetByCustId(int CustomerId)
        {
            string source = "DB";
            List<MachineModel>? dbResult = new List<MachineModel>();
            try
            {
                string currKey = $"{Const.rKeyConfig}:Admin:MachineList:{CustomerId}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<MachineModel>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<MachineModel>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    dbResult = dbController.MachineGetByCustId(CustomerId);
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, LongCache);
                    // per evitare loopback uso deserialize...
                    var tempResult = JsonConvert.DeserializeObject<List<MachineModel>>(rawData);
                    if (tempResult != null)
                    {
                        dbResult = tempResult;
                    }
                }
                if (dbResult == null)
                {
                    dbResult = new List<MachineModel>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"MachineGetByCustId | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Error during MachineGetByCustId:{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        /// <summary>
        /// Lista Macchine da Rest Token
        /// </summary>
        /// <param name="RestToken">token di auth del cliente</param>
        /// <returns></returns>
        public async Task<List<MachineModel>> MachineGetByToken(string RestToken)
        {
            List<MachineModel>? dbResult = new List<MachineModel>();
            // cerco in primis customer ID...
            int CustomerId = await CustomerIdByToken(RestToken);
            if (CustomerId >= 0)
            {
                dbResult = await MachineGetByCustId(CustomerId);
            }
            return dbResult;
        }

        /// <summary>
        /// Update record Machine + refresh cache
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> MachineUpdate(MachineModel currItem)
        {
            bool fatto = false;
            try
            {
                fatto = dbController.MachineUpdate(currItem);
                if (fatto)
                {
                    await FlushRedisCache();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Error during MachineUpdate:{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Recupera CustomerID dal dizionario dei token noti o cercando sul DB
        /// </summary>
        /// <param name="CustID"></param>
        /// <returns></returns>
        public async Task<int> MainKeyByCustomer(int CustID)
        {
            int answ = -1;
            string currKey = $"{Const.rKeyConfig}:Admin:Dict:Cust2MKey";
            answ = RedisHashGetInt(currKey, $"{CustID}");
            if (answ <= 0)
            {
                // cerco nel DB
                var custList = await CustomerGetAll();
                var custRow = custList.FirstOrDefault(x => x.CustomerID == CustID);
                // se trovato salvo
                if (custRow != null)
                {
                    answ = custRow.MainKey;
                    RedisHashSet(currKey, $"{CustID}", $"{answ}");
                    Log.Info($"Cust2MKey: added {CustID} --> {answ}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Recupera MainKey dal dizionario dei token noti o cercando sul DB
        /// </summary>
        /// <param name="RestToken"></param>
        /// <returns></returns>
        public async Task<int> MainKeyByToken(string RestToken)
        {
            int answ = -1;
            string currKey = $"{Const.rKeyConfig}:Admin:Dict:Token2MKey";
            answ = RedisHashGetInt(currKey, RestToken);
            if (answ <= 0)
            {
                // cerco nel DB
                var custList = await CustomerGetAll();
                var custRow = custList.FirstOrDefault(x => x.RestToken == RestToken);
                // se trovato salvo
                if (custRow != null)
                {
                    answ = custRow.MainKey;
                    RedisHashSet(currKey, RestToken, $"{answ}");
                    Log.Info($"TokenMKey: added {RestToken} --> {answ}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Reset dati cache redis
        /// </summary>
        /// <returns></returns>
        public async Task ResetUserDataCache()
        {
            string currKey = $"{Const.rKeyConfig}:Admin:UserData:*";
            await ExecFlushRedisPattern((RedisValue)currKey);
        }

        private readonly UserManager<IdentityUser> _userManager;
        public async Task<List<UserData>> UserDataGetFilt(string searchVal)
        {
            // Collezione utenti
            List<IdentityUser> RawList = new List<IdentityUser>();
            List<UserData> dbResult = new List<UserData>();

            string source = "DB";
            try
            {
                string typeSearch = string.IsNullOrEmpty(searchVal) ? "ALL" : searchVal;
                string currKey = $"{Const.rKeyConfig}:Admin:UserData:{typeSearch}";
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                string? rawData = await redisDb.StringGetAsync(currKey);
                if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
                {
                    source = "REDIS";
                    var tempResult = JsonConvert.DeserializeObject<List<UserData>>(rawData);
                    if (tempResult == null)
                    {
                        dbResult = new List<UserData>();
                    }
                    else
                    {
                        dbResult = tempResult;
                    }
                }
                else
                {
                    // recupero utenti da obj _userManager
                    var allData = _userManager.Users.ToList();
                    if (!string.IsNullOrEmpty(searchVal))
                    {
                        RawList = allData.Where(x => x.NormalizedEmail.Contains(searchVal.ToUpper()) || x.NormalizedUserName.Contains(searchVal.ToUpper())).ToList();
                    }
                    else
                    {
                        RawList = allData;
                    }
                    var user = RawList.Select(x => new IdentityUser
                    {
                        Id = x.Id,
                        UserName = x.UserName,
                        Email = x.Email,
                        PhoneNumber = x.PhoneNumber,
                        PasswordHash = "*****",
                        EmailConfirmed = x.EmailConfirmed
                    }).ToList();

                    foreach (var item in user)
                    {
                        var UserRoles = await _userManager.GetRolesAsync(item);
                        var UserClaims = await _userManager.GetClaimsAsync(item);

                        var newItem = new UserData()
                        {
                            Identity = item,
                            Roles = UserRoles.ToList(),
                            Claims = UserClaims.ToList()
                        };
                        dbResult.Add(newItem);
                    }
                    rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                    await redisDb.StringSetAsync(currKey, rawData, LongCache);
                }
                if (dbResult == null)
                {
                    dbResult = new List<UserData>();
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"UserDataGetFilt | {source} in: {ts.TotalMilliseconds} ms");
            }
            catch (Exception exc)
            {
                Log.Error($"Error during UserDataGetFilt:{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        #endregion Public Methods

        #region Protected Fields

        protected static MTAdminController dbController = null!;

        #endregion Protected Fields

        #region Private Fields

        private static JsonSerializerSettings? JSSettings;

        private static Logger Log = LogManager.GetCurrentClassLogger();

        private readonly IEmailSender _emailSender;

        /// <summary>
        /// Durata cache lunga IN SECONDI
        /// </summary>
        private int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata cache breve IN SECONDI
        /// </summary>
        private int cacheTtlShort = 60 * 1;

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        private IConnectionMultiplexer redisConn;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        private IDatabase redisDb = null!;

        /// <summary>
        /// Generatore random
        /// </summary>
        private Random rnd = new Random();

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Esegue flush memoria redis dato pattern
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        private async Task<bool> ExecFlushRedisPattern(RedisValue pattern)
        {
            bool answ = false;
            var listEndpoints = redisConn.GetEndPoints();
            foreach (var endPoint in listEndpoints)
            {
                //var server = redisConnAdmin.GetServer(listEndpoints[0]);
                var server = redisConn.GetServer(endPoint);
                if (server != null)
                {
                    var keyList = server.Keys(redisDb.Database, pattern);
                    foreach (var item in keyList)
                    {
                        await redisDb.KeyDeleteAsync(item);
                    }
                    answ = true;
                }
            }

            return answ;
        }

        /// <summary>
        /// Recupera UN SINGOLO VALORE dalla hash per un dato field
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        private string RedisHashGet(RedisKey hashKey, string hashField)
        {
            string answ = "";
            var hasVal = redisDb.HashExists(hashKey, hashField);
            if (hasVal)
            {
                answ = redisDb.HashGet(hashKey, hashField).ToString();
            }
            return answ;
        }

        /// <summary>
        /// Recupero HashSet redis come Dictionary
        /// </summary>
        /// <param name="hashKey"></param>
        private Dictionary<string, string> RedisHashGetDict(RedisKey hashKey)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            try
            {
                answ = redisDb
                            .HashGetAll(hashKey)
                            .ToDictionary(x => $"{x.Name}", x => $"{x.Value}");
            }
            catch (Exception exc)
            {
                Log.Info($"Errore RedisHashGetDict | hashKey: {hashKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera UN SINGOLO VALORE dalla hash per un dato field come INT
        /// </summary>
        /// <param name="hashKey">Redis Key for Hashlist</param>
        /// <param name="hashField">Requested key on list</param>
        /// <returns>Value as Int</returns>
        private int RedisHashGetInt(RedisKey hashKey, string hashField)
        {
            int result = 0;
            var rawRes = RedisHashGet(hashKey, hashField);
            if (!string.IsNullOrEmpty(rawRes))
            {
                int.TryParse($"{rawRes}", out result);
            }
            return result;
        }

        /// <summary>
        /// Aggiunta KVP in HashSet Redis
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        private bool RedisHashSet(RedisKey currKey, string hashField, string value)
        {
            bool fatto = false;
            try
            {
                // salvo!
                redisDb.HashSet(currKey, hashField, value);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in RedisHashSet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Salvataggio Dictionary come HashSet Redis
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="dict"></param>
        private bool RedisHashSetDict(RedisKey hashKey, Dictionary<string, string> dict)
        {
            bool fatto = false;
            try
            {
                HashEntry[] data2ins = new HashEntry[dict.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in dict)
                {
                    data2ins[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                // salvo!
                redisDb.HashSet(hashKey, data2ins);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in RedisHashSet | hashKey: {hashKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Salvataggio Dictionary come HashSet Redis
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="dict"></param>
        /// <param name="ttl"></param>
        private bool RedisHashSetDict(RedisKey hashKey, Dictionary<string, string> dict, TimeSpan ttl)
        {
            bool fatto = false;
            try
            {
                HashEntry[] data2ins = new HashEntry[dict.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in dict)
                {
                    data2ins[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                // salvo!
                redisDb.HashSet(hashKey, data2ins);
                redisDb.KeyExpire(hashKey, ttl);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in RedisHashSet | hashKey: {hashKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        #endregion Private Methods
    }
}