using MongoDB.Driver;
using Newtonsoft.Json;
using NLog.Fluent;
using NLog;
using StackExchange.Redis;
using SteamWare.Logger;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Text;
using System.Threading;
using System.Web;

namespace SteamWare.IO
{
    /// <summary>
    /// layer gestione vari tipi di memoria: cache, session...
    /// </summary>
    public class memLayer
    {
        #region Public Fields

        /// <summary>
        /// oggetto singleton x accesso al layer di memoria
        /// </summary>
        public static memLayer ML = new memLayer();

        /// <summary>
        /// oggetto dizionario con chiave / valore x configurazioni applicazione
        /// </summary>
        public Dictionary<string, string> AppConf;

        /// <summary>
        /// Definisce il TTL x appConf (secondi)
        /// </summary>
        public int maxAgeAppConf = 5;

        /// <summary>
        /// Table adapter accesso conf parameters
        /// </summary>
        public DS_UtilityTableAdapters.ConfigTableAdapter taConfig;

        /// <summary>
        /// Table adapter accesso conf parameters TMP (x import/check)
        /// </summary>
        public DS_UtilityTableAdapters.ConfigTmpTableAdapter taConfigTmp;

        #endregion Public Fields

        #region Public Constructors

        /// <summary>
        /// classe gestione accessi a Session, cache, viewstate, configuration...
        /// </summary>
        public memLayer()
        {
            if (Log == null)
            {
                Log = LogManager.GetCurrentClassLogger();
            }
            // istanzia il conf setting reader...
            configAppSetReader = new AppSettingsReader();
            // avvio e configuro TA
            initTA();
            setupConnectionStringBase();
            setupMongo();
            setupParams();
        }

        #endregion Public Constructors

        #region Public Enums

        /// <summary>
        /// Tipologia di ordinamento x liste KVP
        /// </summary>
        public enum kvpOrderBy
        {
            /// <summary>
            /// Ordinamento ASCending per KEY
            /// </summary>
            KeyAsc,

            /// <summary>
            /// Ordinamento DESCending per KEY
            /// </summary>
            KeyDesc,

            /// <summary>
            /// Ordinamento ASCending per VAL
            /// </summary>
            ValAsc,

            /// <summary>
            /// Ordinamento DESCending per VAL
            /// </summary>
            ValDesc
        }

        #endregion Public Enums

        #region Public Properties

