using Newtonsoft.Json;
using RestSharp;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using static GPW_data.LiManObj;

namespace GPW_data
{
    public class licenzeGPW
    {
        #region Private Fields

        private static string _applicazione = memLayer.ML.confReadString("appName");

        /// <summary>
        /// Url di base chiamate API gestione licenze
        /// </summary>
        //private static string apiUrl = "https://localhost:44351/";
        private static string apiUrl = "https://liman.egalware.com/ELM.API/";

        private static string rkeyInstall = memLayer.ML.redHash($"LiMan:Install");
        private static string rkeyNumInstall = memLayer.ML.redHash($"LiMan:NumInstall");
        private static string rkeyAuth = memLayer.ML.redHash($"LiMan:Auth");
        private static string rkeyMKey = memLayer.ML.redHash($"LiMan:rkeyMKey");
        private static string rkeyActInfo = memLayer.ML.redHash($"LiMan:ActInfo");
        private static string rkeyDipAct = memLayer.ML.redHash($"LiMan:DipAct");
        private static string rkeyAppInfo = memLayer.ML.redHash($"LiMan:AppInfo");
        private static string rkeyLicInfo = memLayer.ML.redHash($"LiMan:LicInfo");
        private static string rkeyPayload = memLayer.ML.redHash($"LiMan:Payload");
        private static string rkeyTickets = memLayer.ML.redHash($"LiMan:Tickets");
        private static string rkeyVetoRefPayL = memLayer.ML.redHash($"LiMan:VetoRefPayL");

        private static int cacheTTL = 60 * 5;

        #endregion Private Fields

        #region Public Properties

        /// <summary>
        /// nome applicazione sw
        /// </summary>
        public static string applicazione => _applicazione;

        /// <summary>
        /// numero di licenze attive da info online
        /// </summary>
        public static int attivazioniOnline => _attivazioniOnline();

        /// <summary>
        /// chaive licenza
        /// </summary>
        public static string authKey => _authKey();

        /// <summary>
        /// verifica se numero licenze copre utenti attivi...
        /// </summary>
        public static bool checkLicenze => _checkLicenze();

        /// <summary>
        /// verifica se il payload delle licenze attivate sia valido (con server online)
        /// </summary>
        public static bool checkPayload => _checkPayload();

        /// <summary>
        /// nome installazione sw
        /// </summary>
        public static string installazione => _installazione();

        /// <summary>
        /// numero di licenze attive sul sw (SE CONFORMI A CHIAVE)
        /// </summary>
        public static int licenzeAttive => _licenzeAttive();

        /// <summary>
        /// numero di licenze attive su DB (NON verificate!)
        /// </summary>
        public static int licenzeDb => _licenzeDb();

        /// <summary>
        /// numero di licenze disponibili da info online
        /// </summary>
        public static int licenzeOnline => _licenzeOnline();

        /// <summary>
        /// Elenco attivazioni attuali
        /// </summary>
        public static List<LiManObj.AttivazioneDTO> ListaAttivazioni => _ListaAttivazioni();

        /// <summary>
        /// Chiave Licenza Master
        /// </summary>
        public static string MasterKey => _MasterKey();

        /// <summary>
        /// modalità applicazione (pagina test.aspx)
        /// </summary>
        public static string modApp => _modApp();

        /// <summary>
        /// numero di Ticket APERTI
        /// </summary>
        public static int numTickets => getNumTickets().Result;

        /// <summary>
        /// scadenza licenze x applicativo
        /// </summary>
        public static DateTime scadenzaLicenza => _scadenzaLicenza();

        /// <summary>
        /// Elenco dei Ticket da info online
        /// </summary>
        public static List<TicketDTO> TicketsList => getTickets().Result;

        /// <summary>
        /// numero di utenti attivi
        /// </summary>
        public static int utentiAttivi => _utentiAttivi();

        #endregion Public Properties

        #region Private Properties

