using Core;
using Core.DTO;
using LiMan.DB;
using LiMan.DB.DBModels;
using LiMan.DB.DTO;
using LiMan.DB.Services;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Microsoft.Win32;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using StackExchange.Redis.Extensions.Core.Abstractions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Core.Enum;

namespace LiMan.APi.Data
{
    /// <summary>
    /// Classe astrazione accesso dati
    /// </summary>
    public class ApiDataService : CommonDataServices
    {
        #region Public Constructors

        /// <summary>
        /// Init classe
        /// </summary>
        /// <param name="configuration"></param>
        /// <param name="logger"></param>
        /// <param name="emailSender"></param>
        /// <param name="redisCacheClient"></param>
        /// <param name="redisConnMult"></param>
        public ApiDataService(IConfiguration configuration, ILogger<ApiDataService> logger, IEmailSender emailSender, IRedisCacheClient redisCacheClient, IConnectionMultiplexer redisConnMult) : base(configuration, redisConnMult, emailSender)
        {
            _configuration = configuration;
#if false
            _logger = logger;
            _emailSender = emailSender;
            _redisCacheClient = redisCacheClient;
            //this.distributedCache = distributedCache;
#endif

#if false
            // 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
            };

            // conf messagepipe: setup canali pub/sub
            EnrollMessPipe = new MessagePipe(redisConn, Const.ENRL_MSG_PIPE);
            TaskMessPipe = new MessagePipe(redisConn, Const.TASK_MSG_PIPE);
            UpdActMessPipe = new MessagePipe(redisConn, Const.UPDT_MSG_PIPE);

            // conf DB
            string connStrDB = _configuration.GetConnectionString("LiMan.DB");
            if (string.IsNullOrEmpty(connStrDB))
            {
                Log.Error("ConnString empty!");
            }
            else
            {
                dbController = new LiMan.DB.Controllers.DbController(configuration);
                Log.Info("DbController OK");
            }
#endif
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Recupero da Redis info x elenco info dettaglio di un SINGOLO EgwACC
        /// </summary>
        /// <param name="CodImp">Cod univoco impegno</param>
        public Dictionary<string, string> EgwAccDictDetailGet(string CodImp)
        {
            RedisKey reqKey = (RedisKey)$"{rKeyEACCDetail}:{CodImp}";
            Dictionary<string, string> answ = redisHashDictGet(reqKey);
            return answ;
        }

        /// <summary>
        /// Salvataggio in Redis info di dettaglio di un EgwACC
        /// </summary>
        /// <param name="CodImp">Cod univoco impegno</param>
        /// <param name="Payload"></param>
        public void EgwAccDictDetailSet(string CodImp, Dictionary<string, string> Payload)
        {
            // salvo in hash info CodImp + versione
            RedisKey reqKey = (RedisKey)$"{rKeyEACCDetail}:{CodImp}";
            // imposto scadenza a 60gg...
            double scadenza = 60 * 24 * 60;
            redisHashDictSet(reqKey, Payload, scadenza);
#if false
            // salvo in altra hash (con key da CodImp) le info specifiche ricevute
            foreach (var res in Payload)
            {
                redisHashKeySet(reqKey, res.Key, res.Value, scadenza);
            }
#endif
            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
        }

        /// <summary>
        /// recupero da Redis info x elenco EgwACC secondo key richiesta
        /// </summary>
        /// <param name="KeyName">Chiave Richiesta (es Vers, Last, ...)</param>
        public Dictionary<string, string> EgwAccDictValGet(string KeyName)
        {
            RedisKey reqKey = (RedisKey)$"{rKeyEACCList}:{KeyName}";
            Dictionary<string, string> answ = redisHashDictGet(reqKey);
            return answ;
        }

        /// <summary>
        /// Salvataggio in Redis info x elenco EgwACC sul campo
        /// </summary>
        /// <param name="CodImp">Cod univoco impegno</param>
        /// <param name="KeyName">Chiave salvata (es Vers, Last, ...)</param>
        /// <param name="Value">Valore serializzato</param>
        public void EgwAccDictValSet(string CodImp, string KeyName, string Value)
        {
            // salvo in hash info CodImp + versione
            RedisKey reqKey = (RedisKey)$"{rKeyEACCList}:{KeyName}";
            // salvo in altra hash (con key da CodImp) le info specifiche ricevute
            redisHashKeySet(reqKey, CodImp, Value);
            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
        }

