using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;
using WebDoorCreator.Core;
using WebDoorCreator.Data.DTO;

namespace WebDoorCreator.Data.Services
{
    public class QueueDataService : IDisposable
    {
        #region Public Constructors

        /// <summary>
        /// Init classe
        /// </summary>
        /// <param name="configuration"></param>
        /// <param name="emailSender"></param>
        /// <param name="redisConn"></param>
        public QueueDataService(IConfiguration configuration, IEmailSender emailSender, IConnectionMultiplexer redisConn)
        {
            Log.Info("QueueDataService starting...");
            _configuration = configuration;
            _emailSender = emailSender;
            // setup componenti REDIS
            var redConnString = _configuration.GetConnectionString("Redis");
            if (redConnString == null)
            {
                Log.Error("REDIS ConnString empty!");
            }
            else
            {
                this.redisConn = ConnectionMultiplexer.Connect(redConnString);
                redisDb = this.redisConn.GetDatabase();
            }
            // setup canali pub/sub
            CalcReqPipe = new MessagePipe(redisConn, Constants.CALC_REQ_QUEUE);
            CalcDonePipe = new MessagePipe(redisConn, Constants.CALC_DONE_QUEUE);
            // 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
            };
            // leggo conf speciali
            vetoRemoveProcSec = _configuration.GetValue<int>("RuntimeOpt:VetoRemoveProcessing");
            Log.Info("QueueDataService started!");
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Message pipe esecuzione elaborazione CAM --&gt; UI
        /// </summary>
        public MessagePipe CalcDonePipe { get; set; } = null!;

        /// <summary>
        /// Message pipe richieste elaborazione UI --&gt; CAM
        /// </summary>
        public MessagePipe CalcReqPipe { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            redisConn.Dispose();
        }

        /// <summary>
        /// Effettua pulizia cache dati calcolo porte
        /// </summary>
        /// <param name="DoorId"></param>
        /// <returns></returns>
        public async Task<bool> DoorCalcCacheCleanup()
        {
            /*----------------------------------
             * Recupero Rev corrente porta o inizializza cercando
             * - coda calcoli pending
             * - coda errori
             * - coda calcoli eseguiti
             *
             * se non trova riparte da 1
             *
             ----------------------------------*/
            bool fatto = false;
            int numDayPre = 30;
            if (!string.IsNullOrEmpty(_configuration.GetValue<string>("RuntimeOpt:MaxDayCalcCache")))
            {
                numDayPre = _configuration.GetValue<int>("RuntimeOpt:MaxDayCalcCache");
            }
            DateTime dtLimite = DateTime.Now.AddDays(-numDayPre);
            // recupero elenco di tutti i refresh porte...
            var refreshStatus = await DoorRefreshStatus();
            // ciclo su tutti e cerco quelli + vecchi di x giorni
            if (refreshStatus != null && refreshStatus.Count > 0)
            {
                DateTime dtCurr = DateTime.Now;
                foreach (var item in refreshStatus)
                {
                    // confronto data-ora della singola porta...
                    if (!string.IsNullOrEmpty(item.Key))
                    {
                        try
                        {
                            var rawDate = JsonConvert.DeserializeObject<DateTime>(item.Value);
                            // se esiste e SE è scaduto
                            if (rawDate > DateTime.MinValue && rawDate < dtLimite)
                            {
                                // cancello i dati!
                                await RequestProcessingRemove(item.Key);
                                await RequestErrRemove(item.Key);
                                await RequestDoneRemove(item.Key);
                                await DoorRefreshRemove(item.Key);
                            }
                        }
                        catch
                        { }
                    }
                }
            }
            await Task.Delay(1);
            return fatto;
        }