        /// <summary>
        /// Info applicativo corrente (da cache con eventuale recupero online...)
        /// </summary>
        private static LiManObj.ApplicativoDTO InfoApplicativo
        {
            get
            {
                LiManObj.ApplicativoDTO answ = new LiManObj.ApplicativoDTO();
                // cerco da cache
                string rawData = memLayer.ML.getRSV(rkeyLicInfo);
                // se no ci fosse --> refresh online!
                if (string.IsNullOrEmpty(rawData))
                {
                    var fatto = RefreshAppInfo().Result;
                    if (fatto)
                    {
                        rawData = memLayer.ML.getRSV(rkeyLicInfo);
                    }
                }
                if (!string.IsNullOrEmpty(rawData))
                {
                    try
                    {
                        // verifico se ho 1 risultato o molti...se inizia per "[" è molti
                        if (rawData.StartsWith("["))
                        {
                            // POTREBBE darmi + di 1 risultato, prendo + recente...
                            List<LiManObj.ApplicativoDTO> infoList = JsonConvert.DeserializeObject<List<LiManObj.ApplicativoDTO>>(rawData);
                            if (infoList != null)
                            {
                                answ = infoList.OrderByDescending(x => x.Scadenza).FirstOrDefault();
                            }
                        }
                        else
                        {
                            answ = JsonConvert.DeserializeObject<LiManObj.ApplicativoDTO>(rawData);
                        }
                    }
                    catch
                    { }
                }
                return answ;
            }
        }

        /// <summary>
        /// Durata cache statica locale dati licenza, random circa 1 h
        /// </summary>
        private static int LicCacheTTL
        {
            get
            {
                Random rndGen = new Random();
                return rndGen.Next(50, 70) * 60;
            }
        }

        private static LiManObj.ApplicativoDTO myInfoApplicativo { get; set; }

        #endregion Private Properties

        #region Public Methods