        /// <summary>
        /// Nome della variabile AppConf da utilizzare...
        /// </summary>
        public string ACBH
        {
            get
            {
                string answ = "AppConf";
                try
                {
                    answ = string.Format("{0}:{1}:{2}:AppConf", confReadString("CodModulo"), taConfig.Connection.DataSource, taConfig.Connection.Database).Replace("\\", "_");
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Oggetto DB REDIS corrente
        /// </summary>
        public IDatabase cache //currDB
        {
            get
            {
                IDatabase answ;
                // se già valorizzato uso oggetto private...
                if (_currDB != null)
                {
                    answ = _currDB;
                }
                else
                {
                    // init DB (sullo 0)
                    answ = connRedis.GetDatabase();
                    // gestione override...
                    if (confReadInt("redisDb") >= 0)
                    {
                        // in questo caso uso il DB configurato in app.config...
                        answ = connRedis.GetDatabase(confReadInt("redisDb"));
                    }
                    _currDB = answ;
                }
                // restituisco oggetto DB
                return answ;
            }
        }

        /// <summary>
        /// Indica se usare la cache su REDIS (true) oppure cache applicativo IIS (false)
        /// </summary>
        public bool cacheOnRedis
        {
            get
            {
                bool answ = confReadBool("cacheOnRedis");
                return answ;
            }
        }

        /// <summary>
        /// Nome della variabile x indicare che si sta facendo refresh della appConf...
        /// </summary>
        public string CleaningKey
        {
            get
            {
                string answ = "RunningACCleaning";
                try
                {
                    answ = string.Format("{0}:{1}:{2}:RunningACCleaning", confReadString("CodModulo"), taConfig.Connection.DataSource, taConfig.Connection.Database).Replace("\\", "_");
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Oggetto statico connessione redis
        /// </summary>
        public ConnectionMultiplexer connRedis
        {
            get
            {
                return lazyConnection.Value;
            }
        }

        /// <summary>
        /// Oggetto statico connessione redis
        /// </summary>
        public ConnectionMultiplexer connRedisAdmin
        {
            get
            {
                return lazyConnectionAdmin.Value;
            }
        }

        /// <summary>
        /// Numero record salvati in AppConf
        /// </summary>
        public int numRecAppConf
        {
            get
            {
                int answ = 0;
                try
                {
                    answ = AppConf.Count;
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Restituisce numero record in Redis DB
        /// </summary>
        public long numRecRedis
        {
            get
            {
                long answ = 0;
                try
                {
                    foreach (var ep in connRedis.GetEndPoints())
                    {
                        var server = connRedis.GetServer(ep);
                        answ += server.DatabaseSize();
                    }
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// Verifica se si debba serializzare ogni valore complesso (tabelle/righe) in sessione (per
        /// impiego di sessioni avanzate come Redis)
        /// </summary>
        public bool serializeSession
        {
            get
            {
                return CRB("serializeSession");
            }
        }

        /// <summary>
        /// elenco dictionary delle tab in cache da aggiornare con update svuotando da cache...
        /// </summary>
        public Dictionary<string, string> tabelleInCache
        {
            get
            {
                Dictionary<string, string> answ = new Dictionary<string, string>();
                try
                {
                    var cacheVal = objCacheObj("tabelleInCache");
                    if (cacheVal != null)
                    {
                        answ = JsonConvert.DeserializeObject<Dictionary<string, string>>(cacheVal.ToString());
                    }
                }
                catch (Exception exc)
                {
                    answ = new Dictionary<string, string>();
                    Log.Error(string.Format("Eccezzione in tabelleInCache{0}{1}", Environment.NewLine, exc));
                }
                return answ;
            }
            set
            {
                string serVal = JsonConvert.SerializeObject(value);
                setCacheVal("tabelleInCache", serVal);
            }
        }

        /// <summary>
        /// elenco dictionary dei valori in session da NON aggiornare con update...
        /// </summary>
        public Dictionary<string, string> valSess2SurvUpd
        {
            get
            {
                Dictionary<string, string> answ = new Dictionary<string, string>();
                if (isInSessionObject("valoriInSession2Survive"))
                {
                    try
                    {
                        answ = (Dictionary<string, string>)objSessionObj("valoriInSession2Survive");
                    }
                    catch
                    {
                        answ = new Dictionary<string, string>();
                    }
                }
                return answ;
            }
            set
            {
                setSessionVal("valoriInSession2Survive", value);
            }
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Formattazione stringa URL immagini con gestione "base url"
        /// </summary>
        /// <param name="urlRelPath"></param>
        /// <returns></returns>
        public static string imgUrl(string urlRelPath)
        {
            return string.Format("{0}/{1}", memLayer.ML.CRS("baseUrl"), urlRelPath);
        }

        /// <summary>
        /// aggiunge la stringa corrente nel dictionary delle tabelle messe in cache e da aggiornare
        /// su comando update
        /// </summary>
        /// <param name="nuovaTab"></param>
        public void addTabInCache(string nuovaTab)
        {
            // provo ad aggiungere nuova tab in elenco...
            Dictionary<string, string> _tabelleInCache = tabelleInCache;
            try
            {
                _tabelleInCache.Add(nuovaTab, nuovaTab);
                tabelleInCache = _tabelleInCache;
            }
            catch
            { }
        }

        /// <summary>
        /// aggiunge la stringa corrente nel dictionary delle tabelle messe in session che vanno
        /// preservate da comando update (es: oggetto selezionato...)
        /// </summary>
        /// <param name="nomePar"></param>
        /// <param name="valore"></param>
        public void addValInSession(string nomePar, string valore)
        {
            // provo ad aggiungere nuova tab in elenco...
            Dictionary<string, string> _valoriInSession2Survive = valSess2SurvUpd;
            // verifico se fare update o insert...
            if (_valoriInSession2Survive.ContainsKey(nomePar))
            {
                // update, rimuovo vecchio valore...
                try
                {
                    _valoriInSession2Survive.Remove(nomePar);
                }
                catch
                { }
            }
            // insert
            try
            {
                _valoriInSession2Survive.Add(nomePar, valore);
                valSess2SurvUpd = _valoriInSession2Survive;
            }
            catch
            { }
        }

        /// <summary>
        /// carica dalla Cachee un dato di tipo boolean (se vuoto false)
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool BoolCacheObj(string nomeVar)
        {
            bool answ = false;
            // ...se uso redis...
            if (cacheOnRedis)
            {
                string redVal = JsonConvert.DeserializeObject(getRSV(redHash(nomeVar))).ToString();
                bool.TryParse(redVal, out answ);
            }
            else
            {
                if (HttpContext.Current.Cache[nomeVar] != null)
                {
                    answ = (bool)HttpContext.Current.Cache[nomeVar];
                }
                else
                {
                    answ = false;
                }
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo boolean (se vuoto false)
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool BoolSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return (bool)HttpContext.Current.Session[nomeVar];
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Configurations da tabella DB Config (short form wrapper)
        /// </summary>
        /// <param name="chiave">Valore chiave</param>
        /// <returns></returns>
        public string cdv(string chiave)
        {
            return configDbVal(chiave);
        }

        /// <summary>
        /// Configurations da tabella DB Config (short form wrapper) convertito a bOOL
        /// </summary>
        /// <param name="chiave">Valore chiave</param>
        /// <returns></returns>
        public bool cdvb(string chiave)
        {
            bool answ = false;
            string sVal = configDbVal(chiave);
            if (sVal != "")
            {
                try
                {
                    //answ = Convert.ToBoolean(configDbVal(chiave));
                    bool fatto = bool.TryParse(sVal, out answ);
                    if (!fatto)
                    {
                        Log.Error($"Errore in lettura chiave [{chiave}] durante cdvb: ricevuto {sVal}");
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezzione in lettura chiave [{chiave}] durante cdvb{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Configurations da tabella DB Config (short form wrapper) convertito a INT
        /// </summary>
        /// <param name="chiave">Valore chiave</param>
        /// <returns></returns>
        public int cdvi(string chiave)
        {
            int answ = -1;
            string sVal = configDbVal(chiave);
            if (sVal != "")
            {
                try
                {
                    //answ = Convert.ToInt32(configDbVal(chiave));
                    bool fatto = int.TryParse(sVal, out answ);
                    if (!fatto)
                    {
                        Log.Error($"Errore in lettura chiave [{chiave}] durante cdvi: ricevuto {sVal}");
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezzione in lettura chiave [{chiave}] durante cdvi{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Effettua comaprazione x VALORE in KVP ASC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int CompareVal(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return x.Value.CompareTo(y.Value);
        }

        /// <summary>
        /// Effettua comaprazione x VALORE in KVP DESC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int CompareValDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return y.Value.CompareTo(x.Value);
        }

        /// <summary>
        /// Configurations da tabella DB Config
        /// </summary>
        /// <param name="chiave">Valore chiave</param>
        /// <returns></returns>
        public string configDbVal(string chiave)
        {
            string answ = "";
            bool cacheReloaded = false;
            if (confReadString("DbConfConnectionString") != "")
            {
                // verifico esista oggetto...
                if (AppConf == null)
                {
                    resetAppConf();
                    cacheReloaded = true;
                }
                if (AppConf != null)
                {
                    // controllo se ho dati, altrimenti rileggo
                    if (AppConf.Count == 0)
                    {
                        resetAppConf();
                        cacheReloaded = true;
                    }
                    // controllo SE in redis ci sia ancora il valore, altrimenti rileggo...
                    if (!cacheReloaded && DateTime.Now > vetoCacheCheck && !redKeyPresent(ACBH))
                    {
                        Log.Info($"Manca HASH in redis --> rileggo da DB --> REDIS --> Memoria | {ACBH} | {chiave}");
                        resetAppConf();
                    }
                    // provo a leggere da DICT
                    if (AppConf.ContainsKey(chiave))
                    {
                        try
                        {
                            answ = AppConf[chiave];
                        }
                        catch (Exception exc)
                        {
                            Log.Error($"Errore in lettura AppConf[{chiave}] durante configDbVal{Environment.NewLine}{exc}");
                        }
                    }
                }
            }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore bool
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public bool confReadBool(string nomeParam)
        {
            bool answ = false;
            try
            {
                answ = (bool)configAppSetReader.GetValue(nomeParam, typeof(bool));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore int
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public double confReadDouble(string nomeParam)
        {
            double answ = -1;
            try
            {
                answ = Convert.ToDouble(configAppSetReader.GetValue(nomeParam, typeof(double)));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore int
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public int confReadInt(string nomeParam)
        {
            int answ = -1;
            try
            {
                answ = (int)configAppSetReader.GetValue(nomeParam, typeof(int));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore string
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public string confReadString(string nomeParam)
        {
            string answ = "";
            try
            {
                answ = (string)configAppSetReader.GetValue(nomeParam, typeof(string));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// shot-form di confReadBool: legge dalla config un valore bool
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public bool CRB(string nomeParam)
        {
            bool answ = false;
            // PROVO IN PRIMIS a cercare su DB...
            if (cdv(nomeParam) != "")
            {
                answ = cdvb(nomeParam);
            }
            else
            {
                answ = confReadBool(nomeParam);
            }
            return answ;
        }

        /// <summary>
        /// shot-form di confReadDouble: legge dalla config un valore double
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public double CRD(string nomeParam)
        {
            double answ = -1;
            // PROVO IN PRIMIS a cercare su DB...
            try
            {
                answ = Convert.ToDouble(cdv(nomeParam));
            }
            catch
            { }
            // se non trovato...
            if (answ < 0)
            {
                answ = confReadDouble(nomeParam);
            }
            return answ;
        }

        /// <summary>
        /// shot-form di confReadInt: legge dalla config un valore int
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public int CRI(string nomeParam)
        {
            int answ = -1;
            // PROVO IN PRIMIS a cercare su DB...
            answ = cdvi(nomeParam);
            // se non trovato...
            if (answ < 0)
            {
                answ = confReadInt(nomeParam);
            }
            return answ;
        }

        /// <summary>
        /// shot-form di confReadString: legge dalla config un valore string
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public string CRS(string nomeParam)
        {
            string answ = "";
            // PROVO IN PRIMIS a cercare su DB...
            answ = cdv(nomeParam);
            if (string.IsNullOrEmpty(answ))
            {
                answ = confReadString(nomeParam);
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo DateTime
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public DateTime DateTimeSessionObj(string nomeVar)
        {
            DateTime answ = DateTime.Now;
            // se li ho in sessione ricarico valori...
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                try
                {
                    answ = Convert.ToDateTime(memLayer.ML.objSessionObj(nomeVar));
                }
                catch
                {
                    answ = DateTime.Now;
                }
            }
            return answ;
        }

        /// <summary>
        /// Deserializzazione di un valore string in oggetto generico
        /// </summary>
        /// <param name="serVal"></param>
        /// <returns></returns>
        public object deserializeVal(string serVal)
        {
            object answ = "";
            try
            {
                answ = JsonConvert.DeserializeObject(serVal);
            }
            catch { }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo DataSet NON Tipizzato
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public DataSet dsSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                string valSer = ML.StringSessionObj(nomeVar);
                DataSet dataSet = JsonConvert.DeserializeObject<DataSet>(valSer);
                return dataSet;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// svuota una variabile dalla Cache
        /// </summary>
        /// <param name="nomeVar"></param>
        public bool emptyCacheVal(string nomeVar)
        {
            bool _done = false;
            if (cacheOnRedis)
            {
                redDelKey(redHash(nomeVar));
            }
            else
            {
                try
                {
                    HttpContext.Current.Cache.Remove(nomeVar);
                    _done = true;
                }
                catch
                { }
            }
            return _done;
        }

        /// <summary>
        /// elimina un cookie
        /// </summary>
        /// <param name="nome"></param>
        public bool emptyCookieVal(string nome)
        {
            bool _done = false;
            HttpCookie aCookie;
            try
            {
                aCookie = new HttpCookie(nome);
                aCookie.Expires = DateTime.Now.AddDays(-1);
                HttpContext.Current.Response.Cookies.Add(aCookie);
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// svuota una variabile dalla session
        /// </summary>
        /// <param name="nome"></param>
        public bool emptySessionVal(string nome)
        {
            bool _done = false;
            try
            {
                HttpContext.Current.Session.Remove(nome);
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// forza lo svuotamento delle tabelle indicate come in cache...
        /// </summary>
        public void flushRegisteredCache()
        {
            // elimino tutte le tab nella pos tabInCache...
            foreach (KeyValuePair<string, string> kvp in tabelleInCache)
            {
                if (cacheOnRedis)
                {
                    redDelKey(redHash(kvp.Value));
                }
                else
                {
                    HttpContext.Current.Cache.Remove(kvp.Value);
                }
            }
            if (cacheOnRedis)
            {
                redDelKey(redHash("tabelleInCache"));
            }
            else
            {
                HttpContext.Current.Cache.Remove("tabelleInCache");
            }
        }

        /// <summary>
        /// restituisco un valore da cookie
        /// </summary>
        /// <param name="nome"></param>
        /// <returns></returns>
        public string getCookieVal(string nome)
        {
            string answ = "";
            if (hasCookieVal(nome))
            {
                try
                {
                    answ = HttpContext.Current.Request.Cookies[nome].Value;
                }
                catch
                { }
            }
            return answ;
        }

        /// <summary>
        /// Restituisce oggetto DB richiesto
        /// </summary>
        /// <param name="dbName"></param>
        /// <returns></returns>
        public IMongoDatabase getMongoDatabase(string dbName)
        {
            IMongoDatabase answ = currMongoClient.GetDatabase(dbName);
            return answ;
        }

        /// <summary>
        /// Restituisce una chiave COUNTER in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public int getRCnt(string chiave)
        {
            int answInt = 0;
            string answ = "";
            try
            {
                answ = cache.StringGet(chiave);
                answInt = Convert.ToInt32(answ);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in getRSV:{Environment.NewLine}{exc}");
            }
            return answInt;
        }

        /// <summary>
        /// Restituisce un pò di info sul server redis connesso
        /// </summary>
        /// <returns></returns>
        public string getRedisInfoData()
        {
            string answ = "";
            StringBuilder sb = new StringBuilder();
            try
            {
                sb.AppendLine($"Configuration: {connRedis.Configuration}");
                sb.AppendLine($"Connected: {connRedis.IsConnected}");
                sb.AppendLine($"ClientName: {connRedis.ClientName}");
                sb.AppendLine($"Total Ops: {connRedis.OperationCount}");
                sb.AppendLine($"Status: {connRedis.GetStatus()}");
                answ = sb.ToString();
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Restituisce un set KVP (Key Value Pair) salvati in RedisCache
        /// </summary>
        /// <param name="chiavi"></param>
        /// <returns></returns>
        public RedisValue[] getRKeys(RedisKey[] chiavi)
        {
            RedisValue[] answ = null;
            try
            {
                answ = cache.StringGet(chiavi);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in getRKeys:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Restituisce una chiave salvata in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public string getRSV(string chiave)
        {
            string answ = "";
            try
            {
                answ = cache.StringGet(chiave);
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in getRSV:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// restituisco se ci sia un dato cookie
        /// </summary>
        /// <param name="nome"></param>
        /// <returns></returns>
        public bool hasCookieVal(string nome)
        {
            bool answ = false;
            if (HttpContext.Current.Request.Cookies[nome] != null)
            {
                try
                {
                    answ = HttpContext.Current.Request.Cookies[nome].Value != "";
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in hasCookieVal:{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo int
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public int IntSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
            }
            else
            {
                return -1;
            }
        }

        /// <summary>
        /// restituisce true se sia presente in cache l'oggetto richiesto
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool isInCacheObject(string nomeVar)
        {
            bool answ = false;
            bool stringAnsw = false;
            if (cacheOnRedis)
            {
                try
                {
                    // cerco come key...
                    var redVal = getRSV(redHash(nomeVar));
                    answ = !string.IsNullOrEmpty(redVal);
                    if (!answ)
                    {
                        answ = redKeyPresent(redHash(nomeVar));
                        // cerco come variabile se NON trovata...
                        if (!answ)
                        {
                            // cerco come hash...
                            answ = redHashPresent(redHash(nomeVar));
                        }
                    }
#if false
                    // cerco come key...
                    answ = redKeyPresent(redHash(nomeVar));
                    if (!answ)
                    {
                        // cerco come hash...
                        answ = redHashPresent(redHash(nomeVar));
                    }
                    // cerco come variabile se NON trovata...
                    if (!answ)
                    {
                        var redVal = getRSV(redHash(nomeVar));
                        answ = !string.IsNullOrEmpty(redVal);
                    }
#endif
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in verifica isInCacheObject REDIS per chiave{nomeVar}{Environment.NewLine}{exc}");
                }
            }
            else
            {
                // cerco di fare cast a stringa...
                try
                {
                    stringAnsw = HttpContext.Current.Cache[nomeVar].ToString() != "";
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in verifica HttpContext.Current.Cache per chiave{nomeVar}{Environment.NewLine}{exc}");
                }
                // infine condizione doppia...
                try
                {
                    answ = (HttpContext.Current.Cache[nomeVar] != null && stringAnsw);
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in verifica NULL per HttpContext.Current.Cache per chiave{nomeVar}{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// restituisce true se sia presente in session l'oggetto richiesto
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool isInSessionObject(string nomeVar)
        {
            bool answ = false;
            bool stringAnsw = false;
            // cerco se ci sia...
            try
            {
                //stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
                stringAnsw = HttpContext.Current.Session[nomeVar] != null;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore 01 | isInSessionObject:{Environment.NewLine}{exc}");
            }
            // infine condizione doppia...
            try
            {
                answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore 02 | isInSessionObject:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo long
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public long LongSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// carica dalla Cache un dato di tipo object generico
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public object objCacheObj(string nomeVar)
        {
            object answ = null;
            // ...se uso redis...
            if (cacheOnRedis)
            {
                answ = getRSV(redHash(nomeVar));
            }
            else
            {
                if (HttpContext.Current.Cache[nomeVar] != null)
                {
                    answ = HttpContext.Current.Cache[nomeVar];
                }
                else
                {
                    answ = "";
                }
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo object generico
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public object objSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return HttpContext.Current.Session[nomeVar];
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// recupera valore querystring BOOL
        /// </summary>
        /// <param name="nome"></param>
        /// <returns>valore string</returns>
        public bool QSB(string nome)
        {
            bool answ = false;
            try
            {
                answ = Convert.ToBoolean(HttpContext.Current.Request.QueryString[nome]);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in QSB:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// recupera valore querystring DATE
        /// </summary>
        /// <param name="nome"></param>
        /// <returns>valore DATE</returns>
        public DateTime QSD(string nome)
        {
            DateTime answ = DateTime.Now;
            try
            {
                answ = Convert.ToDateTime(HttpContext.Current.Request.QueryString[nome]);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in QSD:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// recupera valore querystring INT
        /// </summary>
        /// <param name="nome"></param>
        /// <returns>valore INT</returns>
        public int QSI(string nome)
        {
            int answ = 0;
            try
            {
                answ = Convert.ToInt32(HttpContext.Current.Request.QueryString[nome]);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in QSI:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// recupera valore querystring STRING
        /// </summary>
        /// <param name="nome"></param>
        /// <returns>valore string</returns>
        public string QSS(string nome)
        {
            string answ = "";
            if (HttpContext.Current.Request.QueryString[nome] != null)
            {
                try
                {
                    answ = HttpContext.Current.Request.QueryString[nome].ToString().Trim();
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in QSS:{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Conta num oggetti cache redis che rispondono a pattern
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <returns></returns>
        public int redCountKey(string keyPattern)
        {
            int answ = 0;
            // cerco se ci sia valore in redis... se vuoto = ALL...
            keyPattern = string.IsNullOrEmpty(keyPattern) ? "**" : keyPattern;
            try
            {
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern, database: _currDB.Database))
                    {
                        answ++;
                    }
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redCountKey:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// ELIMINA un SINGOLO VALORE dalla hash (dato field = chiave)
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool redDelHashField(string hashKey, string hashField)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                RedisValue campo = hashField;
                answ = cache.HashDelete(chiave, campo);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redDelHashField{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elimina una key (hash, string)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redDelKey(string key)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = key;
                cache.KeyDelete(chiave);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redDelKey:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Flush completo cache redis
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <returns></returns>
        public bool redFlushKey(string keyPattern)
        {
            bool answ = false;
            // cerco se ci sia valore in redis... se vuoto = ALL...
            keyPattern = string.IsNullOrEmpty(keyPattern) ? "**" : keyPattern;
            try
            {
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    var keys = server.Keys(database: confReadInt("redisDb"), pattern: $"{keyPattern}*");
                    foreach (var key in keys)
                    {
                        cache.KeyDelete(key);
                    }
                }
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redFlushKey{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Restituisce oggetti cache redis che rispondono a pattern
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <param name="orderBy">Tipo di ordinamento per kvp</param>
        /// <returns></returns>
        public List<KeyValuePair<string, int>> redGetCounterByKey(string keyPattern, kvpOrderBy orderBy)
        {
            int numAnsw = redCountKey(keyPattern);
            RedisKey[] chiavi = new RedisKey[numAnsw];
            List<KeyValuePair<string, int>> answ = new List<KeyValuePair<string, int>>();
            // se vuoto = ALL...
            keyPattern = string.IsNullOrEmpty(keyPattern) ? "**" : keyPattern;

            // recupero in primis elenco chiavi
            try
            {
                int i = 0;
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern))
                    {
                        chiavi[i] = key;
                        i++;
                    }
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redGetCounterByKey{Environment.NewLine}{exc}");
            }
            // ora recupero valori!
            var valori = getRKeys(chiavi);
            int currVal = 0;
            // popolo rispsota
            try
            {
                for (int i = 0; i < numAnsw; i++)
                {
                    Int32.TryParse(valori[i], out currVal);
                    answ.Add(new KeyValuePair<string, int>(chiavi[i], currVal));
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redGetCounterByKey 02{Environment.NewLine}{exc}");
            }
            // se richiesto riordino...
            switch (orderBy)
            {
                case kvpOrderBy.KeyAsc:
                    answ.Sort(CompareKey);
                    break;

                case kvpOrderBy.KeyDesc:
                    answ.Sort(CompareKeyDesc);
                    break;

                case kvpOrderBy.ValAsc:
                    answ.Sort(CompareVal);
                    break;

                case kvpOrderBy.ValDesc:
                    answ.Sort(CompareValDesc);
                    break;

                default:
                    break;
            }
            return answ;
        }

        /// <summary>
        /// Recupera tutti i valori dalla hash
        /// </summary>
        /// <param name="hashKey"></param>
        /// <returns></returns>
        public KeyValuePair<string, string>[] redGetHash(string hashKey)
        {
            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = cache.HashGetAll(chiave);
                answ = new KeyValuePair<string, string>[valori.Length];
                int i = 0;
                foreach (HashEntry item in valori)
                {
                    answ[i] = new KeyValuePair<string, string>(item.Name, item.Value);
                    i++;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redGetHash{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera tutti i valori dalla hash in formato Dictionary
        /// </summary>
        /// <param name="hashKey"></param>
        /// <returns></returns>
        public Dictionary<string, string> redGetHashDict(string hashKey)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = cache.HashGetAll(chiave);
                foreach (HashEntry item in valori)
                {
                    answ.Add(item.Name, item.Value);
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redGetHashDict{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera UN SINGOLO VALORE dalla hash per un dato field
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public string redGetHashField(string hashKey, string hashField)
        {
            string answ = "";
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                RedisValue campo = hashField;
                RedisValue valOut = cache.HashGet(chiave, campo);
                answ = valOut.ToString();
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redGetHashField{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco oggetti cache redis che rispondono a pattern
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <returns></returns>
        public List<RedisKey> redGetKeys(string keyPattern)
        {
            List<RedisKey> answ = new List<RedisKey>();
            // cerco se ci sia valore in redis... se vuoto = ALL...
            keyPattern = string.IsNullOrEmpty(keyPattern) ? "**" : keyPattern;
            try
            {
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern, database: _currDB.Database))
                    {
                        answ.Add(key);
                    }
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redGetKeys{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Nome della variabile HASH da utilizzare (dato CodModulo / Server / DB impiegato da
        /// funzionalita' DbConfig) + keyName richiesto...
        /// </summary>
        public string redHash(string keyName)
        {
            string answ = keyName;
            try
            {
                answ = string.Format("{0}:{1}:{2}:{3}", confReadString("CodModulo"), taConfig.Connection.DataSource, taConfig.Connection.Database, keyName).Replace("\\", "_");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHash{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Verifica se ci siano valori nella hash indicata...
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redHashPresent(RedisKey key)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                answ = cache.HashGetAll(key).Length > 0;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHashPresent | {key}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Verifica se ci siano valori nella hash indicata (string)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redHashPresentSz(string key)
        {
            bool answ = false;
            try
            {
                RedisKey chiave = key;
                answ = redHashPresent(chiave);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHashPresentSz | {key}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Verifica se ci siano valori nella KEY indicata...
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redKeyPresent(RedisKey key)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                answ = cache.KeyExists(key);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redKeyPresent | RedisKey: {key}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Verifica se ci siano valori nella KEY indicata (string)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redKeyPresentSz(string key)
        {
            bool answ = false;
            try
            {
                RedisKey chiave = key;
                answ = redKeyPresent(chiave);
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redKeyPresentSz | {key}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary>
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <returns></returns>
        public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = new HashEntry[hashFields.Length];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in hashFields)
                {
                    valori[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                cache.HashSet(chiave, valori);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redSaveHash{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary>
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <param name="expireSeconds">
        /// scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)
        /// </param>
        /// <returns></returns>
        public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields, double expireSeconds = -1)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                answ = redSaveHash(hashKey, hashFields);
                if (expireSeconds > 0)
                {
                    cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
                }
                //answ = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redSaveHash | {hashKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio di una hash di valori in formato Dictionary
        /// </summary>
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <returns></returns>
        public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = new HashEntry[hashFields.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in hashFields)
                {
                    valori[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                cache.HashSet(chiave, valori);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redSaveHashDict | {hashKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio di una hash di valori in formato Dictionary
        /// </summary>
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <param name="expireSeconds">
        /// scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)
        /// </param>
        /// <returns></returns>
        public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields, double expireSeconds = -1)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            try
            {
                RedisKey chiave = hashKey;
                answ = redSaveHashDict(hashKey, hashFields);
                if (expireSeconds > 0)
                {
                    cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
                }
                //answ = true;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary>
        /// <param name="hashKey">chiave</param>
        /// <param name="hashListKVP">valori come lista KVP</param>
        /// <returns></returns>
        public bool redSaveHashList(string hashKey, List<KeyValuePair<string, string>> hashListKVP)
        {
            bool answ = false;
            if (connRedis.IsConnected)
            {
                // cerco se ci sia valore in redis...
                IDatabase cache = connRedis.GetDatabase();
                try
                {
                    RedisKey chiave = hashKey;
                    HashEntry[] valori = new HashEntry[hashListKVP.Count];
                    int i = 0;
                    foreach (KeyValuePair<string, string> kvp in hashListKVP)
                    {
                        valori[i] = new HashEntry(kvp.Key, kvp.Value);
                        i++;
                    }
                    cache.HashSet(chiave, valori);
                    answ = true;
                }
                catch
                { }
            }
            return answ;
        }

        /// <summary>
        /// Restituisce info dei server connessi...
        /// </summary>
        /// <returns></returns>
        public IServer[] redServInfo()
        {
            IServer[] answ = new IServer[1];
            try
            {
                answ = new IServer[connRedisAdmin.GetEndPoints().Length];
                int i = 0;
                foreach (var ep in connRedisAdmin.GetEndPoints())
                {
                    var server = connRedisAdmin.GetServer(ep);
                    answ[i] = server;
                    i++;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"redServInfo:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// resetta AppConfig svuotando e rileggendo i dati...
        /// </summary>
        public void resetAppConf()
        {
            redDelKey(ACBH);
            startupAppConf();
        }

        /// <summary>
        /// Resetta (elimina) un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public bool resetRCnt(string chiave)
        {
            bool answ = false;
            try
            {
                answ = cache.KeyDelete(chiave);
            }
            catch (Exception exc)
            {
                Log.Error(string.Format("Eccezione in resetRCnt:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Serializzazione di un oggetto generico
        /// </summary>
        /// <param name="origVal"></param>
        /// <returns></returns>
        public string serializeVal(object origVal)
        {
            string answ = "";
            try
            {
                answ = JsonConvert.SerializeObject(origVal);
            }
            catch { }
            return answ;
        }

        /// <summary>
        /// inserisce in Cache un valore
        /// </summary>
        /// <param name="nomeVar">nome della variabile</param>
        /// <param name="valore">valore</param>
        public bool setCacheVal(string nomeVar, object valore)
        {
            bool _done = false;
            if (cacheOnRedis)
            {
                setRSV(redHash(nomeVar), valore.ToString());
                _done = true;
            }
            else
            {
                try
                {
                    HttpContext.Current.Cache[nomeVar] = valore;
                    _done = true;
                }
                catch
                { }
            }
            return _done;
        }

        /// <summary>
        /// inserisce in Cache un valore e su richiesta regitra tra le tab in cache da svuotare on update..
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="valore">valore</param>
        /// <param name="setInTabInCache">da registrare come tabella da svuotare on update</param>
        /// <returns></returns>
        public bool setCacheVal(string nome, object valore, bool setInTabInCache)
        {
            bool _done = setCacheVal(nome, valore);
            if (setInTabInCache)
            {
                addTabInCache(nome);
            }
            return _done;
        }

        /// <summary>
        /// salvo un valore come cookie
        /// </summary>
        /// <param name="nome"></param>
        /// <param name="valore"></param>
        /// <returns></returns>
        public bool setCookieVal(string nome, string valore)
        {
            bool _done = false;
            try
            {
                HttpCookie newCookie = new HttpCookie(nome, valore);
                HttpContext.Current.Response.AppendCookie(newCookie);
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// salvo un valore come cookie con expiry date esplicita
        /// </summary>
        /// <param name="nome"></param>
        /// <param name="valore"></param>
        /// <param name="expiryDate"></param>
        /// <returns></returns>
        public bool setCookieVal(string nome, string valore, DateTime expiryDate)
        {
            bool _done = false;
            try
            {
                // rimuovo vecchio cookie
                emptyCookieVal(nome);
                // creo nuovo cookie
                HttpCookie newCookie = new HttpCookie(nome, valore);
                newCookie.Expires = expiryDate;
                HttpContext.Current.Response.AppendCookie(newCookie);
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// Decrementa un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public long setRCntD(string chiave)
        {
            long answ = 0;
            try
            {
                answ = cache.StringDecrement(chiave, 1);
            }
            catch (Exception exc)
            {
                Log.Error(string.Format("Eccezzione in setRCD:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Incrementa un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public long setRCntI(string chiave)
        {
            long answ = 0;
            try
            {
                answ = cache.StringIncrement(chiave, 1);
            }
            catch (Exception exc)
            {
                Log.Error(string.Format("Eccezzione in setRCI:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Salva un set KVP (Key Value Pair) in RedisCache
        /// </summary>
        /// <param name="valori">Set KVP chiave-valore da salvare</param>
        /// <returns></returns>
        public bool setRKeys(KeyValuePair<RedisKey, RedisValue>[] valori)
        {
            bool answ = false;
            try
            {
                cache.StringSet(valori);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error(string.Format("Eccezione in setRKeys:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// Salva una chiave in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <returns></returns>
        public bool setRSV(string chiave, string valore)
        {
            bool answ = false;
            if (!string.IsNullOrEmpty(chiave))
            {
                try
                {
                    cache.StringSet(chiave, valore);
                    answ = true;
                }
                catch (Exception exc)
                {
                    Log.Error(string.Format("Eccezzione in setRSV:{0}{1}", Environment.NewLine, exc));
                }
            }
            else
            {
                Log.Error("Errore: chiave non valida (vuota) in setRSV");
            }
            return answ;
        }

        /// <summary>
        /// Salva una chiave in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <param name="TTL_sec">in secondi</param>
        /// <returns></returns>
        public bool setRSV(string chiave, string valore, int TTL_sec = 5)
        {
            bool answ = false;
            try
            {
                TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
                // salvo con expyry...
                cache.StringSet(chiave, valore, expT);
                answ = true;
            }
            catch (Exception exc)
            {
                Log.Error(string.Format("Eccezzione in setRSV:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }

        /// <summary>
        /// inserisce in session un DataSet (serializzandolo)
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="dSet">DataSet da salvare</param>
        public bool setSessionDataSet(string nome, DataSet dSet)
        {
            bool _done = false;
            try
            {
                string dataSer = JsonConvert.SerializeObject(dSet);
                _done = setSessionVal(nome, dataSer);
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// inserisce in session un DataSet (serializzandolo)
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="dSet">DataSet da salvare</param>
        /// <param name="surviveUpdate">
        /// indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)
        /// </param>
        /// <returns></returns>
        public bool setSessionDataSet(string nome, DataSet dSet, bool surviveUpdate)
        {
            bool _done = false;
            try
            {
                string dataSer = JsonConvert.SerializeObject(dSet);
                _done = setSessionVal(nome, dataSer, surviveUpdate);
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// inserisce in session un DataSet (serializzandolo)
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="dTable">DataTable da salvare</param>
        public bool setSessionDataTable(string nome, DataTable dTable)
        {
            bool _done = false;
            try
            {
                DataSet dataSet = new DataSet("dataSet");
                dataSet.Tables.Add(dTable);
                string dataSer = JsonConvert.SerializeObject(dataSet);
                _done = setSessionVal(nome, dataSer);
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// inserisce in session un DataSet (serializzandolo)
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="dTable">DataTable da salvare</param>
        /// <param name="surviveUpdate">
        /// indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)
        /// </param>
        public bool setSessionDataTable(string nome, DataTable dTable, bool surviveUpdate)
        {
            bool _done = false;
            try
            {
                DataSet dataSet = new DataSet("dataSet");
                dataSet.Tables.Add(dTable);
                string dataSer = JsonConvert.SerializeObject(dataSet);
                _done = setSessionVal(nome, dataSer, surviveUpdate);
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// inserisce in session un valore
        /// </summary>
        /// <param name="nome"></param>
        /// <param name="valore"></param>
        public bool setSessionVal(string nome, object valore)
        {
            bool _done = false;
            try
            {
                HttpContext.Current.Session[nome] = valore;
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// inserisce in session un valore
        /// </summary>
        /// <param name="nome">nome della variabile</param>
        /// <param name="valore">valore associato</param>
        /// <param name="surviveUpdate">
        /// indica se debba sopravvivere ad update (inserita in elenco valSess2SurvUpd)
        /// </param>
        /// <returns></returns>
        public bool setSessionVal(string nome, object valore, bool surviveUpdate)
        {
            bool _done = false;
            try
            {
                HttpContext.Current.Session[nome] = valore;
                if (surviveUpdate)
                {
                    addValInSession(nome, valore.ToString());
                }
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// carica dalla Cachee un dato di tipo string
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public string StringCacheObj(string nomeVar)
        {
            string answ = "";
            // ...se uso redis...
            if (cacheOnRedis)
            {
                answ = JsonConvert.DeserializeObject(getRSV(redHash(nomeVar))).ToString();
            }
            else
            {
                if (HttpContext.Current.Cache[nomeVar] != null)
                {
                    answ = HttpContext.Current.Cache[nomeVar].ToString();
                }
                else
                {
                    answ = "";
                }
            }
            return answ;
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo string
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public string StringSessionObj(string nomeVar)
        {
            string answ = "";
            try
            {
                if (HttpContext.Current.Session[nomeVar] != null)
                {
                    answ = HttpContext.Current.Session[nomeVar].ToString();
                }
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Aggiornamento di una chiave in tabella config
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        public void updateAppConf(string chiave, string valore)
        {
            // recupero valore attuale...
            memLayer nML = new memLayer();
            nML.taConfig.updateQuery(chiave, valore);
            resetAppConf();
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// lettore file configurazione
        /// </summary>
        protected AppSettingsReader configAppSetReader;

        /// <summary>
        /// Oggetto MongoDbCLient x accesso al motore
        /// </summary>
        protected MongoClient currMongoClient;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// stringa conn x DB CONF
        /// </summary>
        protected string connStringDbConf
        {
            get
            {
                string answ = "";
                answ = confReadString("DbConfConnectionString");
                // se fosse vuota fallback a path dei permessi...
                if (string.IsNullOrEmpty(answ))
                {
                    answ = confReadString("PermessiConnectionString");
                }
                // se ancora vuota --> devAuth
                if (string.IsNullOrEmpty(answ))
                {
                    answ = confReadString("DevicesAuthConnectionString");
                }
                return answ;
            }
        }

        /// <summary>
        /// Stringa di connessione mongoDb
        /// </summary>
        protected string mongoConnString
        {
            get
            {
                string answ = "";
                answ = confReadString("mdbConnString");
                if (string.IsNullOrEmpty(answ))
                {
                    answ = "mongodb://W2019-MONGODB:27017";
                }
                return answ;
            }
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// init dei table adapters
        /// </summary>
        protected void initTA()
        {
            taConfig = new DS_UtilityTableAdapters.ConfigTableAdapter();
            taConfigTmp = new DS_UtilityTableAdapters.ConfigTmpTableAdapter();
        }

        /// <summary>
        /// carica in ram oggetto AppConf
        /// </summary>
        /// <returns></returns>
        protected Dictionary<string, string> ricaricaAppConf()
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // istanzio un NUOVO oggetto x evitare problemi init contestuali
            memLayer nML = new memLayer();
            DS_Utility.ConfigDataTable tabDati = null;
            int waitMs = 100;
            int numTry = 5;
            do
            {
                try
                {
                    tabDati = nML.taConfig.GetData();
                }
                catch (Exception exc)
                {
                    numTry--;
                    Log.Error($"Errore procedura nML.taConfig.GetData(), numTry = {numTry}, now {waitMs}ms wait{Environment.NewLine}{exc}");
                    Thread.Sleep(waitMs);
                }
            } while (numTry > 0 && tabDati == null);
            if (tabDati != null)
            {
                // carico
                foreach (DS_Utility.ConfigRow riga in tabDati)
                {
                    try
                    {
                        answ.Add(riga.chiave, riga.valore);
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Errore procedura ricaricaAppConf per kvp: {riga.chiave} / {riga.valore}{Environment.NewLine}{exc}");
                    }
                }
                // log ricarica
                Log.Info($"Effettuata procedura ricaricaAppConf per {answ.Count} records");
            }
            return answ;
        }

        /// <summary>
        /// effettua setup dei connection strings da web.config delal singola applicazione
        /// </summary>
        protected virtual void setupConnectionStringBase()
        {
            // connections del db
            taConfig.Connection.ConnectionString = connStringDbConf;
            taConfigTmp.Connection.ConnectionString = connStringDbConf;
        }

        /// <summary>
        /// avvio oggetto AppConf in ram
        /// </summary>
        protected void startupAppConf()
        {
            // SOLO SE ho la chiave x abilitare config su DB...
            if (confReadString("DbConfConnectionString") != "")
            {
                try
                {
                    if (redKeyPresent(ACBH))
                    {
                        AppConf = new Dictionary<string, string>();
                        foreach (var item in redGetHash(ACBH))
                        {
                            if (AppConf.ContainsKey(item.Key))
                            {
                                AppConf[item.Key] = item.Value;
                            }
                            else
                            {
                                AppConf.Add(item.Key, item.Value);
                            }
                        }
                    }
                    else
                    {
                        AppConf = ricaricaAppConf();
                        if (AppConf.Count > 0)
                        {
                            KeyValuePair<string, string>[] valori = new KeyValuePair<string, string>[AppConf.Count];
                            int i = 0;
                            foreach (var item in AppConf)
                            {
                                valori[i] = new KeyValuePair<string, string>(item.Key, item.Value);
                                i++;
                            }
                            // salvo in redis valori (con TTL)
                            redSaveHash(ACBH, valori, maxAgeAppConf);
                            // salvo info cache riletta 2 sec prima della scadenza
                            vetoCacheCheck = DateTime.Now.AddSeconds(maxAgeAppConf + 1);
                            Log.Info("Completato procedura startupAppConf");
                        }
                        else
                        {
                            Log.Error("Errore in procedura startupAppConf, ritornato insieme vuoto");
                        }
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in startupAppConf:{Environment.NewLine}{exc}");
                }
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Connessione lazy a redis...
        /// </summary>
        private Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            string RedisConn = memLayer.ML.confReadString("RedisConn");
            if (string.IsNullOrEmpty(RedisConn))
            {
                RedisConn = "localhost,abortConnect=false,ssl=false";
            }

            return ConnectionMultiplexer.Connect(RedisConn);
        });

        /// <summary>
        /// Connessione lazy a redis...
        /// </summary>
        private Lazy<ConnectionMultiplexer> lazyConnectionAdmin = new Lazy<ConnectionMultiplexer>(() =>
        {
            string RedisConnAdmin = memLayer.ML.confReadString("RedisConnAdmin");
            if (string.IsNullOrEmpty(RedisConnAdmin))
            {
                RedisConnAdmin = "localhost,abortConnect=false,ssl=false,allowAdmin=true";
            }

            return ConnectionMultiplexer.Connect(RedisConnAdmin);
        });

        private DateTime vetoCacheCheck = DateTime.Now;

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Oggetto currentDb locale
        /// </summary>
        private IDatabase _currDB { get; set; }

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Effettua comaprazione x CHIAVE in KVP ASC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private int CompareKey(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return x.Key.CompareTo(y.Key);
        }

        /// <summary>
        /// Effettua comaprazione x CHIAVE in KVP DESC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private int CompareKeyDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return y.Key.CompareTo(x.Key);
        }

        /// <summary>
        /// Init accesso MongoDb
        /// </summary>
        private void setupMongo()
        {
            currMongoClient = new MongoClient(mongoConnString);
        }

        private void setupParams()
        {
            // default 5 minuti x refresh...
            int maxAge = 5;
            try
            {
                maxAge = confReadInt("maxAgeAppConf_min");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in lettura valore maxAgeAppConf_min{Environment.NewLine}{exc}");
            }
            // controllo maxage valida...
            if (maxAge < 1)
            {
                maxAge = 5;
            }
            maxAgeAppConf = maxAge * 60;
        }

        #endregion Private Methods
    }
}