        /// <summary>
        /// Restitusice gli errori della porta in oggetto
        /// </summary>
        /// <param name="doorIdVers">formato DoorId:Versione</param>
        /// <returns></returns>
        public async Task<bool> DoorErrExists(string doorIdVers)
        {
            bool hasErr = false;
            // cerco versione errore x la porta...
            var doorData = doorIdVers.Split(":");
            if (doorData.Length == 2)
            {
                RedisKey currErrKey = new RedisKey($"{Constants.CALC_REQ_ERRS}");
                int currId = await RedHashGetInt(currErrKey, doorData[0]);
                hasErr = doorData[1] == $"{currId}";
            }
            return hasErr;
        }

        /// <summary>
        /// Restitusice gli errori della porta in oggetto
        /// </summary>
        /// <param name="doorIdVers">formato DoorId:Versione</param>
        /// <returns></returns>
        public async Task<string> DoorErrGet(string doorIdVers)
        {
            RedisKey currErrKey = new RedisKey($"{Constants.CALC_REQ_ERRS}:{doorIdVers}");
            RedisValue errVal = await redisDb.StringGetAsync(currErrKey);
            return errVal.ToString();
        }

        /// <summary>
        /// Cerca nelle esecuzioni ultimo SVG della porta e lo restituisce...
        /// </summary>
        /// <param name="DoorId"></param>
        /// <returns></returns>
        public async Task<string> DoorGetLastSvg(int DoorId)
        {
            string answ = "";
            // cerco in hashtable dei task eseguiti ultimo x porta corrente...
            var doorData = await RequestDoneGetSingle(DoorId);
            if (doorData != null && doorData.Count > 0)
            {
                var firstRecord = doorData.FirstOrDefault();
                // recupero da REDIS
                var currSvgKey = new RedisKey($"{Constants.CALC_REQ_SVG_CACHE}:{firstRecord.Key}:{firstRecord.Value}");
                var rawData = await redisDb.StringGetAsync(currSvgKey);
                if (rawData.HasValue)
                {
                    answ = $"{rawData}";
                }
            }
            // se non trovata --> missing!
            if (string.IsNullOrEmpty(answ))
            {
                // leggo missing standard...
                string missingFilePath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), "wwwroot/images", "MissingOrange.svg");
                if (File.Exists(missingFilePath))
                {
                    answ = File.ReadAllText(missingFilePath);
                }
            }
            return answ;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <returns></returns>
        public async Task<bool> DoorRefreshRemove(string doorId)
        {
            RedisKey currKey = new RedisKey(Constants.LAST_DOOR_REFR_KEY);
            bool fatto = await RedHashRemove(currKey, doorId);
            return fatto;
        }