        /// <summary>
        /// Verifica attivazione licenza dato codice impiego
        /// </summary>
        /// <param name="CodImpiego"></param>
        /// <returns></returns>
        public static async Task<bool> checkActivation(string CodImpiego)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
            var response = client.Get(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    // deserializzo
                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
                    answ = datiAttivazione != null && datiAttivazione.CodImpiego == CodImpiego;
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Verifica attivazione licenza dato codice impiego
        /// </summary>
        /// <param name="CodImpiego"></param>
        /// <returns></returns>
        public static async Task<bool> checkActivationUnlocked(string CodImpiego)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni/verifica?chiave={MKeyEnc}&CodImpiego={CodImpiego}", DataFormat.Json);
            var response = client.Get(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    // deserializzo
                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
                    if (datiAttivazione != null)
                    {
                        // verifico se il veto sia scaduto
                        answ = datiAttivazione.VetoUnlock <= DateTime.Today;
                    }
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Effettua refresh ActivationInfo con chiamata remota (sovrascrivendo info locali Redis)
        /// </summary>
        /// <returns></returns>
        public static async Task<bool> RefreshActInfo()
        {
            bool answ = false;

            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni/?chiave={MKeyEnc}", DataFormat.Json);
            var response = client.Get(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                answ = true;
                // salvo in redis contenuto serializzato
                string rawData = response.Content;
                // salvo in redis per 7 gg
                memLayer.ML.setRSV(rkeyActInfo, rawData, LicCacheTTL);
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Effettua refresh AppInfo con chiamata remota (sovrascrivendo info locali Redis)
        /// </summary>
        /// <returns></returns>
        public static async Task<bool> RefreshAppInfo()
        {
            bool answ = false;

            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            var request = new RestRequest($"/api/applicazione/{installazione}?CodApp={applicazione}", DataFormat.Json);
            var response = client.Get(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                answ = true;
                // salvo in redis contenuto serializzato
                string rawData = response.Content;
                // salvo in redis per 7 gg
                memLayer.ML.setRSV(rkeyAppInfo, rawData, LicCacheTTL);
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Effettua refresh LicenseInfo con chiamata remota (sovrascrivendo info locali Redis)
        /// </summary>
        /// <returns></returns>
        public static async Task<bool> RefreshLicInfo()
        {
            bool answ = false;

            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/licenza/{installazione}?CodApp={applicazione}&Chiave={MKeyEnc}", DataFormat.Json);
            var response = client.Get(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                answ = true;
                // salvo in redis contenuto serializzato
                string rawData = response.Content;
                // salvo in redis per 7 gg
                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Effettua refresh Payload su server (Remoto) e recupera info licenza in locale (sovrascrivendo info locali Redis)
        /// </summary>
        /// <returns></returns>
        public static async Task<bool> RefreshPayload()
        {
            bool answ = false;
            // svuoto payload calcolato in primis (ttl a 1 sec)...
            memLayer.ML.setRSV(rkeyPayload, "", 1);

            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/licenza/refreshPayload", DataFormat.Json);
            string newEnigma = calcHash($"{DateTime.Now:yyyyMMddHHmmss}");
            LicenseCoord newBody = new LicenseCoord()
            {
                MasterKey = MasterKey,
                CodInst = installazione,
                CodApp = applicazione,
                Enigma = newEnigma
            };
            request.AddJsonBody(newBody);
            var response = client.Post(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                answ = true;
                // salvo in redis contenuto serializzato
                string rawData = response.Content;
                // salvo in redis per 7 gg
                memLayer.ML.setRSV(rkeyLicInfo, rawData, LicCacheTTL);
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Tenta invio di un ticket x licenza indicata
        /// </summary>
        /// <param name="contName"></param>
        /// <param name="contEmail"></param>
        /// <param name="contPhone"></param>
        /// <param name="reqBody"></param>
        /// <param name="codImpiego"></param>
        /// <param name="idxSubLic"></param>
        /// <returns></returns>
        public static async Task<bool> sendTicketReq(string contName, string contEmail, string contPhone, string reqBody, string codImpiego, int idxSubLic)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/ticket/sendReq", DataFormat.Json);

            SupportRequest richiesta = new SupportRequest()
            {
                ContactName = contName,
                ContactEmail = contEmail,
                ContactPhone = contPhone,
                ReqBody = reqBody,
                CodInst = installazione,
                CodApp = applicazione,
                MasterKey = MasterKey,
                idxSubLic = idxSubLic,
                CodImp = codImpiego
            };

            request.AddJsonBody(richiesta);
            var response = client.Post(request);

            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    if (rawData.StartsWith("["))
                    {
                        // deserializzo
                        List<TicketDTO> tickets = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
                        answ = tickets != null;
                    }
                    else
                    {
                        // deserializzo singolo
                        TicketDTO tickets = JsonConvert.DeserializeObject<TicketDTO>(rawData);
                        answ = tickets != null;
                    }
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Tenta attivazione licenza dato codice impiego
        /// </summary>
        /// <param name="CodImpiego"></param>
        /// <returns></returns>
        public static async Task<bool> tryActivation(string CodImpiego, string Chiave)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
            Dictionary<string, string> parDict = new Dictionary<string, string>();
            parDict.Add(CodImpiego, Chiave);
            UserLicenseRequest newBody = new UserLicenseRequest()
            {
                MasterKey = MasterKey,
                ParamDict = parDict
            };
            request.AddJsonBody(newBody);
            var response = client.Post(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    // deserializzo
                    AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
                    answ = datiAttivazione != null;
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Tenta attivazione licenze dato dizionario codici impiego + chiavi
        /// </summary>
        /// <param name="ParamsList">Dizionario parametri attivazione di tipo (CodImpiego,Chiave)</param>
        /// <returns></returns>
        public static async Task<bool> tryActivationMult(Dictionary<string, string> ParamsList)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
            UserLicenseRequest newBody = new UserLicenseRequest()
            {
                MasterKey = MasterKey,
                ParamDict = ParamsList
            };
            request.AddJsonBody(newBody);
            var response = client.Post(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    if (rawData.StartsWith("["))
                    {
                        // deserializzo
                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
                        answ = datiAttivazione != null;
                    }
                    else
                    {
                        // deserializzo singolo
                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
                        answ = datiAttivazione != null;
                    }
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Tenta disattivazione licenza dato codice impiego
        /// </summary>
        /// <param name="ParamsList">Dizionario codici da eliminare (CodImpiego/uSERkEY)</param>
        /// <returns></returns>
        public static async Task<bool> tryDeactivation(Dictionary<string, string> ParamsList)
        {
            bool answ = false;
            // cerco attivazione...
            var refreshDone = RefreshActInfo().Result;
            if (refreshDone)
            {
                // cerco online
                RestClient client = new RestClient(apiUrl);
                //client.Authenticator = new HttpBasicAuthenticator("username", "password");
                var request = new RestRequest($"/api/attivazioni", DataFormat.Json);
                UserLicenseRequest newBody = new UserLicenseRequest()
                {
                    MasterKey = MasterKey,
                    ParamDict = ParamsList
                };
                request.AddJsonBody(newBody);
                var response = client.Delete(request);
                // controllo risposta
                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    // verifico risposta
                    string rawData = response.Content;
                    bool.TryParse(rawData, out answ);
                }
            }

            return await Task.FromResult(answ);
        }

        /// <summary>
        /// Tenta refresh licenza dato codice impiego (aggiorna la authKey...)
        /// </summary>
        /// <param name="CodImpiego"></param>
        /// <returns></returns>
        public static async Task<bool> tryRefreshActivation(string CodImpiego, string Chiave)
        {
            bool answ = false;
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni/refreshKey", DataFormat.Json);
            Dictionary<string, string> parDict = new Dictionary<string, string>();
            parDict.Add(CodImpiego, Chiave);
            UserLicenseRequest newBody = new UserLicenseRequest()
            {
                MasterKey = MasterKey,
                ParamDict = parDict
            };
            request.AddJsonBody(newBody);
            var response = client.Post(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // verifico risposta
                string rawData = response.Content;
                try
                {
                    if (rawData.StartsWith("["))
                    {
                        // deserializzo
                        List<AttivazioneDTO> datiAttivazione = JsonConvert.DeserializeObject<List<AttivazioneDTO>>(rawData);
                        answ = datiAttivazione != null;
                    }
                    else
                    {
                        // deserializzo singolo
                        AttivazioneDTO datiAttivazione = JsonConvert.DeserializeObject<AttivazioneDTO>(rawData);
                        answ = datiAttivazione != null;
                    }
                }
                catch
                { }
            }
            return await Task.FromResult(answ);
        }

        public static bool userPayloadOk(int idxDip) => _userPayloadOk(idxDip);

        #endregion Public Methods

        #region Private Methods

        /// <summary>
        /// numero di licenze attive da info online
        /// </summary>
        private static int _attivazioniOnline()
        {
            return InfoApplicativo.NumLicenzeAttive;
        }

        /// <summary>
        /// chiave licenza
        /// </summary>
        private static string _authKey()
        {
            // cerco in redis
            string answ = memLayer.ML.getRSV(rkeyAuth);
            // se non trovato --> DB
            if (string.IsNullOrEmpty(answ))
            {
                // altrimenti DB...
                try
                {
                    answ = DataProxy.DP.taAKV.getByKey(installazione)[0].valString;
                    // salvo x 5 min
                    memLayer.ML.setRSV(rkeyAuth, answ, cacheTTL);
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore recupero chiave auth da AKV: {0}", exc), tipoLog.EXCEPTION);
                }
            }
            return answ;
        }

        /// <summary>
        /// verifica se numero licenze copre utenti attivi...
        /// </summary>
        private static bool _checkLicenze()
        {
            bool answ = false;
            bool fatto = false;
            try
            {
                // cerco da cache
                string rawData = memLayer.ML.getRSV(rkeyActInfo);
                // se non ci fosse --> refresh online!
                if (string.IsNullOrEmpty(rawData))
                {
                    // effettua refresh attivazioni...
                    fatto = RefreshActInfo().Result;
                }
                answ = utentiAttivi <= licenzeAttive;
                if (!answ && memLayer.ML.confReadInt("_logLevel") > 5)
                {
                    logger.lg.scriviLog(string.Format("WARNING licenze: utenti attivi {0} / licenziati {1}", utentiAttivi, licenzeAttive), tipoLog.WARNING);
                }
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// verifica se il payload delle licenze attivate sia valido (con server online)
        /// </summary>
        private static bool _checkPayload()
        {
            bool answ = false;
            string currPayload = "";
            tryCheckPayloadOnline(ref answ, ref currPayload);

            // se OK resetto counter, altrimenti incremento
            if (!answ)
            {
                bool okRefreshPayload = string.IsNullOrEmpty(memLayer.ML.getRSV(rkeyVetoRefPayL));
                if (okRefreshPayload)
                {
                    Stopwatch sw = new Stopwatch();
                    sw.Start();
                    // richiedo update payload impostando TTL a 1 sec...
                    memLayer.ML.setRSV(rkeyPayload, "", 1);
                    var okApp = RefreshAppInfo().Result;
                    var okLic = RefreshActInfo().Result;
                    var okAct = RefreshLicInfo().Result;
                    var okPld = RefreshPayload().Result;

                    // evito ricalcolo x 5 sec...
                    memLayer.ML.setRSV(rkeyVetoRefPayL, "Veto", 5);
                    sw.Stop();
                    logger.lg.scriviLog($"Trovato payload non valido, effettuato reset variabili in {sw.ElapsedMilliseconds} ms");

                    sw.Start();
                    tryCheckPayloadOnline(ref answ, ref currPayload);
                    sw.Stop();
                    logger.lg.scriviLog($"Rivalutato payload con esito {answ} in {sw.ElapsedMilliseconds} ms");
                }
            }

            return answ;
        }

        /// <summary>
        /// nome installazione sw
        /// </summary>
        private static string _installazione()
        {
            // cerco in redis
            string answ = memLayer.ML.getRSV(rkeyInstall);
            // se non trovato --> DB
            if (string.IsNullOrEmpty(answ))
            {
                // altrimenti DB...
                try
                {
                    answ = DataProxy.DP.taAKV.getByKey("installazione")[0].valString;
                    // salvo x 5 min
                    memLayer.ML.setRSV(rkeyInstall, answ, cacheTTL);
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore recupero chiave installazione da AKV: {0}", exc), tipoLog.EXCEPTION);
                }
            }
            return answ;
        }

        /// <summary>
        /// numero di licenze attive sul sw (SE CONFORMI A CHIAVE)
        /// </summary>
        private static int _licenzeAttive()
        {
            int answ = 0;
            int licenzeMax = licenseMan.getLicenseNum(installazione, applicazione);
            // verifico dato su DB sia valido... expiry date con quel numero sia > della data odierna
            if (scadenzaLicenza >= DateTime.Today)
            {
                answ = licenzeDb;
            }
            else
            {
                answ = licenzeMax;
            }
            return answ;
        }

        /// <summary>
        /// numero di licenze attive su DB (NON verificate!)
        /// </summary>
        private static int _licenzeDb()
        {
            int answ = 0;
            string rawData = memLayer.ML.getRSV(rkeyNumInstall);
            // se non trovato --> DB
            if (string.IsNullOrEmpty(rawData))
            {
                // altrimenti DB...
                try
                {
                    answ = DataProxy.DP.taAKV.getByKey(installazione)[0].valInt;
                    // salvo x 5 min
                    memLayer.ML.setRSV(rkeyNumInstall, $"{answ}", cacheTTL);
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore recupero num lic da AKV: {0}", exc), tipoLog.EXCEPTION);
                }
            }
            else
            {
                int.TryParse(rawData, out answ);
            }
            return answ;
        }

        /// <summary>
        /// numero di licenze disponibili da info online
        /// </summary>
        private static int _licenzeOnline()
        {
            return InfoApplicativo.NumLicenze;
        }

        /// <summary>
        /// Elenco attivazioni attuali
        /// </summary>
        private static List<LiManObj.AttivazioneDTO> _ListaAttivazioni()
        {
            List<LiManObj.AttivazioneDTO> answ = new List<LiManObj.AttivazioneDTO>();
            // cerco da cache
            string rawData = memLayer.ML.getRSV(rkeyActInfo);
            // se non ci fosse --> refresh online!
            if (string.IsNullOrEmpty(rawData))
            {
                var fatto = RefreshActInfo().Result;
                if (fatto)
                {
                    rawData = memLayer.ML.getRSV(rkeyActInfo);
                }
            }
            if (!string.IsNullOrEmpty(rawData))
            {
                answ = JsonConvert.DeserializeObject<List<LiManObj.AttivazioneDTO>>(rawData);
            }
            return answ;
        }

        /// <summary>
        /// Chiave Licenza Master
        /// </summary>
        private static string _MasterKey()
        {
            // cerco in redis
            string answ = memLayer.ML.getRSV(rkeyMKey);
            // se non trovato --> DB
            if (string.IsNullOrEmpty(answ))
            {
                // altrimenti DB...
                try
                {
                    answ = DataProxy.DP.taAKV.getByKey(installazione)[0].valString;
                    // salvo x 5 min
                    memLayer.ML.setRSV(rkeyMKey, answ, cacheTTL);
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore recupero chiave MasterKey da AKV: {0}", exc), tipoLog.EXCEPTION);
                }
            }
            return answ;
        }

        /// <summary>
        /// modalità applicazione (pagina test.aspx)
        /// </summary>
        private static string _modApp()
        {
            string answ = "";
            try
            {
                answ = DataProxy.DP.taAKV.getByKey("appMode")[0].valString;
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore recupero chiave appMode da AKV: {0}", exc), tipoLog.EXCEPTION);
            }
            return answ;
        }

        /// <summary>
        /// scadenza licenze x applicativo
        /// </summary>
        private static DateTime _scadenzaLicenza()
        {
            DateTime answ = licenseMan.expiryDateByAuthKey(installazione, applicazione, licenzeDb, authKey);
            return answ;
        }

        private static bool _userPayloadOk(int idxDip)
        {
            bool answ = false;
            try
            {
                // recupero riga dip
                var userRow = DataProxy.DP.getRowDip(idxDip);
                if (userRow != null)
                {
                    // calcolo suo codice...
                    var codImpCurr = DataProxy.DP.hashCodImpiego(userRow);
                    // cerco dip tra elenco json
                    var userLocalList = ListaAttivazioni;
                    var foundRec = userLocalList.Where(x => x.CodImpiego == codImpCurr);
                    answ = foundRec.Count() > 0;
                }
            }
            catch
            { }

            return answ;
        }

        /// <summary>
        /// numero di utenti attivi
        /// </summary>
        private static int _utentiAttivi()
        {
            return getDipAttivi().Count;
        }

        public static DS_Applicazione.DipendentiDataTable getDipAttivi()
        {
            DS_Applicazione.DipendentiDataTable answ = new DS_Applicazione.DipendentiDataTable();
            // cerco da cache
            string rawData = memLayer.ML.getRSV(rkeyDipAct);
            // se no ci fosse --> refresh online!
            if (string.IsNullOrEmpty(rawData))
            {
                answ = DataProxy.DP.taDipendenti.getAttivi(false);
                rawData = JsonConvert.SerializeObject(answ);
                memLayer.ML.setRSV(rkeyDipAct, rawData, cacheTTL);
            }
            else
            {
                answ = JsonConvert.DeserializeObject<DS_Applicazione.DipendentiDataTable>(rawData);
            }
            return answ;
        }

        /// <summary>
        /// Calcolo Hash data stringa input
        /// </summary>
        /// <param name="rawData"></param>
        /// <returns></returns>
        private static string calcHash(string rawData)
        {
            string hash = "";
            // hashing!
            using (var md5 = MD5.Create())
            {
                byte[] InputBytes = Encoding.UTF8.GetBytes(rawData);
                var byteHash = md5.ComputeHash(InputBytes);
                hash = BitConverter.ToString(byteHash).Replace("-", "").ToLowerInvariant();
            }
            return hash;
        }

        private static string calcPayload()
        {
            string answ = "";
            // costruisco stringa da elenco impieghi...
            StringBuilder sb = new StringBuilder();

            // ciclo tutti gli utenti attivi
            var localUserList = getDipAttivi();
            List<string> codiciImpiego = new List<string>();
            // ciclo x ogni dip attivo...
            foreach (var item in localUserList)
            {
                codiciImpiego.Add(DataProxy.DP.hashCodImpiego(item));
            }
            // riordino
            var ordList = codiciImpiego.OrderBy(x => x);
            foreach (var item in ordList)
            {
                sb.AppendLine(item);
            }
            string rawData = sb.ToString();

            // hashing!
            using (var md5 = MD5.Create())
            {
                byte[] InputBytes = Encoding.UTF8.GetBytes(rawData);
                var byteHash = md5.ComputeHash(InputBytes);
                answ = BitConverter.ToString(byteHash).Replace("-", "").ToLowerInvariant();
            }
            return answ;
        }

        /// <summary>
        /// Recupera num ticket da sistema LiMan online
        /// </summary>
        /// <returns></returns>
        private static async Task<int> getNumTickets()
        {
            var elenco = await getTickets();
            var openTickets = elenco
                                .Where(x => x.Status <= StatoRichiesta.Valutazione)
                                .ToList();
            return await Task.FromResult(openTickets.Count);
        }

        /// <summary>
        /// Recupera num ticket da sistema LiMan online
        /// </summary>
        /// <returns></returns>
        private static async Task<List<TicketDTO>> getTickets()
        {
            List<TicketDTO> answ = new List<TicketDTO>();
            // cerco in cache locale...
            string rawData = memLayer.ML.getRSV(rkeyTickets);
            if (!string.IsNullOrEmpty(rawData))
            {
                answ = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
            }
            // se vuoto rileggo
            if (answ.Count == 0)
            {
                // cerco online
                RestClient client = new RestClient(apiUrl);
                //client.Authenticator = new HttpBasicAuthenticator("username", "password");
                string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
                var request = new RestRequest($"/api/ticket/{installazione}?CodApp={applicazione}&Chiave={MKeyEnc}", DataFormat.Json);
                var response = client.Get(request);
                // controllo risposta
                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    // salvo in redis contenuto serializzato
                    rawData = response.Content;
                    // deserializzo
                    answ = JsonConvert.DeserializeObject<List<TicketDTO>>(rawData);
                    // salvo in redis per TTL std
                    memLayer.ML.setRSV(rkeyTickets, rawData, 20);
                }
            }
            return await Task.FromResult(answ);
        }

        public static void resetTicketCache()
        {
            // resetto cache tickets a 1 sec e vuoto
            memLayer.ML.setRSV(rkeyTickets, "", 1);
            // ricarico
            var newList = getTickets();
        }

        private static void tryCheckPayloadOnline(ref bool answ, ref string currPayload)
        {
            try
            {
                // cerco payload licenze locale...
                currPayload = memLayer.ML.getRSV(rkeyPayload);
                // se no ci fosse --> refresh online!
                if (string.IsNullOrEmpty(currPayload))
                {
                    currPayload = calcPayload();
                    memLayer.ML.setRSV(rkeyPayload, currPayload, LicCacheTTL);
                }
                // confronto payload calc con quello della licenza
                var currInfo = InfoApplicativo;
                answ = (InfoApplicativo.Payload == currPayload);
                // se fallisce --> resetto payload calcolato
                if (!answ)
                {
                    memLayer.ML.setRSV(rkeyAppInfo, "", 1);
                    memLayer.ML.setRSV(rkeyPayload, "", 1);
                }
            }
            catch
            { }
        }

        #endregion Private Methods
    }
}