using EgwCoreLib.Razor.Data;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;
using System.Text;
using WebDoorCreator.Core;
using WebDoorCreator.Data.Controllers;
using WebDoorCreator.Data.DbModels;

namespace WebDoorCreator.UI.Data
{
    public class WebDoorCreatorService
    {
        #region Public Fields

        public static WebDoorCreatorController dbController = null!;

        #endregion Public Fields

        #region Public Constructors

        public WebDoorCreatorService(IConfiguration configuration, IConnectionMultiplexer redisConnMult, IEmailSender emailSender)
        {
            _configuration = configuration;
            _emailSender = emailSender;
            // Conf cache
            redisConn = redisConnMult;
            redisDb = this.redisConn.GetDatabase();

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

            // cod app
            CodApp = _configuration["CodApp"];
            // Conf DB
            string connStr = _configuration.GetConnectionString("WDC.DB");
            if (string.IsNullOrEmpty(connStr))
            {
                Log.Info("ConnString empty!");
            }
            else
            {
                dbController = new WebDoorCreatorController(configuration);
            }
            Log.Info("Avviata classe WebDoorCreatorService");
        }

        #endregion Public Constructors

        #region Public Properties

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

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Update company
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> CompanyAddMod(CompanyModel currRec)
        {
            var dbResult = await dbController.CompanyAddMod(currRec);
            // elimino cache redis...
            RedisValue pattern = new RedisValue($"{Constants.rKeyCompany}");
            bool answ = await ExecFlushRedisPattern(pattern);
            await Task.Delay(1);
            return dbResult;
        }

        /// <summary>
        /// Company list filtered by company id
        /// </summary>
        /// <param name="id">Id to filter (0=ALL)</param>
        /// <returns></returns>
        public async Task<List<CompanyModel>> CompanyGetByKey(int id)
        {
            string source = "DB";

            List<CompanyModel> dbResult = new List<CompanyModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyCompany}:{id}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<CompanyModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<CompanyModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.CompanyGetByKey(id);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<CompanyModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"CompanyGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /*----------------------------------------------------------------------------------------------------------------------*/

        /// <summary>
        /// Getting a list of all the active components
        /// </summary>
        /// <param name="rootPath">Path to start</param>
        /// <returns></returns>
        public async Task<List<string>> CompoGetAllActive(string rootPath)
        {
            await Task.Delay(1);
            List<string> listActiveCompo = new List<string>();

            //estraggo la lista di componenti che sono attive per il cliente
            IniFile fIni = new IniFile(rootPath);
            string compoDDF = fIni.ReadString("CompoOrder", "CompoDDFOrder", "CONFIG");
            var compoDDFList = compoDDF.Split(",");
            foreach (string compo in compoDDFList)
            {
                listActiveCompo.Add(compo.Trim());
            }

            return listActiveCompo;
        }