        /// <summary>
        /// Get Door (last) Refresh status
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> DoorRefreshStatus()
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.LAST_DOOR_REFR_KEY);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAllAsync(currKey);
                foreach (var item in rawData)
                {
                    dictResult.Add($"{item.Name}", $"{item.Value}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DoorRefreshStatus | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Upsert info ultimo update di una porta
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<long> DoorRefreshUpsert(string doorId)
        {
            DateTime adesso = DateTime.Now;
            string sAdesso = JsonConvert.SerializeObject(adesso, JSSettings);
            RedisKey currKey = new RedisKey(Constants.LAST_DOOR_REFR_KEY);
            long numReq = await RedHashUpsert(currKey, doorId, sAdesso);
            return numReq;
        }

        /// <summary>
        /// Restitusice l'SVG della porta in oggetto
        /// </summary>
        /// <param name="doorIdVers">formato DoorId:Versione</param>
        /// <returns></returns>
        public async Task<string> DoorSvgGet(string doorIdVers)
        {
            RedisKey currSvgKey = new RedisKey($"{Constants.CALC_REQ_SVG_CACHE}:{doorIdVers}");
            RedisValue svgVal = await redisDb.StringGetAsync(currSvgKey);
            return svgVal.ToString();
        }

        /// <summary>
        /// Check if specified DoorId is in Template door list
        /// </summary>
        /// <param name="DoorId">Door Id to search</param>
        /// <returns>Found (true/false)</returns>
        public async Task<bool> DoorTplListContainsDoor(string DoorId)
        {
            bool found = false;
            RedisKey currKey = new RedisKey(Constants.DOOR_TPL_LIST);
            var rawVal = await RedHashGetString(currKey, DoorId);
            found = !string.IsNullOrEmpty(rawVal) && (rawVal == DoorId);
            return found;
        }

        /// <summary>
        /// Add specified DoorIdList to Template door list
        /// </summary>
        /// <param name="DoorIdList">List to add</param>
        /// <returns>Num of items in list</returns>
        public async Task<long> DoorTplListUpsert(List<string> DoorIdList)
        {
            RedisKey currKey = new RedisKey(Constants.DOOR_TPL_LIST);
            long numReq = 0;
            foreach (var item in DoorIdList)
            {
                numReq = await RedHashUpsert(currKey, item, item);
            }
            return numReq;
        }

        public async Task<bool> FlushRedisCache()
        {
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Constants.BASE_HASH}:Cache*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        /// <summary>
        /// Get # of calculation request done
        /// </summary>
        public async Task<long> NumRequestDone()
        {
            long numReq = 0;
            string source = "REDIS";
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_DONE);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = await redisDb.HashLengthAsync(currKey);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"NumRequestDone | {source} in: {ts.TotalMilliseconds} ms");
            return numReq;
        }

        /// <summary>
        /// Get # of calculation request with errors
        /// </summary>
        public async Task<long> NumRequestErrors()
        {
            long numReq = 0;
            string source = "REDIS";
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = await redisDb.HashLengthAsync(currKey);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"NumRequestErrors | {source} in: {ts.TotalMilliseconds} ms");
            return numReq;
        }

        /// <summary>
        /// Get # of calculation request pending
        /// </summary>
        public async Task<long> NumRequestPending()
        {
            long numReq = 0;
            string source = "REDIS";
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PEND);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = await redisDb.HashLengthAsync(currKey);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"NumRequestPending | {source} in: {ts.TotalMilliseconds} ms");
            return numReq;
        }

        /// <summary>
        /// Get # of calculation request processing
        /// </summary>
        public async Task<long> NumRequestProcessing()
        {
            long numReq = 0;
            string source = "REDIS";
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = await redisDb.HashLengthAsync(currKey);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"NumRequestProcessing | {source} in: {ts.TotalMilliseconds} ms");
            return numReq;
        }

        /// <summary>
        /// Get single hash record
        /// </summary>
        /// <param name="currKey">Redis Key for Hashlist</param>
        /// <param name="chiave">Requested key on list</param>
        /// <returns>Value as Int</returns>
        public async Task<int> RedHashGetInt(RedisKey currKey, string chiave)
        {
            int result = 0;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            var hasVal = await redisDb.HashExistsAsync(currKey, chiave);
            if (hasVal)
            {
                var rawRes = await redisDb.HashGetAsync(currKey, chiave);
                if (rawRes.HasValue)
                {
                    int.TryParse($"{rawRes}", out result);
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"RedHashGetInt | {currKey} | in: {ts.TotalMilliseconds} ms");
            return result;
        }

        /// <summary>
        /// Get single hash record
        /// </summary>
        /// <param name="currKey">Redis Key for Hashlist</param>
        /// <param name="chiave">Requested key on list</param>
        /// <returns>Value as string</returns>
        public async Task<string> RedHashGetString(RedisKey currKey, string chiave)
        {
            string result = "";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            var hasVal = await redisDb.HashExistsAsync(currKey, chiave);
            if (hasVal)
            {
                var rawRes = await redisDb.HashGetAsync(currKey, chiave);
                if (rawRes.HasValue)
                {
                    result = $"{rawRes}";
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"RedHashGetString | {currKey} | in: {ts.TotalMilliseconds} ms");
            return result;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <param name="currKey">Chiave redis della Hashlist</param>
        /// <param name="chiave">Chiave nella HashList</param>
        /// <returns>Esito rimozione</returns>
        public async Task<bool> RedHashRemove(RedisKey currKey, string chiave)
        {
            bool fatto = false;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            fatto = await redisDb.HashDeleteAsync(currKey, chiave);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"RedHashRemove | {currKey} | in: {ts.TotalMilliseconds} ms");
            return fatto;
        }

        /// <summary>
        /// Restitusice gli errori della porta in oggetto
        /// </summary>
        /// <param name="doorIdVers">formato DoorId:Versione</param>
        /// <returns></returns>
        public async Task<bool> RedisBulkDelHashByKey(int doorId)
        {
            await DoorRefreshRemove($"{doorId}");
            await RequestDoneRemove($"{doorId}");
            await RequestErrRemove($"{doorId}");
            await RequestPendingRemove($"{doorId}");
            await RequestProcessingRemove($"{doorId}");

            return true;
        }

        /// <summary>
        /// Get Queue request done
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> RequestDone()
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_DONE);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAllAsync(currKey);
                foreach (var item in rawData)
                {
                    dictResult.Add($"{item.Name}", $"{item.Value}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RequestDone | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Get LAST request done for DoorId
        /// </summary>
        /// <param name="DoorId"></param>
        /// <returns></returns>
        public async Task<Dictionary<string, string>> RequestDoneGetSingle(int DoorId)
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_DONE);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAsync(currKey, $"{DoorId}");
                if (rawData.HasValue)
                {
                    dictResult.Add($"{DoorId}", $"{rawData}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RequestDoneGetSingle | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<bool> RequestDoneRemove(string doorId)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_DONE);
            bool fatto = await RedHashRemove(currKey, doorId);
            return fatto;
        }

        /// <summary>
        /// Upsert for single hash record
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<long> RequestDoneUpsert(string doorId, string vers)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_DONE);
            long numReq = await RedHashUpsert(currKey, doorId, vers);
            return numReq;
        }

        /// <summary>
        /// Get Queue request with errors
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> RequestErr()
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAllAsync(currKey);
                foreach (var item in rawData)
                {
                    dictResult.Add($"{item.Name}", $"{item.Value}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RequestErr | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Rimuove hash record errori
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<bool> RequestErrRemove(string doorId)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            bool fatto = await RedHashRemove(currKey, doorId);
            return fatto;
        }

        /// <summary>
        /// Upsert record errori
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<long> RequestErrUpsert(string doorId, string vers)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            long numReq = await RedHashUpsert(currKey, doorId, vers);
            return numReq;
        }

        /// <summary>
        /// Get Queue request pending
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> RequestPending()
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PEND);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAllAsync(currKey);
                foreach (var item in rawData)
                {
                    dictResult.Add($"{item.Name}", $"{item.Value}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RequestPending | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<bool> RequestPendingRemove(string doorId)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PEND);
            bool fatto = await RedHashRemove(currKey, doorId);
            return fatto;
        }

        /// <summary>
        /// Upsert for single hash record
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<long> RequestPendingUpsert(string doorId, string vers)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PEND);
            long numReq = await RedHashUpsert(currKey, doorId, vers);
            return numReq;
        }

        /// <summary>
        /// Get Queue request processing
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> RequestProcessing()
        {
            string source = "REDIS";
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                var rawData = await redisDb.HashGetAllAsync(currKey);
                foreach (var item in rawData)
                {
                    dictResult.Add($"{item.Name}", $"{item.Value}");
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RequestProcessing | {source} in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        /// <summary>
        /// Remove for single hash record
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<bool> RequestProcessingRemove(string doorId)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            bool fatto = await RedHashRemove(currKey, doorId);
            return fatto;
        }

        /// <summary>
        /// Upsert for single hash record in processing
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<long> RequestProcessingUpsert(string doorId, string vers)
        {
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            long numReq = await RedHashUpsert(currKey, doorId, vers);
            // aggiungo cache veto rimozione da coda processing
            RedisKey currVetoKey = new RedisKey($"{Constants.CALC_REQ_PROC}:{doorId}");
            await redisDb.StringSetAsync(currVetoKey, vers, TimeSpan.FromSeconds(vetoRemoveProcSec));
            return numReq;
        }

        /// <summary>
        /// Reset to queue request all processing/processed data
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<bool> ResetQueue()
        {
            bool fatto = false;
            await Task.Delay(1);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            // cerco le richieste processing
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            var rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                await RequestPendingUpsert(item.Name!, item.Value!);
                await RequestProcessingRemove(item.Name!);
                fatto = true;
            }
            // cerco le richieste con errori
            currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                await RequestPendingUpsert(item.Name!, item.Value!);
                await RequestErrRemove(item.Name!);
                fatto = true;
            }
            // cerco le richieste processed
            currKey = new RedisKey(Constants.CALC_REQ_DONE);
            rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                await RequestPendingUpsert(item.Name!, item.Value!);
                await RequestDoneRemove(item.Name!);
                fatto = true;
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ResetQueue | REDIS EXEC in: {ts.TotalMilliseconds} ms");
            return fatto;
        }

        /// <summary>
        /// Reset to queue request for specified DoorIdList
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<List<string>> ResetQueueByDoorList(List<string> DoorIdList)
        {
            int num2proc = DoorIdList.Count;
            List<string> listDone = new List<string>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            // cerco le richieste processing
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            var rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                // se è nell'elenco...
                if (DoorIdList.Contains(item.Name.ToString()))
                {
                    await RequestPendingUpsert(item.Name!, item.Value!);
                    await RequestProcessingRemove(item.Name!);
                    listDone.Add(item.Name.ToString());
                }
            }
            // cerco le richieste con errori
            currKey = new RedisKey(Constants.CALC_REQ_ERRS);
            rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                // se è nell'elenco...
                if (DoorIdList.Contains(item.Name.ToString()))
                {
                    await RequestPendingUpsert(item.Name!, item.Value!);
                    await RequestErrRemove(item.Name!);
                    listDone.Add(item.Name.ToString());
                }
            }
            // cerco le richieste processed
            currKey = new RedisKey(Constants.CALC_REQ_DONE);
            rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                // se è nell'elenco...
                if (DoorIdList.Contains(item.Name.ToString()))
                {
                    await RequestPendingUpsert(item.Name!, item.Value!);
                    await RequestDoneRemove(item.Name!);
                    listDone.Add(item.Name.ToString());
                }
            }
