using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.EntityFrameworkCore;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MP.FileData.DatabaseModels;
using Newtonsoft.Json;
using MP.FileData.DTO;

namespace MP.FileData.Controllers
{
    public class FileController : IDisposable
    {
        #region Private Fields

        private static IConfiguration _configuration;
        private static MoonPro_ProgContext dbCtx;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Public Constructors

        public FileController(IConfiguration configuration)
        {
            _configuration = configuration;
            dbCtx = new MoonPro_ProgContext(configuration);
            Log.Info("Avviata classe FileController");
        }

        #endregion Public Constructors

        #region Public Methods

        public static string rulePath(string ruleName)
        {
            return string.Format($"Conf/{ruleName}");
        }

        /// <summary>
        /// Effettua la comparazione tra i file in archivio ed i file attuali e segna info LastCheck e Changed (se cambiati)
        /// </summary>
        /// <param name="idxMacchina">cod macchina</param>
        /// <param name="path">path ricerca x macchina</param>
        /// <param name="numDayPre">Numero giorni x ricerca all'indietro da data corrente / 0 = nessun limite</param>
        /// <param name="searchPattern">pattern di ricerca (*.*)</param>
        /// <param name="forceTag">Forza il controllo dei Tags</param>
        /// <param name="SearchRules">Regole di ricerca applicate</param>
        /// <returns></returns>
        public int CheckFileArchived(string idxMacchina, string path, int numDayPre, string searchPattern, bool forceTag, SearchRules currRule)
        {
            Log.Info($"CheckFileArchived S00 | macchina: {idxMacchina} | path: {path} | pattern: {searchPattern} | # ExcludedFileExt: {currRule.ExcludedFileExt.Count()}");
            int checkDone = 0;
            DirectoryInfo dirInfo = new DirectoryInfo(path);
            FileInfo[] fileListRaw = dirInfo.GetFiles(searchPattern, SearchOption.AllDirectories);
            List<FileInfo> fileList = new List<FileInfo>();
            DateTime adesso = DateTime.Now;
            // se ho un limite x giorni indietor x modifiche --> limito!
            if (numDayPre > 0)
            {
                foreach (var item in fileListRaw)
                {
                    if (adesso.Subtract(item.LastWriteTime).TotalDays <= numDayPre)
                    {
                        fileList.Add(item);
                    }
                }
            }
            else
            {
                fileList = fileListRaw.ToList();
            }
            Log.Trace($"CheckFileArchived S01 | file trovati: {fileList.Count()}");
            List<FileInfo> fileNew = new List<FileInfo>();
            List<FileModel> fileChecked = new List<FileModel>();
            List<FileModel> fileMod = new List<FileModel>();

            // recupera elenco file nel DB
            var archivedFile = FileGetByPath(path, true);
            using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
            {
                // verifica i file
                foreach (var file in fileList)
                {
                    // escludo i file con desinenza da escludere...
                    if (!string.IsNullOrEmpty(file.Extension) && currRule.ExcludedFileExt.Contains(file.Extension))
                    {
                        Log.Trace($"CheckFileArchived S02: escluso {file.Name} | estensione {file.Extension}");
                    }
                    else
                    {
                        // cerca nel DB...
                        FileModel currRecord = archivedFile
                                        .Where(x => x.Active && x.Path == file.FullName)
                                        .OrderByDescending(y => y.Rev)
                                        .FirstOrDefault();
                        // se NON trova lo crea
                        if (currRecord == null)
                        {
                            fileNew.Add(file);
                        }
                        else
                        {
                            // verifico se data modifica sia cambiata...
                            if (currRecord.LastMod != file.LastWriteTime)
                            {
                                // calcolo e verifico MD5
                                var fileContent = File.ReadAllBytes(file.FullName);
                                var hash = md5.ComputeHash(fileContent);
                                var newMD5 = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                                if (newMD5 != currRecord.MD5)
                                {
                                    fileMod.Add(currRecord);
                                }
                                else
                                {
                                    fileChecked.Add(currRecord);
                                }
                            }
                            else
                            {
                                fileChecked.Add(currRecord);
                            }
                        }
                    }
                }
            }

            // salvo i NUOVI file
            if (fileNew != null && fileNew.Count > 0)
            {
                checkDone += fileNew.Count;
                FileInsert(idxMacchina, path, fileNew, 0, currRule);
                Log.Trace($"CheckFileArchived S03 | insert {fileNew.Count} files");
            }
            // aggiorno i file modificati
            if (fileMod != null && fileMod.Count > 0)
            {
                checkDone += fileMod.Count;
                FileSetUpdated(fileMod);
                Log.Trace($"CheckFileArchived S04 | update {fileMod.Count} files");
            }
            // segno data-ora ultimo controllo x file invariati
            if (fileChecked != null && fileChecked.Count > 0)
            {
                checkDone += fileChecked.Count;
                FileSetChecked(fileChecked, path, currRule, forceTag);
                Log.Trace($"CheckFileArchived S05 | refreshed {fileChecked.Count} files");
            }

            Log.Info($"Effettuati {checkDone} controlli");
            return checkDone;
        }

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
        }