        /// <summary>
        /// Setting all the component list
        /// </summary>
        /// <param name="rootPath">Path to start</param>
        /// <returns></returns>
        public async Task<bool> CompoListSetAll(string rootPath)
        {
            bool fatto = false;
            string compoName = "";
            string edgeType = "";
            string sizeVal = "";
            string swingType = "";
            int numHier = 1;
            List<GraphicParamsModel> listGraphicParams = new List<GraphicParamsModel>();
            List<ListValuesTempModel> listValues = new List<ListValuesTempModel>();
            ListValuesTempModel Values = new ListValuesTempModel();

            dbController.TestTablesTruncate();

            List<string> listActiveCompo = await CompoGetAllActive(Path.Combine(rootPath, @"Default.ini"));
            List<HardwareModel> listCompoS = new List<HardwareModel>();
            //estraggo tutte le sotto directory della cartella \EgtData\Doors\EgtCompoBase\Compo
            string[] dirs = Directory.GetDirectories(rootPath, "*", SearchOption.TopDirectoryOnly);

            // elenco obj da inserire
            List<DoorOpTypeModel> ListObjDOT = new List<DoorOpTypeModel>();

            string[] DefaultFile = Directory.GetFiles(rootPath, "Default.ini");

            IniFile fIniDef = new IniFile(DefaultFile[0]);

            // parto con obj base
            sizeVal = fIniDef.ReadString("Size", "Width", "0.0");

            ListValuesTempModel listValObj = new ListValuesTempModel()
            {
                TableName = "Size",
                FieldName = "DoorDef",
                Value = "Width",
                Label = "50001",
                Ordinal = 1,
                DefaultVal = sizeVal,
                InputType = "TextBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            sizeVal = fIniDef.ReadString("Size", "Height", "0.0");
            listValObj = new ListValuesTempModel()
            {
                TableName = "Size",
                FieldName = "DoorDef",
                Value = "Height",
                Label = "50002",
                Ordinal = 2,
                DefaultVal = sizeVal,
                InputType = "TextBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            sizeVal = fIniDef.ReadString("Size", "Thickness", "0.0");
            listValObj = new ListValuesTempModel()
            {
                TableName = "Size",
                FieldName = "DoorDef",
                Value = "Thickness",
                Label = "50003",
                Ordinal = 3,
                DefaultVal = sizeVal,
                InputType = "TextBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            sizeVal = fIniDef.ReadString("Size", "SwingList", "UNDEF");
            listValObj = new ListValuesTempModel()
            {
                TableName = "Swing",
                FieldName = "DoorDef",
                Value = "Swing",
                Label = "50004",
                Ordinal = 1,
                DefaultVal = sizeVal,
                InputType = "TextBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            //sizeVal = fIniDef.ReadString("Edge", "EdgeTypeList", "UNDEF");
            StringBuilder edgesList = new StringBuilder();
            for (int x = 1; x <= 11; x++)
            {
                var edge = fIniDef.ReadString("Edge", $"EdgeType{x}", "UNDEF");
                if (x != 11)
                {
                    edgesList.Append($"{edge.Split("/")[0]},");
                }
                else
                {
                    edgesList.Append($"{edge.Split("/")[0]}");
                }
            }
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "lockedge",
                Label = "50005",
                Ordinal = 1,
                DefaultVal = "",
                InputType = "",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "hingeedge",
                Label = "50006",
                Ordinal = 2,
                DefaultVal = "",
                InputType = "",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "top",
                Label = "50007",
                Ordinal = 3,
                DefaultVal = "",
                InputType = "",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "bottom",
                Label = "50008",
                Ordinal = 4,
                DefaultVal = "",
                InputType = "",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "type",
                Label = "50424",
                Ordinal = 5,
                DefaultVal = edgesList.ToString(),
                InputType = "ComboBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "machining",
                Label = "90312",
                Ordinal = 6,
                DefaultVal = "ON,OFF",
                InputType = "ComboBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            listValObj = new ListValuesTempModel()
            {
                TableName = "Profiles",
                FieldName = "DoorDef",
                Value = "overmaterial",
                Label = "90312",
                Ordinal = 7,
                DefaultVal = "0.1",
                InputType = "ComboBox",
                isSerializable = true
            };
            listValues.Add(listValObj);
            foreach (string dir in dirs)
            {
                int numPar = 1;
                int numHead = 1;
                // scansione della directory...
                string[] files = Directory.GetFiles(dir, "Config.ini");

                compoName = "";
                //iterazione per cercare tutti numPar file "Config.ini" nelle sotto directory
                foreach (string file in files)
                {
                    //leggo tutte le linee del file
                    List<string> lines = File.ReadAllLines(file).ToList();
                    IniFile fIni = new IniFile(file);
                    Guid opCode = Guid.NewGuid();
                    //cerco la sezione del file ed estraggo il nome del componente
                    compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                    //cerco la sezione del file ed estraggo se numPar template sono attivi per il seguente componente
                    var isActive = fIni.ReadString("Template", "IsActive", "1");
                    bool compoTemplateIsActive = true;
                    string layerName = fIni.ReadString("Layer", "LayerName", "LAYER");
                    if (isActive == "0")
                    {
                        compoTemplateIsActive = false;
                    }
                    // lo slash indica l'alias
                    var compoNameSplit = compoName.Split("/");
                    if (listActiveCompo.Contains(compoNameSplit[0].ToString()))
                    {
                        //creo il componente (padre)
                        listValObj = new ListValuesTempModel()
                        {
                            TableName = $"{compoNameSplit[0]}".Trim(),
                            FieldName = "Hardware",
                            Value = $"{compoNameSplit[0]}",
                            Label = $"{compoNameSplit[1]}",
                            Ordinal = 0,
                            DefaultVal = " ",
                            InputType = " "
                        };
                        //HardwareModel compoConfig = new HardwareModel() { compoName = $"{compoNameSplit[0]}", compoAlias = compoNameSplit[1].ToString(), compoLayerName = layerName, compoTemplateIsActive = compoTemplateIsActive };
                        //await dbController.CompoAdd(compoConfig);
                        //listCompoS.Add(compoConfig);
                        listValues.Add(listValObj);
                        //cerco all'interno del file tutte le sezioni che contengono "[Graphic" così da poter prendere il nome della sezione ES: [Graphic parameters1] = Graphic parameters1
                        var lineToSearch = lines.Where(x => x.Contains("[Graphic")).ToList();
                        numHead = 1;
                        foreach (var match in lineToSearch)
                        {
                            var listV = await GraphicParamsGetAll(file, match, numHead, numPar, $"{compoNameSplit[0]}");

                            foreach (var item in listV)
                            {
                                listValues.Add(item);
                            }

                            numHead++;
                        }
                        numPar++;
                    }
                }
            }

            fatto = await dbController.ListValuesAdd(listValues);

            return fatto;
        }

        public string DecriptData(string encData)
        {
            return SteamCrypto.DecryptString(encData, Constants.passPhrase);
        }

        /// <summary>
        /// CElimina record posta
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> DoorDelete(DoorModel currRec)
        {
            int DoorId = currRec.DoorId;
            int OrderId = currRec.OrderId;
            // elimino sul DB
            bool answ = await dbController.DoorDelete(DoorId);
            // svuoto cache
            await DoorFlushCache(DoorId);
            await DoorOpFlushCache(DoorId);
            await OrderDetailFlushCache(OrderId);
            await OrdersFlushCache();
            return answ;
        }

        /// <summary>
        /// Clean redis DOORS cache
        /// </summary>
        /// <param name="DoorId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> DoorFlushCache(int DoorId)
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyDoor}:*");
            if (DoorId > 0)
            {
                pattern = new RedisValue($"{Constants.rKeyDoor}:{DoorId}:*");
            }
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        /// <summary>
        /// Doors list by orderId
        /// </summary>
        public async Task<List<DoorModel>?> DoorGetByOrderId(int orderId)
        {
            string source = "DB";
            List<DoorModel>? dbResult = new List<DoorModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyOrderDetail}:{orderId}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DoorModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DoorModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.DoorsGetByOrderId(orderId);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<DoorModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DoorGetByOrderId | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Add door
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<int> DoorInsert(DoorModel newRec)
        {
            var dbResult = await dbController.DoorInsert(newRec);
            // elimino cache redis dati ordine...
            await OrderDetailFlushCache(newRec.OrderId);
            await OrdersFlushCache();
            return dbResult;
        }

        /// <summary>
        /// Adding or removing a single door
        /// </summary>
        /// <param name="DoorId">Record id to edit or add</param>
        /// <param name="isAdd">States if it has to be added or removing a door</param>
        /// <returns></returns>
        public async Task<bool> DoorModQty(int OrderId, int DoorId, bool isAdd)
        {
            var dbResult = await dbController.DoorModQty(DoorId, isAdd);
            // svuoto cache
            await DoorFlushCache(DoorId);
            await DoorOpFlushCache(DoorId);
            await OrderDetailFlushCache(OrderId);
            await OrdersFlushCache();
            return dbResult;
        }

        /// <summary>
        /// Eliminazione DoorOP
        /// </summary>
        /// <param name="currDoorOp"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpDelete(DoorOpModel currDoorOp)
        {
            var dbResult = await dbController.DoorOpDelete(currDoorOp);
            // elimino cache redis dati porta...
            bool answ = await DoorOpFlushCache(currDoorOp.DoorId);
            answ = answ && await DoorFlushCache(currDoorOp.DoorId);
            // elimino cache redis dati ordine...
            answ = answ && await OrdersFlushCache();
            return dbResult;
        }

        /// <summary>
        /// Eliminazione DoorOP list
        /// </summary>
        /// <param name="currDoorOpList"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpDeleteRange(List<DoorOpModel> currDoorOpList)
        {
            var dbResult = await dbController.DoorOpDeleteRange(currDoorOpList);
            // elimino cache redis dati porta...
            foreach (var item in currDoorOpList)
            {
                bool answ = await DoorOpFlushCache(item.DoorId);
                answ = answ && await DoorFlushCache(item.DoorId);
                // elimino cache redis dati ordine...
                answ = answ && await OrdersFlushCache();
            }
            return dbResult;
        }

        /// <summary>
        /// Clean redis DOORS OP cache
        /// </summary>
        /// <param name="DoorId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> DoorOpFlushCache(int DoorId)
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyDoorOp}*");
            if (DoorId > 0)
            {
                pattern = new RedisValue($"{Constants.rKeyDoorOp}:{DoorId}*");
            }
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        /// <summary>
        /// Doors list by orderId
        /// </summary>
        public async Task<List<DoorOpModel>?> DoorOpGetByDoorId(int doorId)
        {
            string source = "DB";
            List<DoorOpModel>? dbResult = new List<DoorOpModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyDoorOp}:{doorId}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DoorOpModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DoorOpModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.DoorOpGetByDoorId(doorId);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<DoorOpModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DoorOpGetByDoorId | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// lista DoorOpList necessarie all'init
        /// </summary>
        /// <returns></returns>
        public async Task<List<DoorOpTypeModel>> DoorOpGetDefault()
        {
            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            string source = "DB";
            // cerco da cache
            string currKey = $"{Constants.rKeyDoorOpType}:DEFAULT";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
#if false
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DoorOpTypeModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DoorOpTypeModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
#endif
            dbResult = await dbController.DoorOpTypeGetDefault();
#if false
            rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
            await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
        }
#endif
            if (dbResult == null)
            {
                dbResult = new List<DoorOpTypeModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DoorOpGetDefault | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Add doorOP list
        /// </summary>
        /// <param name="DoorId"></param>
        /// <param name="newOpList"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpInsert(int DoorId, List<DoorOpModel> newOpList)
        {
            var dbResult = await dbController.DoorOpInsert(newOpList);
            // elimino cache redis dati porta...
            bool answ = await DoorOpFlushCache(DoorId);
            answ = answ && await DoorFlushCache(DoorId);
            // elimino cache redis dati ordine...
            answ = answ && await OrdersFlushCache();
            return dbResult;
        }

        /// <summary>
        /// Doors list by orderId
        /// </summary>
        public async Task<List<DoorOpTypeModel>?> DoorOpTypeGetAll()
        {
            string source = "DB";
            List<DoorOpTypeModel>? dbResult = new List<DoorOpTypeModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyDoorOpType}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
#if false
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DoorOpTypeModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DoorOpTypeModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
            rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
            await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
#endif
            dbResult = dbController.DoorOpTypeGetAll();
            if (dbResult == null)
            {
                dbResult = new List<DoorOpTypeModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DoorOpTypeGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Aggiornamento DoorOP
        /// </summary>
        /// <param name="currDoorOp"></param>
        /// <returns></returns>
        public async Task<bool> DoorOpUpdate(DoorOpModel currDoorOp)
        {
            var dbResult = await dbController.DoorOpUpdate(currDoorOp);
            // elimino cache redis dati porta...
            bool answ = await DoorOpFlushCache(currDoorOp.DoorId);
            answ = answ && await DoorFlushCache(currDoorOp.DoorId);
            // elimino cache redis dati ordine...
            answ = answ && await OrdersFlushCache();
            return dbResult;
        }

        /// <summary>
        /// Update or add door
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> DoorUpsert(DoorModel currRec)
        {
            var dbResult = await dbController.DoorUpsert(currRec);
            // elimino cache redis dati porta...
            bool answ = await DoorFlushCache(currRec.DoorId);
            // elimino cache redis dati ordine...
            answ = answ && await OrdersFlushCache();
            return dbResult;
        }

        public string EncriptData(string rawData)
        {
            return SteamCrypto.EncryptString(rawData, Constants.passPhrase);
        }

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

        public async Task<List<ListValuesTempModel>> GraphicParamsGetAll(string file, string match, int n, int i, string HwCode)
        {
            await Task.Delay(1);
            List<ListValuesTempModel> listValuesTemp = new List<ListValuesTempModel>();
            ListValuesTempModel listValObj = new ListValuesTempModel();

            IniFile fIni = new IniFile(file);
            //cerco il contenuto delle sezioni
            var graphicParamsName = fIni.ReadSection(match.Substring(1, match.Length - 2));
            //controllo se tra numPar numeri di graphic params vi è un buco ES: Graphic parameters1  Graphic parameters3   se il buco c'è salto tutti numPar parametri che stanno dopo il buco ==> tengo conto solo di Graphic parameters1
            if (int.Parse(match.Substring(match.Length - 2, 1)) == n)
            {
                int ordinal = 1;
                foreach (string param in graphicParamsName)
                {
                    string compoParams = fIni.ReadString(match.Substring(1, match.Length - 2), $"{param.Split("=")[0]}", "CONFIG"); //cerco il parametro nella sezione
                    var compoParamsSplit = compoParams.Split(";");

                    string CompoParamName = "";
                    string CompoParamAlias = "";
                    if (param.Split("=")[0].StartsWith("Param"))
                    {
                        if (compoParamsSplit[1].Contains("/"))
                        {
                            CompoParamName = compoParamsSplit[1].Split("/")[0];
                            CompoParamAlias = compoParamsSplit[1].Split("/")[1];
                        }
                        else if (compoParamsSplit[1].Contains(" "))
                        {
                            CompoParamName = compoParamsSplit[1].Split(" ")[1];
                            //CompoParamAlias = compoParamsSplit[1].Split(" ")[1];
                        }

                        //creo nuovo oggetto parametro che conterrà anche il nome del componente per creare relazione

                        listValObj = new ListValuesTempModel()
                        {
                            TableName = $"{HwCode}".Trim(),
                            FieldName = match.Substring(1, match.Length - 2),
                            Value = CompoParamName,
                            Label = CompoParamAlias,
                            Ordinal = ordinal,
                            DefaultVal = param.Split("=")[1].Split(";")[2],
                            InputType = param.Split("=")[1].Split(";")[0],
                            isSerializable = true
                        };

                        if (listValuesTemp.Where(x => x.TableName == listValObj.TableName && x.FieldName == listValObj.FieldName && x.Value == listValObj.Value).Count() == 0 && listValObj.TableName != null && listValObj.FieldName != null && listValObj.Value != null)
                        {
                            listValuesTemp.Add(listValObj);
                            ordinal++;
                        }
                        else
                        {
                            Log.Error($"GraphicParamsGetAll | Duplicated key: {listValObj.TableName} {listValObj.FieldName} {listValObj.Value} ");
                        }
                    }
                    else
                    {
                    }
                }
            }

            return listValuesTemp;
        }

        /// <summary>
        /// Estraggo tutte le lingue disponibili per questa applicazione
        /// </summary>
        /// <returns></returns>
        public async Task<List<LanguageModel>?> LanguageGetAll()
        {
            string source = "DB";

            List<LanguageModel>? dbResult = new List<LanguageModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyLanguage}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<LanguageModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<LanguageModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.LanguageGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<LanguageModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"LanguageGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// List values
        /// </summary>
        public async Task<List<ListValuesModel>?> ListValuesGetAll(string tableName, string fieldName)
        {
            string source = "DB";

            List<ListValuesModel>? dbResult = new List<ListValuesModel>();
            string currKey = "";
            // cerco da cache
            currKey = $"{Constants.rKeyListValues}:{tableName}:{fieldName}";

            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<ListValuesModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<ListValuesModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.ListValuesGetAll(tableName, fieldName);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<ListValuesModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ListValuesGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }
        /// <summary>
        /// Effettua il setup dei Graph parameters date info template selezionato
        /// </summary>
        /// <param name="currDoorOp"></param>
        /// <returns></returns>
        public async Task<DoorOpModel> DoorOpSetupGraphParams(DoorOpModel currDoorOp)
        {
            string default2Design = "";
            Dictionary<string, string>? actDict = new Dictionary<string, string>();
            Dictionary<string, string>? actDictNew = new Dictionary<string, string>();
            Dictionary<string, List<string>>? defaultDictNew = new Dictionary<string, List<string>>();
            // per prima cosa deserializzo i valori attuali dal record...
            if (!string.IsNullOrEmpty(currDoorOp.JsoncActVal))
            {
                actDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(currDoorOp.JsoncActVal);
                // verifico di avere valori validi
                if (actDict != null)
                {
                    // cerco il setup del template selezionato
                    var listRecordTmp = await ListValuesGetAll(currDoorOp.ObjectId, "template");
                    if (listRecordTmp != null && actDict.ContainsKey("Folder") && actDict.ContainsKey("template"))
                    {
                        string actKey = actDict["template"];// Path.Combine(actDict["Folder"], actDict["template"]);
                        var firstTemplate = listRecordTmp.Where(x => x.Value == actKey).FirstOrDefault();
                        if (firstTemplate != null)
                        {
                            if (firstTemplate.DefaultVal != "")
                            {
                                default2Design = firstTemplate.DefaultVal;
                            }
                            else
                            {
                                default2Design = "1";
                            }
                        }
                        // elimino dai valori di setup e attuali quanto non sia template/folder...
                        actDictNew = actDict.Where(x => x.Key == "Folder" || x.Key == "template").ToDictionary(x => x.Key, x => x.Value);
                        // preparo setup valori
                        List<string> listDefVal = new List<string>();
                        var listRecordGP = await ListValuesGetAll(currDoorOp.ObjectId, $"Graphic Parameters{default2Design}");
                        if (listRecordGP != null)
                        {
                            foreach (var item in listRecordGP)
                            {
                                if (item.isSerializable && item.DefaultVal.Contains(","))
                                {
                                    listDefVal = item.DefaultVal.Trim().Split(",").ToList();
                                    actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim().Split(",")[0].Split("/")[0]);
                                }
                                else
                                {
                                    if (item.DefaultVal.Contains("/"))
                                    {
                                        listDefVal = new List<string>() { item.DefaultVal.Trim().Split("/")[0] };
                                        actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim().Split("/")[0]);
                                    }
                                    else
                                    {
                                        listDefVal = new List<string>() { item.DefaultVal.Trim() };
                                        actDictNew.Add(item.Value.Trim(), item.DefaultVal.Trim());
                                    }
                                }
                                //defaultParamsList.Add(listDefVal);
                                defaultDictNew.Add(item.Value.Trim(), listDefVal);
                            }
                        }
                        // ri-serializzo e salvo!
                        currDoorOp.JsoncActVal = JsonConvert.SerializeObject(actDictNew);
                        currDoorOp.JsoncConfigVal = JsonConvert.SerializeObject(defaultDictNew);
                    }
                }
            }
            return currDoorOp;
        }

        /// <summary>
        /// Restitusice i CurrVals + GraphParams aggiornati dati valori Folder/template
        /// </summary>
        /// <param name="ObjectId">Obj x cui è richiesto il ricalcolo parametri</param>
        /// <param name="currVal">Dizionario dei valori attuali</param>
        /// <param name="currParams">Dizionario di obj x GraphParams</param>
        /// <returns></returns>
        public async Task<(Dictionary<string, string>, Dictionary<string, List<string>>)> DoorOpGetUpdatedVals(string ObjectId, Dictionary<string, string> currVal, Dictionary<string, List<string>> currParams)
        {
            await Task.Delay(1);
            // duplico oggetti da tornare
            Dictionary<string, string> currValUpd = new Dictionary<string, string>();
            Dictionary<string, List<string>> currParamsUpd = new Dictionary<string, List<string>>();
            string default2Design = "";
            // cerco il setup del template selezionato
            var listRecordTmp = await ListValuesGetAll(ObjectId, "template");
            if (listRecordTmp != null && currVal.ContainsKey("Folder") && currVal.ContainsKey("template"))
            {
                string actKey = currVal["template"];
                var firstTemplate = listRecordTmp.Where(x => x.Value == actKey).FirstOrDefault();
                if (firstTemplate != null)
                {
                    if (firstTemplate.DefaultVal != "")
                    {
                        default2Design = firstTemplate.DefaultVal;
                    }
                    else
                    {
                        default2Design = "1";
                    }
                }
                // elimino dai valori di setup e attuali quanto non sia template/folder...
                currValUpd = currVal.Where(x => x.Key == "Folder" || x.Key == "template").ToDictionary(x => x.Key, x => x.Value);
                // preparo setup valori
                List<string> listDefVal = new List<string>();
                var listRecordGP = await ListValuesGetAll(ObjectId, $"Graphic Parameters{default2Design}");
                if (listRecordGP != null)
                {
                    foreach (var item in listRecordGP)
                    {
                        if (item.isSerializable && item.DefaultVal.Contains(","))
                        {
                            listDefVal = item.DefaultVal.Trim().Split(",").ToList();
                            currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim().Split(",")[0].Split("/")[0]);
                        }
                        else
                        {
                            if (item.DefaultVal.Contains("/"))
                            {
                                listDefVal = new List<string>() { item.DefaultVal.Trim().Split("/")[0] };
                                currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim().Split("/")[0]);
                            }
                            else
                            {
                                listDefVal = new List<string>() { item.DefaultVal.Trim() };
                                currValUpd.Add(item.Value.Trim(), item.DefaultVal.Trim());
                            }
                        }
                        //defaultParamsList.Add(listDefVal);
                        currParamsUpd.Add(item.Value.Trim(), listDefVal);
                    }
                }
            }
            return (currValUpd, currParamsUpd);
        }