#if false
            // calcolo eventuali porte NON ancora richieste...
            foreach (var item in listDone)
            {
                DoorIdList.Remove(item);
            }
#endif
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ResetQueueByDoorList | doors #: {num2proc} --> {DoorIdList.Count} | EXEC in: {ts.TotalMilliseconds} ms");
            return DoorIdList;
        }

        /// <summary>
        /// Reset to queue request all processing stuck data (veto check)
        /// </summary>
        /// <returns>Boolean, executed</returns>
        public async Task<bool> ResetQueueProcessing()
        {
            bool fatto = false;
            await Task.Delay(1);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            // cerco le richieste processing
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PROC);
            RedisKey currVetoKey = new RedisKey($"{Constants.CALC_REQ_PROC}:0");
            var rawData = await redisDb.HashGetAllAsync(currKey);
            foreach (var item in rawData)
            {
                // verifico SE siano senza veto rimozione...
                currVetoKey = new RedisKey($"{Constants.CALC_REQ_PROC}:{item.Name}");
                var redisVal = await redisDb.StringGetAsync(currVetoKey);
                if (!redisVal.HasValue)
                {
                    await RequestPendingUpsert(item.Name!, item.Value!);
                    await RequestProcessingRemove(item.Name!);
                    fatto = true;
                }
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ResetQueueProcessing | REDIS EXEC in: {ts.TotalMilliseconds} ms");
            return fatto;
        }

        /// <summary>
        /// Salvo elenco risultati elaborazioni (modalità boolean di esecuzione corretta)
        /// </summary>
        /// <param name="calcResults">Risultati elaborazioni in formato CalcResultDTO</param>
        /// <returns></returns>
        public async Task<bool> SaveProcessingResult(List<CalcResultDTO> calcResults)
        {
            bool answ = true;
            if (calcResults != null && calcResults.Count > 0)
            {
                string sDoorId = "";
                string sCurrVers = "";
                bool doorIsTpl = false;
                foreach (var calcTask in calcResults)
                {
                    RedisKey currSvgKey = new RedisKey("");
                    var doorData = calcTask.DoorIdVers.Split(".");
                    sDoorId = doorData.Length > 0 ? doorData[0] : "";
                    sCurrVers = doorData.Length > 0 ? doorData[1] : "";
                    // verifico se sia template --> durata indefinita...
                    doorIsTpl = await DoorTplListContainsDoor(sDoorId);
                    // se valido salvo SVG...
                    if (calcTask.Validated)
                    {
                        // salvo in area REDIS
                        currSvgKey = new RedisKey($"{Constants.CALC_REQ_SVG_CACHE}:{sDoorId}:{sCurrVers}");
                        // se template --> no scadenza
                        if (doorIsTpl)
                        {
                            await redisDb.StringSetAsync(currSvgKey, calcTask.SvgGen);
                        }
                        else
                        {
                            await redisDb.StringSetAsync(currSvgKey, calcTask.SvgGen, WeekLongCache);
                        }
                        // elimino dalle code proc/err
                        await RequestProcessingRemove(sDoorId);
                        await RequestErrRemove(sDoorId);
                        // metto in coda done
                        await RequestDoneUpsert(sDoorId, sCurrVers);
                    }
                    // altrimenti salvo errore e metto in coda errori
                    else
                    {
                        // salvo in area REDIS
                        currSvgKey = new RedisKey($"{Constants.CALC_REQ_ERRS}:{sDoorId}:{sCurrVers}");
                        if (doorIsTpl)
                        {
                            await redisDb.StringSetAsync(currSvgKey, calcTask.ErrorMsg);
                        }
                        else
                        {
                            await redisDb.StringSetAsync(currSvgKey, calcTask.ErrorMsg, WeekLongCache);
                        }
                        // elimino dalle code proc/done
                        await RequestProcessingRemove(sDoorId);
                        await RequestDoneRemove(sDoorId);
                        // metto in coda err
                        await RequestErrUpsert(sDoorId, sCurrVers);
                    }
                    // invio il messaggio di ritorno...
                    CalcDonePipe.saveAndSendMessage(Constants.LAST_CALC_DONE_KEY, calcTask.DoorIdVers);
                }
            }
            else
            {
                await Task.Delay(1);
            }
            return answ;
        }

        /// <summary>
        /// Invio richiesta di calcolo per la porta indicata, dato il suo DDF
        /// </summary>
        /// <param name="DoorId"></param>
        /// <param name="FullDDF">Contenuto completo del DDF</param>
        /// <returns>indice/versione del calcolo DDF</returns>
        public async Task<int> SendCalcReq(int DoorId, string FullDDF)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string sDoorId = $"{DoorId}";
            int currVers = await DoorCalcRev(sDoorId);
            string sCurrVers = $"{currVers}";
            // elimino da code errori (SE fosse presente)
            await RequestErrRemove(sDoorId);

            // salvo nell'archivio REDIS delle porte il DDF corrente (key=doorId.versNumb), potrebbe
            // venire buono anche x eventuale UNDO...
            RedisKey currDdfKey = new RedisKey($"{Constants.CALC_REQ_DDF_CACHE}:{sDoorId}:{sCurrVers}");
            await redisDb.StringSetAsync(currDdfKey, FullDDF, WeekLongCache);

            // invio sul canale dei messaggi il numero di items in coda attuali x chiedere esecuzione...
            long numPending = await NumRequestPending();
            bool answ = CalcReqPipe.saveAndSendMessage(Constants.LAST_CALC_REQ_KEY, $"{numPending}");

            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"SendCalcReq | DoorId: {DoorId} enqueued in: {ts.TotalMilliseconds} ms");
            return currVers;
        }

        /// <summary>
        /// Get Queue request pending, removing from queue and putting on processing queue
        /// </summary>
        /// <returns>Dictionary of DoorId, saveVersNumb</returns>
        public async Task<Dictionary<string, string>> TakeProcessingItems(int numItems)
        {
            int maxTake = Math.Min(10, numItems);
            long numReq = 0;
            Dictionary<string, string> dictResult = new Dictionary<string, string>();
            // cerco da cache
            RedisKey currKey = new RedisKey(Constants.CALC_REQ_PEND);
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            // calcolo il totale delle richieste pending
            numReq = redisDb.HashLength(currKey);
            if (numReq > 0)
            {
                // per prima cosa aspetto che NON sia locked la coda...
                while (queueLock)
                {
                    Thread.Sleep(rnd.Next(1, 20));
                }
                // blocco
                queueLock = true;
                var rawData = await redisDb.HashGetAllAsync(currKey);
                // sposto fino a concorrenza...
                foreach (var item in rawData)
                {
                    // per prima cosa tolgo da item richiesti e metto in processing
                    await RequestPendingRemove(item.Name!);
                    await RequestProcessingUpsert(item.Name!, item.Value!);
                    maxTake--;
                    // recupero il DDF...
                    RedisKey currDdfKey = new RedisKey($"{Constants.CALC_REQ_DDF_CACHE}:{item.Name}:{item.Value}");
                    var rawDDF = await redisDb.StringGetAsync(currDdfKey);
                    dictResult.Add($"{item.Name}.{item.Value}", $"{rawDDF}");
                    if (maxTake <= 0)
                    {
                        break;
                    }
                }
                // sblocco
                queueLock = false;
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"TakeProcessingItems | REDIS in: {ts.TotalMilliseconds} ms");
            return dictResult;
        }

        #endregion Public Methods

        #region Protected Fields

        protected const string rKeyCalcOreFase = "Check:OreFasi";
        protected const string rKeyFasiAct = "Check:FasiAct";
        protected const string rKeyProjAct = "Check:ProjAct";

        /// <summary>
        /// TTL da 1 min x cache Redis
        /// </summary>
        protected const int shortTTL = 60 * 5;

        protected int idxSim = 0;
        protected Random rnd = new Random();

        #endregion Protected Fields

        #region Protected Properties

        protected static bool queueLock { get; set; } = false;

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Recupera revisione corrente della porta o inizializza
        /// </summary>
        /// <param name="DoorId"></param>
        /// <returns></returns>
        protected async Task<int> DoorCalcRev(string sDoorId)
        {
            /*----------------------------------
             * Recupero Rev corrente porta o inizializza cercando
             * - coda calcoli pending
             * - coda errori
             * - coda calcoli eseguiti
             *
             * se non trova riparte da 1
             *
             ----------------------------------*/
            int currVers = 1;
            string sCurrVers = "";
            // per prima cosa controllo se ho GIA' in coda qualcosa come richieste
            if (await NumRequestPending() > 0)
            {
                var currPending = await RequestPending();
                if (currPending != null)
                {
                    if (currPending.ContainsKey(sDoorId))
                    {
                        sCurrVers = currPending[sDoorId];
                        int.TryParse(sCurrVers, out currVers);
                        currVers++;
                    }
                }
            }
            // cerco coda errori
            if (await NumRequestErrors() > 0)
            {
                var currErrors = await RequestErr();
                if (currErrors != null)
                {
                    if (currErrors.ContainsKey(sDoorId))
                    {
                        sCurrVers = currErrors[sDoorId];
                        int.TryParse(sCurrVers, out currVers);
                        currVers++;
                    }
                }
            }
            // cerco coda task completati
            if (await NumRequestDone() > 0)
            {
                var currDone = await RequestDone();
                if (currDone != null)
                {
                    if (currDone.ContainsKey(sDoorId))
                    {
                        sCurrVers = currDone[sDoorId];
                        int.TryParse(sCurrVers, out currVers);
                        currVers++;
                    }
                }
            }
            // inserisco in coda x calcoli
            await RequestPendingUpsert(sDoorId, $"{currVers}");
            // metto in coda "last calc" la porta corrente x pulizia successiva
            await DoorRefreshUpsert(sDoorId);
            return currVers;
        }

        /// <summary>
        /// Recupero chiave da redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <returns></returns>
        protected async Task<string> getRSV(string rKey)
        {
            string answ = "";
            var rawData = await redisDb.StringGetAsync(rKey);
            if (rawData.HasValue)
            {
                answ = $"{rawData}";
            }
            return answ;
        }

        /// <summary>
        /// Effettua upsert in HasList redis
        /// </summary>
        /// <param name="currKey">Chiave redis della Hashlist</param>
        /// <param name="chiave">Chiave nella HashList</param>
        /// <param name="valore">Valore da salvare</param>
        /// <returns>Num record nella HashList</returns>
        protected async Task<long> RedHashUpsert(RedisKey currKey, string chiave, string valore)
        {
            long numReq = 0;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            await redisDb.HashSetAsync(currKey, chiave, valore);
            numReq = await redisDb.HashLengthAsync(currKey);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"RedHashUpsert | {currKey} | in: {ts.TotalMilliseconds} ms");
            return numReq;
        }

        /// <summary>
        /// Salvataggio chiave in redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <param name="rVal"></param>
        /// <param name="ttlSec"></param>
        /// <returns></returns>
        protected async Task<bool> setRSV(string rKey, string rVal, int ttlSec)
        {
            bool fatto = false;
            await redisDb.StringSetAsync(rKey, rVal, TimeSpan.FromSeconds(ttlSec));
            fatto = true;
            return fatto;
        }

        /// <summary>
        /// Salvataggio chiave in redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <param name="rValInt"></param>
        /// <param name="ttlSec"></param>
        /// <returns></returns>
        protected async Task<bool> setRSV(string rKey, int rValInt, int ttlSec)
        {
            bool fatto = false;
            await redisDb.StringSetAsync(rKey, rValInt, TimeSpan.FromSeconds(ttlSec));
            fatto = true;
            return fatto;
        }

        /// <summary>
        /// Registra in cache chiave se non fosse già in elenco
        /// </summary>
        /// <param name="newKey"></param>
        protected void trackCache(string newKey)
        {
            if (!cachedDataList.Contains(newKey))
            {
                cachedDataList.Add(newKey);
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static IConfiguration _configuration = null!;
        private static JsonSerializerSettings? JSSettings;
        private static Logger Log = LogManager.GetCurrentClassLogger();
        private readonly IEmailSender _emailSender;

        /// <summary>
        /// Elenco obj in cache
        /// </summary>
        private List<string> cachedDataList = new List<string>();

        /// <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 ConnectionMultiplexer redisConn = null!;

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

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Durata cache di 24h
        /// </summary>
        private TimeSpan DayLongCache
        {
            get => TimeSpan.FromHours(24);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan FastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan LongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache di 24h
        /// </summary>
        private TimeSpan MonthLongCache
        {
            get => TimeSpan.FromDays(30);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan UltraLongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * 10 * rnd.Next(900, 1100) / 1000);
        }

        private int vetoRemoveProcSec { get; set; } = 10;

        /// <summary>
        /// Durata cache di 1 settimana
        /// </summary>
        private TimeSpan WeekLongCache
        {
            get => TimeSpan.FromHours(24 * 7 * rnd.Next(1000, 1100) / 1000);
        }

        #endregion Private Properties

        #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);
                    }
                    // brutalmente rimuovo intero contenuto DB... DANGER
                    //await server.FlushDatabaseAsync();
                    answ = true;
                }
            }

            return answ;
        }

        #endregion Private Methods
    }
}