        public int FileCountFilt(string IdxMacchina, bool OnlyActive, bool OnlyMod, bool OnlyNoTag, string FileName, string Tag, string SearchVal)
        {
            int answ = 0;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                answ = localDbCtx
                .DbSetProgFile
                .Where(x =>
                    (x.IdxMacchina == IdxMacchina || IdxMacchina == "0")
                    && (x.Active == OnlyActive || !OnlyActive) && (x.Tags.Count() == 0 || !OnlyNoTag)
                    && (!OnlyMod || x.DiskStatus != FileState.Ok)
                    && (x.Path.Equals(FileName) || string.IsNullOrEmpty(FileName))
                    && (x.Tags.Where(t => t.TagId == Tag).Count() > 0 || string.IsNullOrEmpty(Tag))
                    && ((!string.IsNullOrEmpty(SearchVal) && (x.Path.Contains(SearchVal) || x.Tags.Where(t => t.TagId.Contains(SearchVal)).Count() > 0)) || string.IsNullOrEmpty(SearchVal))
                ).Count();
            }
            return answ;
        }

        /// <summary>
        /// ELiminazione file da tabella
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public bool FileDelete(FileModel currItem)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                // eliminazione di uno specifico file + rev da tabella
                var file2del = localDbCtx
                    .DbSetProgFile
                    .Where(x => x.FileId == currItem.FileId)
                    .FirstOrDefault();
                localDbCtx
                    .DbSetProgFile
                    .Remove(file2del);

                // se ce ne fosse un altro precedente --> lo (ri)attiva
                var file2open = localDbCtx
                    .DbSetProgFile
                    .Where(x => x.Name == currItem.Name && x.IdxMacchina == currItem.IdxMacchina)
                    .OrderByDescending(y => y.Rev)
                    .FirstOrDefault();
                if (file2open != null)
                {
                    file2open.Active = true;
                }

                // salvo!
                localDbCtx.SaveChanges();
                done = true;
            }
            return done;
        }

        public bool FileDiskStatusChange(List<FileModel> updFiles, FileState newStatus)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                foreach (var item in updFiles)
                {
                    item.DiskStatus = newStatus;
                    localDbCtx.Entry(item).State = EntityState.Modified;
                }
                localDbCtx.SaveChanges();
                done = true;
            }
            return done;
        }

        public bool FileExport(FileModel currFile)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                // sovrascrivo il file su disco
                File.WriteAllBytes(currFile.Path, currFile.FileContent);
                done = true;
            }
            return done;
        }

        public FileModel FileGetByKey(int FileId)
        {
            FileModel thisFile = null;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                thisFile = localDbCtx
                   .DbSetProgFile
                   .Where(x => x.FileId == FileId)
                   .FirstOrDefault();
            }
            return thisFile;
        }

        public List<DatabaseModels.FileModel> FileGetByPath(string path, bool onlyActive)
        {
            List<DatabaseModels.FileModel> dbResult = new List<DatabaseModels.FileModel>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                    .DbSetProgFile
                    .Where(x => x.Path.StartsWith(path) && ((onlyActive == x.Active) || !onlyActive))
                    .OrderBy(x => x.Name)
                    .ToList();
            }
            return dbResult;
        }

        public List<DatabaseModels.FileModel> FileGetFilt(string IdxMacchina, bool OnlyActive, bool OnlyMod, bool OnlyNoTag, string FileName, string Tag, string SearchVal, int NumStart, int NumRecords)
        {
            List<DatabaseModels.FileModel> dbResult = new List<DatabaseModels.FileModel>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetProgFile
                .Include(m => m.Macchina)
                .Include(t => t.Tags)
                .Where(x =>
                    (x.IdxMacchina == IdxMacchina || IdxMacchina == "0")
                    && (x.Active == OnlyActive || !OnlyActive) && (x.Tags.Count() == 0 || !OnlyNoTag)
                    && (!OnlyMod || x.DiskStatus != FileState.Ok)
                    && (x.Path.Equals(FileName) || string.IsNullOrEmpty(FileName))
                    && (x.Tags.Where(t => t.TagId == Tag).Count() > 0 || string.IsNullOrEmpty(Tag))
                    && ((!string.IsNullOrEmpty(SearchVal) && (x.Path.Contains(SearchVal) || x.Tags.Where(t => t.TagId.Contains(SearchVal)).Count() > 0)) || string.IsNullOrEmpty(SearchVal))
                ).OrderByDescending(x => x.LastMod)
                .Skip(NumStart)
                .Take(NumRecords)
                .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Effettua inserimento di un elenco di record in archivio come NUOVO documento tracciato
        /// </summary>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="basePath">Path base macchina</param>
        /// <param name="newFiles">Elenco files</param>
        /// <param name="rev">rev da usare x creazione</param>
        /// <param name="currRule">Configuraizone ricerca</param>
        /// <returns></returns>
        public bool FileInsert(string idxMacchina, string basePath, List<FileInfo> newFiles, int rev, SearchRules currRule)
        {
            // fare: lettura conf x macchina
            Log.Info($"FileInsert S01 per macchina {idxMacchina}: {newFiles.Count} files da valutare");
            bool answ = false;
            DateTime adesso = DateTime.Now;
            // MD5 hash
            using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
            {
                using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
                {
                    // converto
                    List<DatabaseModels.FileModel> newRec = newFiles.Select(o => new DatabaseModels.FileModel()
                    {
                        Active = true,
                        DiskStatus = FileState.Ok,
                        IdxMacchina = idxMacchina,
                        LastCheck = adesso,
                        LastMod = o.LastWriteTime,
                        MimeType = o.Extension,
                        Name = o.Name,
                        Path = o.FullName,
                        Rev = rev,
                        Size = o.Length,
                        FileContent = File.ReadAllBytes(o.FullName)
                    }).ToList();

                    // elenco Tags
                    List<TagModel> currTags = localDbCtx.DbSetTags.ToList();

                    // calcolo MD5 e tags
                    foreach (var item in newRec)
                    {
                        var hash = md5.ComputeHash(item.FileContent);
                        item.MD5 = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();

                        List<string> Tags = new List<string>();
                        List<TagModel> Tag4File = new List<TagModel>();
                        // se necessario bonifico filename...
                        string fileName = item.Name;
                        if (currRule.FileNameExtReplace.Count > 0)
                        {
                            foreach (var fReplace in currRule.FileNameExtReplace)
                            {
                                fileName = fileName.Replace(fReplace.Key, fReplace.Value).Trim();
                            }
                        }
                        // cerco codice tag da configurazione
                        if (currRule.Mode == SearchMode.StringOnFile)
                        {
                            Tags = TagsUtils.searchProgComment(fileName, item.FileStringContent, currRule);
                        }
                        else
                        {
                            Tags = TagsUtils.searchPathName(item.Path, basePath, currRule);
                        }

                        foreach (var tag in Tags)
                        {
                            var foundTag = currTags.SingleOrDefault(x => x.TagId == tag);
                            // aggiungo i tags SE non ci fossero
                            if (foundTag == null)
                            {
                                var newTag = new TagModel() { TagId = tag };
                                currTags.Add(newTag);
                                Tag4File.Add(newTag);
                            }
                            else
                            {
                                // al file aggiungo comunque
                                Tag4File.Add(foundTag);
                            }
                        }
                        // aggiungo ai file
                        if (Tag4File.Count > 0)
                        {
                            // salvo i tags relativi ai files
                            item.Tags = Tag4File;
                        }
                    }

                    // aggiungo in blocco
                    localDbCtx
                    .DbSetProgFile
                    .AddRange(newRec);

                    Log.Trace($"FileInsert S02 per macchina {idxMacchina}: {newRec.Count} files da aggiungere EFCore");

                    // salvo
                    localDbCtx.SaveChanges();
                    answ = true;
                }
            }
            Log.Trace($"FileInsert S03 per macchina {idxMacchina}");
            return answ;
        }

        public bool FileModApprove(FileModel currFile)
        {
            bool done = false;
            // recupero file regole json da macchina..

            List<FileInfo> listUpdate = new List<FileInfo>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                // rileggo dati file...
                var newFileInfo = new FileInfo(currFile.Path);
                listUpdate.Add(newFileInfo);

                var currMacchina = localDbCtx
                                    .DbSetMacchine
                                    .Where(x => x.IdxMacchina == currFile.IdxMacchina)
                                    .SingleOrDefault();
                if (currMacchina != null)
                {
                    // gestione confRule...
                    SearchRules currRule = new SearchRules();
                    try
                    {
                        string rawData = File.ReadAllText(rulePath(currMacchina.RuleName));
                        currRule = JsonConvert.DeserializeObject<SearchRules>(rawData);
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Eccezione in deserializzazione conf rule{Environment.NewLine}{exc}");
                    }
                    // se ho letto conf
                    if (currRule.Name != "ND")
                    {
                        // inserisco come REVISIONE
                        FileInsert(currFile.IdxMacchina, currMacchina.BasePath, listUpdate, currFile.Rev + 1, currRule);

                        // archivio vecchio file
                        currFile.Active = false;
                        currFile.DiskStatus = FileState.Ok;
                        localDbCtx.Entry(currFile).State = EntityState.Modified;
                        // salvo DB
                        localDbCtx.SaveChanges();

                        done = true;
                    }
                }
            }
            return done;
        }

        public bool FileModReject(FileModel currFile)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                // sovrascrivo il file su disco
                File.WriteAllBytes(currFile.Path, currFile.FileContent);

                // rileggo file...
                var newFileInfo = new FileInfo(currFile.Path);
                currFile.LastMod = newFileInfo.LastWriteTime;

                // aggiorno stato del file a unchanged e data mod ad ora...
                currFile.DiskStatus = FileState.Ok;
                localDbCtx.Entry(currFile).State = EntityState.Modified;

                // salvo DB
                localDbCtx.SaveChanges();
                done = true;
            }
            return done;
        }

        /// <summary>
        /// Effettua update di un record in archivio da lista (SOLO STATUS)
        /// </summary>
        /// <param name="updFiles">Elenco file controllati</param>
        /// <param name="basePath">Path base macchina</param>
        /// <param name="currRule">Configuraizone ricerca</param>
        /// <param name="forceTag">Indica se fare COMUNQUE verifica del TAG</param>
        /// <returns></returns>
        public bool FileSetChecked(List<FileModel> updFiles, string basePath, SearchRules currRule, bool forceTag)
        {
            bool answ = false;
            DateTime adesso = DateTime.Now;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                // SOLO SE richiesto forzatura tags
                if (forceTag)
                {
                    // elenco Tags
                    List<TagModel> currTags = localDbCtx.DbSetTags.ToList();
                    foreach (var item in updFiles)
                    {
                        // rimuovo tags vecchi
                        if (item.Tags != null)
                        {
                            item.Tags.Clear();
                            localDbCtx.SaveChanges();
                        }

                        List<string> Tags = new List<string>();
                        List<TagModel> Tag4File = new List<TagModel>();
                        // se necessario bonifico filename...
                        string fileName = item.Name;
                        if (currRule.FileNameExtReplace.Count > 0)
                        {
                            foreach (var fReplace in currRule.FileNameExtReplace)
                            {
                                fileName = fileName.Replace(fReplace.Key, fReplace.Value).Trim();
                            }
                        }
                        // cerco codice tag da configurazione
                        if (currRule.Mode == SearchMode.StringOnFile)
                        {
                            Tags = TagsUtils.searchProgComment(fileName, item.FileStringContent, currRule);
                        }
                        else
                        {
                            Tags = TagsUtils.searchPathName(item.Path, basePath, currRule);
                        }

                        foreach (var tag in Tags)
                        {
                            var foundTag = currTags.SingleOrDefault(x => x.TagId == tag);
                            // aggiungo i tags SE non ci fossero
                            if (foundTag == null)
                            {
                                var newTag = new TagModel() { TagId = tag };
                                currTags.Add(newTag);
                                Tag4File.Add(newTag);
                            }
                            else
                            {
                                // al file aggiungo comunque
                                Tag4File.Add(foundTag);
                            }
                        }
                        // aggiungo ai file
                        if (Tag4File.Count > 0)
                        {
                            // salvo i tags relativi ai files
                            item.Tags = Tag4File;
                        }
                    }
                    try
                    {
                        // salvo
                        localDbCtx.SaveChanges();
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Errore in salvataggio FileSetChecked{Environment.NewLine}{exc}");
                    }
                }
                // update comunque data-ora
                foreach (var item in updFiles)
                {
                    // salvo update file
                    item.LastCheck = adesso;
                    localDbCtx.Entry(item).State = EntityState.Modified;
                }

                answ = true;
            }

            return answ;
        }

        /// <summary>
        /// Effettua update di un record in archivio da lista (solo status, da approvare)
        /// </summary>
        /// <param name="updFiles"></param>
        /// <returns></returns>
        public bool FileSetUpdated(List<FileModel> updFiles)
        {
            bool answ = false;
            DateTime adesso = DateTime.Now;

            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                foreach (var item in updFiles)
                {
                    item.DiskStatus = FileState.Changed;
                    item.LastCheck = adesso;
                    localDbCtx.Entry(item).State = EntityState.Modified;
                }

                // salvo
                localDbCtx.SaveChanges();
                answ = true;
            }

            return answ;
        }

        /// <summary>
        /// Aggiorna un record FILE rileggendo e ricalcolando...
        /// </summary>
        /// <param name="updItem"></param>
        /// <returns></returns>
        public bool FileUpdate(FileModel updItem)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                try
                {
                    // elenco Tags
                    List<TagModel> currTags = localDbCtx.DbSetTags.ToList();

                    // file
                    FileModel currData = null;
                    currData = dbCtx
                       .DbSetProgFile
                       .Where(x => x.FileId == updItem.FileId)
                       .FirstOrDefault();

                    if (currData != null)
                    {
                        updItem.DiskStatus = FileState.Changed;
                        localDbCtx.Entry(updItem).State = EntityState.Modified;
                        localDbCtx.SaveChanges();
                    }
                    else
                    {
                        dbCtx
                            .DbSetProgFile
                            .Add(updItem);
                        dbCtx.SaveChanges();
                    }
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error(exc, "Eccezione durante FileUpdate");
                }
            }
            return done;
        }

        public List<ArchiveStatusDTO> GetArchiveStatus()
        {
            List<ArchiveStatusDTO> ArchiveList = new List<ArchiveStatusDTO>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                ArchiveList = localDbCtx
                        .DbSetMacchine
                        .Select(x => new ArchiveStatusDTO()
                        {
                            IdxMacchina = x.IdxMacchina,
                            Nome = x.Nome,
                            Descrizione = x.Descrizione,
                            BasePath = x.BasePath
                        })
                        .ToList();
                // ora ciclo a cercare i file...
                foreach (var item in ArchiveList)
                {
                    var activeRecords = localDbCtx
                        .DbSetProgFile
                        .Where(x => x.IdxMacchina == item.IdxMacchina && x.Active)
                        .Include(p => p.Tags)
                        .ToList();

                    item.TotFile = activeRecords
                        .Count();

                    item.NumChanged = activeRecords
                        .Where(x => x.DiskStatus == FileState.Changed)
                        .Count();

                    item.NoTags = activeRecords
                        .Where(x => x.Tags.Count == 0)
                        .Count();

                    item.TotalTags = activeRecords
                        .Sum(x => x.Tags.Count);
                }
            }
            return ArchiveList;
        }

        /// <summary>
        /// Recupera singola macchina
        /// </summary>
        /// <returns></returns>
        public MacchinaModel MacchinaGetByKey(string idxMacchina)
        {
            MacchinaModel dbResult = new MacchinaModel();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetMacchine
                .Where(x => x.IdxMacchina == idxMacchina)
                .SingleOrDefault();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella Macchine
        /// </summary>
        /// <returns></returns>
        public List<DatabaseModels.MacchinaModel> MacchineGetAll()
        {
            List<DatabaseModels.MacchinaModel> dbResult = new List<DatabaseModels.MacchinaModel>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                .DbSetMacchine
                .OrderBy(x => x.IdxMacchina)
                .ToList();
            }
            return dbResult;
        }

        public void ResetController()
        {
            dbCtx = new MoonPro_ProgContext(_configuration);
            Log.Info("Effettuato reset FileController");
        }

        /// <summary>
        /// Annulla modifiche su una specifica entity (cancel update)
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool RollBackEntity(object item)
        {
            bool answ = false;
            try
            {
                if (dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Deleted || dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Modified)
                {
                    dbCtx.Entry(item).Reload();
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco TAGS (tutti)
        /// </summary>
        /// <param name="searchVal"></param>
        /// <param name="maxNum"></param>
        /// <returns></returns>
        public List<DatabaseModels.TagModel> TagGetAll()
        {
            List<DatabaseModels.TagModel> dbResult = new List<DatabaseModels.TagModel>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                    .DbSetTags
                    .OrderBy(x => x.TagId)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco TAGS (FILTRATO!!!)
        /// </summary>
        /// <param name="searchVal"></param>
        /// <param name="maxNum"></param>
        /// <returns></returns>
        public List<DatabaseModels.TagModel> TagGetFilt(string searchVal, int maxNum = 100)
        {
            maxNum = maxNum <= 0 ? 100 : maxNum;
            List<DatabaseModels.TagModel> dbResult = new List<DatabaseModels.TagModel>();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                int totRecord = localDbCtx
                .DbSetTags
                .Where(x => x.TagId.Contains(searchVal))
                .Count();
                if (totRecord > maxNum)
                {
                    dbResult = localDbCtx
                        .DbSetTags
                        .Where(x => x.TagId.Contains(searchVal))
                        .OrderBy(x => x.TagId)
                        .Take(maxNum)
                        .ToList();
                    dbResult.Add(new DatabaseModels.TagModel() { TagId = $"... +{totRecord - maxNum} rec ..." });
                }
                else
                {
                    dbResult = localDbCtx
                        .DbSetTags
                        .Where(x => x.TagId.Contains(searchVal))
                        .OrderBy(x => x.TagId)
                        .ToList();
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Ricerca singolo record
        /// </summary>
        /// <param name="TagId"></param>
        /// <returns></returns>
        public TagModel TagGetSingle(string TagId)
        {
            TagModel dbResult = new TagModel();
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                dbResult = localDbCtx
                    .DbSetTags
                    .Where(x => x.TagId == TagId)
                    .FirstOrDefault();
            }
            return dbResult;
        }

        /// <summary>
        /// inserisce i tag
        /// </summary>
        /// <param name="newTags"></param>
        /// <returns></returns>
        public bool TagInsert(List<TagModel> newTags)
        {
            bool done = false;
            using (MoonPro_ProgContext localDbCtx = new MoonPro_ProgContext(_configuration))
            {
                try
                {
                    localDbCtx.DbSetTags.AddRange(newTags);
                    localDbCtx.SaveChanges();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TagInsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        #endregion Public Methods

#if false
        /// <summary>
        /// Elenco Azioni (decodifica)
        /// </summary>
        /// <returns></returns>
        public List<DatabaseModels.AzioniUL> ActionsGetAll()
        {
            List<DatabaseModels.AzioniUL> dbResult = new List<DatabaseModels.AzioniUL>();

            dbResult = dbCtx
                .DbSetAzioniUL
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<DatabaseModels.AnagArticoli> ArticoliGetSearch(int numRecord, string searchVal = "")
        {
            List<DatabaseModels.AnagArticoli> dbResult = new List<DatabaseModels.AnagArticoli>();

            dbResult = dbCtx
                .DbSetArticoli
                .Where(x => x.CodArticolo.Contains(searchVal) || x.DescArticolo.Contains(searchVal) || x.Disegno.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
                .OrderBy(x => x.CodArticolo)
                .Take(numRecord)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<DatabaseModels.ODL> CommesseGetSearch(int numRecord, string searchVal = "")
        {
            List<DatabaseModels.ODL> dbResult = new List<DatabaseModels.ODL>();

            dbResult = dbCtx
                .DbSetODL
                .Where(x => x.KeyRichiesta.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
                .OrderBy(x => x.KeyRichiesta)
                .Take(numRecord)
                .ToList();

            return dbResult;
        }
#endif
#if false
        /// <summary>
        /// Elenco tabella controlli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<DatabaseModels.ResControlli> StatControlliGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<DatabaseModels.ResControlli> dbResult = new List<DatabaseModels.ResControlli>();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

            dbResult = dbCtx
                .DbSetControlli
                .FromSqlRaw("EXEC stp_UI_RC_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella DDB da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="IdxODL"></param>
        /// <param name="KeyRichiesta"></param>
        /// <param name="CodArticolo"></param>
        /// <param name="FirstRecord"></param>
        /// <param name="NumRecord"></param>
        /// <returns></returns>
        public List<DatabaseModels.DdbTurni> StatDdbGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo, int FirstRecord, int NumRecord)
        {
            List<DatabaseModels.DdbTurni> dbResult = new List<DatabaseModels.DdbTurni>();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);
            var firstRecord = new SqlParameter("@FirstRecord", FirstRecord);
            var numRecord = new SqlParameter("@NumRecord", NumRecord);

            dbResult = dbCtx
                .DbSetDdbTurni
                .FromSqlRaw("EXEC stp_UI_DDBTurni_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo,@FirstRecord,@NumRecord", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo, firstRecord, numRecord)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella DDB da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="IdxODL"></param>
        /// <param name="KeyRichiesta"></param>
        /// <param name="CodArticolo"></param>
        /// <returns></returns>
        public int StatDdbGetCount(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            var dbResult = dbCtx
                  .DbSetDdbTurni
                  .Where(x => (x.IdxMacchina == IdxMacchina || IdxMacchina == "*") && (x.IdxOdl == IdxODL || IdxODL == -999) && (x.KeyRichiesta == KeyRichiesta || KeyRichiesta == "*") && (x.CodArticolo == CodArticolo || CodArticolo == "*") && (x.InizioPeriodo >= DataStart && x.InizioPeriodo <= DataEnd))
                  .Count();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella ODL da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<DatabaseModels.ODL> StatOdlGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<DatabaseModels.ODL> dbResult = new List<DatabaseModels.ODL>();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

            dbResult = dbCtx
                .DbSetODL
                .FromSqlRaw("EXEC stp_UI_Odl_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella scarti da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="DataEnd"></param>
        /// <returns></returns>
        public List<DatabaseModels.ResScarti> StatScartiGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<DatabaseModels.ResScarti> dbResult = new List<DatabaseModels.ResScarti>();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

            dbResult = dbCtx
                .DbSetScarti
                .FromSqlRaw("EXEC stp_UI_RS_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella TurniOee da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="DataEnd"></param>
        /// <returns></returns>
        public List<DatabaseModels.TurniOee> StatTurniOeeGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<DatabaseModels.TurniOee> dbResult = new List<DatabaseModels.TurniOee>();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

            dbResult = dbCtx
                .DbSetTurniOee
                .FromSqlRaw("EXEC stp_UI_TurniOee_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                .ToList();

            return dbResult;
        }

        /// <summary>
        /// Elenco tabella UserLog da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<DatabaseModels.UserActionLog> StatUserLogGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<DatabaseModels.UserActionLog> dbResult = new List<DatabaseModels.UserActionLog>();

            //dbResult = dbCtx
            //    .DbSetUserLog
            //    .Where(x => x.Valore.Contains(searchVal) || x.Cognome.Contains(searchVal) || x.CodArticolo.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
            //    .OrderByDescending(x => x.DataOraRif)
            //    .Take(numRecord)
            //    .ToList();

            var dataFrom = new SqlParameter("@dataFrom", DataStart);
            var dataTo = new SqlParameter("@dataTo", DataEnd);
            var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
            var idxODL = new SqlParameter("@IdxODL", IdxODL);
            var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
            var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

            dbResult = dbCtx
                .DbSetUserLog
                .FromSqlRaw("EXEC stp_UI_UL_GetByFilter @dataFrom,@dataTo,@idxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                .ToList();

            return dbResult;
        }
#endif
    }
}