        public async Task<bool> ListValuesLuaNgeInsert(string rootPath)
        {
            List<ListValuesTempModel> values = new List<ListValuesTempModel>();
            string[] dirs = Directory.GetDirectories(rootPath);
            foreach (string dir in dirs)
            {
                string compoCode = "";
                string[] templateDirectories = Directory.GetDirectories(dir);

                string[] iniFiles = Directory.GetFiles(dir, "Config.ini");

                int ordin = 1;
                foreach (string templateDirectory in templateDirectories)
                {
                    var tName = templateDirectory.Split("\\");
                    var fName = templateDirectory.Split("\\");

                    foreach (var file in iniFiles)
                    {
                        List<string> lines = File.ReadAllLines(file).ToList();
                        IniFile fIni = new IniFile(file);

                        var compoName = fIni.ReadString("Compo", "Name", "COMPONAME");
                        compoCode = compoName.Split("/")[0].Trim();
                    }
                    string[] templateFiles = Directory.GetFiles(templateDirectory);
                    if (templateFiles.Length > 0)
                    {
                        ListValuesTempModel folderNames = new ListValuesTempModel()
                        {
                            TableName = $"{compoCode}".Replace(" ", "_"),
                            FieldName = "Folder",
                            Value = @$"{tName[tName.Length - 1]}",
                            Label = @$"{tName[tName.Length - 1]}",
                            Ordinal = 0,
                            DefaultVal = " ",
                            InputType = " ",
                        };
                        values.Add(folderNames);
                    }

                    foreach (string templateFile in templateFiles)
                    {
                        string defGpNum = "";
                        var lines = File.ReadAllLines(templateFile).ToList();

                        foreach (var line in lines)
                        {
                            if (line.StartsWith("--") && line.Contains("Default"))
                            {
                                if (line.Split("=")[1] != null)
                                {
                                    defGpNum = line.Split("=")[1];
                                }
                                else
                                {
                                    defGpNum = " ";
                                }
                            }
                        }

                        ListValuesTempModel temp = new ListValuesTempModel()
                        {
                            TableName = $"{compoCode}".Replace(" ", "_"),
                            FieldName = "template",
                            Value = @$"{tName[tName.Length - 1]}\{Path.GetFileName(templateFile).Split(".")[0]}",
                            Label = Path.GetFileName(templateFile).Split(".")[0],
                            Ordinal = ordin,
                            DefaultVal = defGpNum,
                            InputType = " ",
                        };

                        if (values.Where(x => x.TableName == temp.TableName && x.FieldName == temp.FieldName && x.Value == temp.Value).Count() == 0 && temp.TableName != null && temp.FieldName != null && temp.Value != null)
                        {
                            values.Add(temp);
                            ordin++;
                        }
                        else
                        {
                            Log.Error($"GraphicParamsGetAll | Duplicated key: {temp.TableName} {temp.FieldName} {temp.Value} ");
                        }
                    }
                }
            }

            bool fatto = await dbController.ListValuesAdd(values);

            return fatto;
        }