        /// <summary>
        /// Crea record richiesta enroll (univoco rispetto richieste correnti)
        /// </summary>
        /// <param name="MachineInfo">Dati da associare alla richeista</param>
        /// <returns></returns>
        public async Task<EnrollRequestModel> EnrollReqCreate(Dictionary<string, string> MachineInfo)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            // svuoto elenco richieste scaduteù
            var cleanDone = await EnrollReqPurgeInvalid();
            // prendo elenco attive x evitare duplicazioni codici TOTP...
            var resList = await EnrollReqGetActive();
            int totpCode = rnd.Next(1, 100000000);
            // verifico che non sia preesistente...
            if (resList.Count > 0)
            {
                // cerco se fosse già presente...
                while (resList.Where(x => x.Passcode == totpCode).Any())
                {
                    // genero nuovo...
                    await Task.Delay(rnd.Next(50));
                    totpCode = rnd.Next(1, 100000000);
                }
            }

            // serializzo i dati della richiesta..
            string reqPayload = JsonConvert.SerializeObject(MachineInfo);

            // preparo il record da registrare...
            EnrollRequestModel newReq = new EnrollRequestModel()
            {
                DtReq = DateTime.Now,
                Passcode = totpCode,
                ReqPayload = reqPayload
            };

            var dbRec = await EnrollReqUpsert(newReq);
            sw.Stop();
            TimeSpan ts = sw.Elapsed;
            Log.Trace($"Effettuata EnrollReqCreate: {ts.TotalMilliseconds} ms");

            // invio string in messagepipe x forzare refresh...
            EnrollMessPipe.sendMessage("NewEnrollReq");

            // restituisce record
            return dbRec;
        }

        /// <summary>
        /// Esegue aggiunta file dato ticket e list uploadResult
        /// </summary>
        /// <param name="idxTicket">Identificativo del ticket</param>
        /// <param name="baseDir">Directory di salvataggio dei file</param>
        /// <param name="fileUploaded">lista risultati della funzione di upload</param>
        /// <returns></returns>
        public async Task<bool> FileAdd(int idxTicket, string baseDir, List<UploadResult> fileUploaded)
        {
            bool fatto = false;
            // inserimento!
            Stopwatch sw = new Stopwatch();
            sw.Start();
            fatto = dbController.FileAdd(idxTicket, baseDir, fileUploaded);
            sw.Stop();
            TimeSpan ts = sw.Elapsed;
            Log.Trace($"Effettuata inserimento con FileAdd: {ts.TotalMilliseconds} ms");

            // restituisce elenco
            return await Task.FromResult(fatto);
        }


        /// <summary>
        /// Effettua registrazione chiamata verificando se vada messa sul DB o in redis...
        /// </summary>
        /// <param name="codInst"></param>
        /// <param name="codApp"></param>
        /// <param name="targetUrl"></param>
        public async Task<bool> recordCall(string codInst, string codApp, string targetUrl)
        {
            bool fatto = false;

            // in primis recupero statistiche (e nel mentre eventualmente salvo su DB)
            SampleStats currStats = await getCurrStats();

            // preparo chiave x dato da loggare
            string currKey = $"{rKeySampleVars}:{codInst}:{codApp}:{targetUrl}";

            // verifico presenza contatore corrente altrimenti aggiungo e salvo...
            if (!currStats.VList.Contains(currKey))
            {
                currStats.VList.Add(currKey);
                // salvo!
                await setCurrStats(currStats);
            }
            // incremento valore contatore corrente
            await redCountIncr(currKey);

            return fatto;
        }

        /// <summary>
        /// Effettua registrazione da codice chiave...
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="targetUrl"></param>
        public async Task<bool> recordCall(string chiave, string targetUrl)
        {
            bool fatto = false;
            // valutare se cache key --> lic...
            if (!string.IsNullOrEmpty(chiave))
            {
                var currLic = await LicenzaByMasterKey(chiave);
                if (currLic != null)
                {
                    fatto = await recordCall(currLic.CodInst, currLic.CodApp, targetUrl);
                }
            }
            return fatto;
        }