        /// <summary>
        /// Add new order
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> OrderAdd(OrderModel currRec)
        {
            var dbResult = await dbController.OrderAdd(currRec);
            // elimino cache redis...
            RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return dbResult;
        }

        /// <summary>
        /// Clean REDIS order detail data in cache
        /// </summary>
        /// <param name="OrderId">0 = all</param>
        /// <returns></returns>
        public async Task<bool> OrderDetailFlushCache(int OrderId)
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyOrderDetail}:*");
            if (OrderId > 0)
            {
                pattern = new RedisValue($"{Constants.rKeyOrderDetail}:{OrderId}");
            }
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        /// <summary>
        /// Remove order
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> OrderRem(int OrdId)
        {
            var dbResult = await dbController.OrderRem(OrdId);
            // elimino cache redis...
            RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return dbResult;
        }

        /// <summary>
        /// Clean redis ORDERS cache
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> OrdersFlushCache()
        {
            RedisValue pattern = new RedisValue($"{Constants.rKeyOrderStatus}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        public async Task<List<OrderStatusViewModel>?> OrderStatusGetFilt(int companyId, int orderStatus, DateTime dataFrom, DateTime dataTo)
        {
            string source = "DB";

            List<OrderStatusViewModel>? dbResult = new List<OrderStatusViewModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyOrderStatus}:{companyId}:{orderStatus}:{dataFrom:yyyyMMdd}:{dataTo:yyyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<OrderStatusViewModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<OrderStatusViewModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.OrderStatusGetAll(companyId, orderStatus, dataFrom, dataTo);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<OrderStatusViewModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"OrderStatusGetFilt | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Graphic parameters list by hw id
        /// </summary>
        public async Task<List<GraphicParamsModel>?> ParamGetByHwId(int hwId)
        {
            string source = "DB";

            List<GraphicParamsModel>? dbResult = new List<GraphicParamsModel>();
            // cerco da cache
            string currKey = $"{Constants.rKeyGraphicParameters}:{hwId}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<GraphicParamsModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<GraphicParamsModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.ParamGetByHwId(hwId);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<GraphicParamsModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ParamGetByHwId | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// roles list
        /// </summary>
        public async Task<List<AspNetRoles>?> RolesGetAll()
        {
            string source = "DB";

            List<AspNetRoles>? dbResult = new List<AspNetRoles>();
            // cerco da cache
            string currKey = Constants.rKeyRoles;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AspNetRoles>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AspNetRoles>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RolesGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AspNetRoles>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RolesGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<List<AspNetUsers>?> UsersGetAll()
        {
            string source = "DB";

            List<AspNetUsers>? dbResult = new List<AspNetUsers>();
            // cerco da cache
            string currKey = Constants.rKeyUsers;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AspNetUsers>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AspNetUsers>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.UsersGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AspNetUsers>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"UsersGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<AspNetUsers> UsersGetById(string userId)
        {
            string source = "DB";

            AspNetUsers dbResult = new AspNetUsers();
            // cerco da cache
            string currKey = $"{Constants.rKeyUsers}:{userId}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<AspNetUsers>(rawData);
                if (tempResult == null)
                {
                    dbResult = new AspNetUsers();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.UsersGetById(userId);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new AspNetUsers();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"UsersGetById | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Users roles list
        /// </summary>
        public async Task<List<UsersViewModel>?> UserViewGetAll()
        {
            string source = "DB";

            List<UsersViewModel>? dbResult = new List<UsersViewModel>();
            // cerco da cache
            string currKey = Constants.rKeyUsersView;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<UsersViewModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<UsersViewModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.UserViewGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<UsersViewModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"UserViewGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public async Task<Dictionary<string, Dictionary<string, string>>?> VocLemmaGetAll()
        {
            string source = "DB";
            Dictionary<string, Dictionary<string, string>>? dbResult = new Dictionary<string, Dictionary<string, string>>();
            // cerco da cache
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string currKey = $"{Constants.rKeyVocLemma}";
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new Dictionary<string, Dictionary<string, string>>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.VocLemmaGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new Dictionary<string, Dictionary<string, string>>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"VocLemmaGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public async Task<bool> VocLemmaInsert(string rootPath)
        {
            bool fatto = false;

            List<VocabularyTempModel> VocLemmas = new List<VocabularyTempModel>();

            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();

            string[] files = Directory.GetFiles(rootPath, "*");
            string lang = "";
            foreach (string file in files)
            {
                var fileName = file.Split(".");

                lang = fileName[0].Substring(fileName[0].Length - 2, 2);

                //leggo tutte le linee del file
                List<string> lines = File.ReadAllLines(file).ToList();

                foreach (var line in lines)
                {
                    if (!line.StartsWith("//") && line != "")
                    {
                        string[] lineSplit = line.Split("=");
                        //string trad = "";
                        if (lineSplit.Length != 1)
                        {
                            VocabularyTempModel newVocLemma = new VocabularyTempModel()
                            {
                                Lingua = lang,
                                Lemma = lineSplit[0],
                                Traduzione = lineSplit[1]
                            };
                            VocLemmas.Add(newVocLemma);
                        }
                    }
                }
            }
            fatto = await dbController.VocLemmaInsert(VocLemmas);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"VocLemmaInsert in: {ts.TotalMilliseconds} ms");
            return fatto;
        }

        #endregion Public Methods

        #region Protected Fields

        protected Random rnd = new Random();

        #endregion Protected Fields

        #region Private Fields

        private static IConfiguration _configuration = null!;

        private static JsonSerializerSettings? JSSettings;

        private static Logger Log = LogManager.GetCurrentClassLogger();

        private readonly IEmailSender _emailSender;

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

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

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

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

        #endregion Private Fields

        #region Private Properties

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

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

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

        #endregion Private Properties

        #region Private Methods

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

            return answ;
        }

        #endregion Private Methods
    }
}