        /// <summary>
        /// Elenco Release dato Applicativo
        /// </summary>
        /// <param name="CodApp">Codice Applicazione</param>
        /// <returns></returns>
        public async Task<List<ReleaseDTO>> ReleaseDtoGetByApp(string CodApp)
        {
            await Task.Delay(1);
            List<ReleaseDTO> dbResult = new List<ReleaseDTO>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            dbResult = dbController.ReleaseDtoGetByApp(CodApp);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata lettura da DB per ReleaseDtoGetByApp | {CodApp} | {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco Release dato Applicativo + versione minima
        /// </summary>
        /// <param name="CodApp">Codice Applicazione</param>
        /// <param name="VersMin">Versione minima richiesta</param>
        /// <returns></returns>
        public async Task<List<ReleaseDTO>> ReleaseDtoGetByAppVers(string CodApp, string VersMin)
        {
            await Task.Delay(1);
            List<ReleaseDTO> dbResult = new List<ReleaseDTO>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            dbResult = dbController.ReleaseDtoGetByAppVers(CodApp, VersMin);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata lettura da DB per ReleaseDtoGetByAppVers | {CodApp} | vers >= {VersMin} | {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco Release dato Applicativo + versione minima
        /// </summary>
        /// <param name="CodApp">Codice Applicazione</param>
        /// <param name="VersMin">Versione minima richiesta</param>
        /// <param name="VersMax">Versione massima consentita</param>
        /// <returns></returns>
        public async Task<List<ReleaseDTO>> ReleaseGetByAppVersLimit(string CodApp, string VersMin, string VersMax)
        {
            await Task.Delay(1);
            List<ReleaseDTO> dbResult = new List<ReleaseDTO>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            dbResult = dbController.ReleaseDtoGetByAppVersLimit(CodApp, VersMin, VersMax);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata lettura da DB per ReleaseDtoGetByAppVersLimit | {CodApp} | vers >= {VersMin} | {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco di TUTTE le release CRITICAL come dizionario CodApp - release
        /// </summary>
        /// <returns></returns>
        public async Task<Dictionary<string, ReleaseDTO>> ReleaseGetCritical()
        {
            Dictionary<string, ReleaseDTO> dbResult = new Dictionary<string, ReleaseDTO>();
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string cacheKey = $"{rKeyAttivByLic}:AppReleases:CRITICAL";
            string source = "REDIS";
            trackCache(cacheKey);
            string rawData = await getRSV(cacheKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                dbResult = JsonConvert.DeserializeObject<Dictionary<string, ReleaseDTO>>(rawData);
            }
            else
            {
                source = "DB";
                dbResult = dbController.ReleaseGetCritical();
                rawData = JsonConvert.SerializeObject(dbResult);
                await setRSV(cacheKey, rawData, redCacheTtlFast);
            }
            sw.Stop();
            Log.Trace($"Effettuata lettura da DB per ReleaseGetCritical | {source} | # found: {dbResult.Count} | {sw.ElapsedMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Registro su DB le statistiche delle chiavi in elenco, resettando i vari contatori quando res
        /// </summary>
        /// <param name="keyList">Elenco key nel formato {rKeySampleVars}:{codInst}:{codApp}:{targetUrl}</param>
        public async Task<bool> saveStatsToDb(List<string> keyList)
        {
            bool fatto = false;
            // ciclo x eseguire 1:1
            foreach (var item in keyList)
            {
                // recupero counter...
                var currCount = await redCount(item);
                // scompongo key... senza url di base
                string[] valStr = item.Replace($"{rKeySampleVars}:", "").Split(":");
                if (valStr.Length > 2)
                {
                    LogCallModel newRec = new LogCallModel()
                    {
                        CodInst = valStr[0],
                        CodApp = valStr[1],
                        TargetUrl = item.Replace($"{rKeySampleVars}:", "").Replace($"{valStr[0]}:{valStr[1]}:", ""),
                        DataRif = DateTime.Now,
                        NumCall = currCount
                    };
                    fatto = await dbController.LogCallUpsert(newRec);
                    if (fatto)
                    {
                        await redCountClear(item);
                    }
                }
            }
            return fatto;
        }

        /// <summary>
        /// Restituisce i task associati ad un dato EgwACC
        /// </summary>
        /// <param name="CodImp"></param>
        /// <returns></returns>
        public Dictionary<string, string> TaskListGet(string CodImp)
        {
            RedisKey currKey = (RedisKey)$"{rKeyTaskReq}:{CodImp}";
            Dictionary<string, string> answ = redisHashDictGet(currKey);
            return answ;
        }

        /// <summary>
        /// Resetta i task di un dato EgwACC
        /// </summary>
        /// <param name="CodImp"></param>
        /// <returns></returns>
        public Dictionary<string, string> TaskListReset(string CodImp)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // svuoto dizoinari specifici
            bool ok01 = redisHashDictDelete((RedisKey)$"{rKeyTaskReq}:{CodImp}");
            bool ok02 = redisHashDictDelete((RedisKey)$"{rKeyTaskRun}:{CodImp}");
            bool ok03 = redisHashDictDelete((RedisKey)$"{rKeyTaskDone}:{CodImp}");
            // svuoto in elenco task x imp...
            redisHashKeyDelete((RedisKey)$"{rKeyTaskReq}List", CodImp);
            redisHashKeyDelete((RedisKey)$"{rKeyTaskRun}List", CodImp);
            redisHashKeyDelete((RedisKey)$"{rKeyTaskDone}List", CodImp);
            // leggo remaining x verificare sia ok..
            var dictReq = new Dictionary<string, string>(redisHashDictGet((RedisKey)$"{rKeyTaskReq}:{CodImp}"));
            var dictRun = new Dictionary<string, string>(redisHashDictGet((RedisKey)$"{rKeyTaskRun}:{CodImp}"));
            var dictDone = new Dictionary<string, string>(redisHashDictGet((RedisKey)$"{rKeyTaskDone}:{CodImp}"));
            answ = new Dictionary<string, string>(dictReq);
            foreach (var item in dictRun)
            {
                answ.TryAdd(item.Key, item.Value);
            }
            foreach (var item in dictDone)
            {
                answ.TryAdd(item.Key, item.Value);
            }
            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
            return answ;
        }

        /// <summary>
        /// Salva il risultato dell'esecuzione dei task effettuata
        /// </summary>
        /// <param name="CodImp"></param>
        /// <param name="DataPayload"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int TaskSetDone(string CodImp, Dictionary<string, string> DataPayload)
        {
            int done = 0;
            // imposto scadenza a 30gg...
            double scadenza = 60 * 24 * 30;
            // upsert per ogni singolo record + rimozione da running
            foreach (var res in DataPayload)
            {
                bool answ = redisHashKeySet((RedisKey)$"{rKeyTaskDone}:{CodImp}", res.Key, res.Value, scadenza);
                redisHashKeyDelete((RedisKey)$"{rKeyTaskRun}:{CodImp}", res.Key);
                // sistemo hashset...
                redisHashKeySet((RedisKey)$"{rKeyTaskDone}List", CodImp, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}");
                redisHashKeyDelete((RedisKey)$"{rKeyTaskRun}List", CodImp);
                // segnalo fatto
                done += answ ? 1 : 0;
            }
            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
            return done;
        }

        /// <summary>
        /// Salva come running i task indicati (togliendo da richiesti)
        /// </summary>
        /// <param name="CodImp"></param>
        /// <param name="DataPayload"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int TaskSetRunning(string CodImp, Dictionary<string, string> DataPayload)
        {
            int done = 0;
            // imposto scadenza a 30gg...
            double scadenza = 60 * 24 * 30;
            // upsert per ogni singolo record + rimozione da richiesti
            foreach (var res in DataPayload)
            {
                // sposto il valore in key
                bool answ = redisHashKeySet((RedisKey)$"{rKeyTaskRun}:{CodImp}", res.Key, res.Value, scadenza);
                redisHashKeyDelete((RedisKey)$"{rKeyTaskReq}:{CodImp}", res.Key);

                // sistemo list task...
                redisHashKeySet((RedisKey)$"{rKeyTaskRun}List", CodImp, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}");
                redisHashKeyDelete((RedisKey)$"{rKeyTaskReq}List", CodImp);
                // segnalo fatto
                done += answ ? 1 : 0;
            }
            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
            return done;
        }

        /// <summary>
        /// Esegue aggiunta Ticket richiesto + restitusice aperti x cliente
        /// </summary>
        /// <param name="currRequest"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<bool> TicketAdd(SupportRequest currRequest)
        {
            bool fatto = false;
            // inserimento!
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            fatto = dbController.TicketAddNew(currRequest);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata inserimento con TicketAdd: {ts.TotalMilliseconds} ms");

            // restituisce elenco
            return await Task.FromResult(fatto);
        }

        /// <summary>
        /// Elenco ticket dato cliente + App + MasterKey
        /// </summary>
        /// <param name="CodInst"></param>
        /// <param name="CodApp"></param>
        /// <param name="MasterKey"></param>
        /// <param name="numRec"></param>
        /// <returns></returns>
        public async Task<List<TicketDTO>> TicketByCliente(string CodInst, string CodApp, string MasterKey, int numRec = 1000)
        {
            List<TicketDTO> dbResult = new List<TicketDTO>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();

            dbResult = dbController.TicketGetFilt(false, TipologiaTicket.ND, CodApp, CodInst, MasterKey, numRec);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata lettura da DB per TicketByCliente: {ts.TotalMilliseconds} ms");

            return await Task.FromResult(dbResult);
        }

        /// <summary>
        /// Salva ultima dataora di comunicazione con un updater
        /// </summary>
        /// <param name="CodImp"></param>
        /// <param name="CodAction"></param>
        /// <returns></returns>
        public int UpdaterRecordAction(string CodImp, string CodAction)
        {
            int done = 0;

            // salvo info sul TIPO di chiamata
            bool answ = redisHashKeyIncDecBy((RedisKey)$"{rKeyUpdLastAct}:{CodImp}", CodAction, 1);

            // registro ultima chiamata
            redisHashKeySet((RedisKey)$"{rKeyUpdLastAct}List", CodImp, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}");

            // invio string in messagepipe x forzare refresh...
            UpdActMessPipe.sendMessage(CodImp);
            // scambio tipo di pipe messaggi (update e non task)
            //TaskMessPipe.sendMessage(CodImp);
            return done;
        }

        #endregion Public Methods

        #region Protected Fields

        protected new static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Protected Fields

        #region Protected Methods

        /// <summary>
        /// Recupera statistiche correnti
        /// </summary>
        /// <returns></returns>
        protected async Task<SampleStats> getCurrStats()
        {
            DateTime adesso = DateTime.Now;
            SampleStats answ = new SampleStats()
            {
                Name = "ApiStats"
            };
            // in primis check data/ora prima/ultima scrittura del set... (2 date, lista chiavi gestite)
            string rawData = await getRSV(rKeySampleStats);
            if (rawData != null)
            {
                answ = JsonConvert.DeserializeObject<SampleStats>(rawData);
                // aggiorno ultimo controllo e salvo...
                answ.DtLast = adesso;
                // salvo!
                await setCurrStats(answ);
            }
            // controllo se scadute...
            if (adesso.Subtract(answ.DtFirst).TotalMinutes > 60)
            {
                // se scaduto --> registrazione set sul DB (async), resettando i vari contatori...
                bool salvato = await saveStatsToDb(answ.VList);
                // inizio NUOVO set vuoto con record corrente
                answ = new SampleStats()
                {
                    Name = "ApiStats"
                };
                // salvo!
                await setCurrStats(answ);
            }
            // restituisco record!
            return answ;
        }

        /// <summary>
        /// Salva statistiche correnti
        /// </summary>
        /// <returns></returns>
        protected async Task<bool> setCurrStats(SampleStats newVal)
        {
            bool answ = false;
            string rawData = JsonConvert.SerializeObject(newVal);
            answ = await setRSV(rKeySampleStats, rawData, 24 * hourTTL);
            return answ;
        }

        #endregion Protected Methods
    }
}