using Newtonsoft.Json;
using SteamWare;
using System;
using System.Collections;

namespace WebLCP
{
    public class dataLayer
    {
        #region Public Fields

        public static dataLayer man = new dataLayer();
        public DS_AppTableAdapters.JobsListTableAdapter taJL;

        #endregion Public Fields

        #region Public Constructors

        public dataLayer()
        {
            initAdapters();
            setupConnection();
        }

        #endregion Public Constructors

        #region Private Methods

        /// <summary>
        /// Effettua vera pulizia directory
        /// </summary>
        /// <param name="sourceDir"></param>
        /// <param name="dataLimite"></param>
        private static void forceClean(string sourceDir, DateTime dataLimite, bool updateDb)
        {
            logger.lg.scriviLog($"Richiesta eliminazione file + antecedenti {dataLimite} nella cartella {sourceDir}");
            fileMover.obj.setDirectoryMapPath(sourceDir);
            fileMover.obj.checkDir();
            // eliminazione files!
            var elencoFiles = fileMover.obj.elencoFiles_FI();
            foreach (var fi in elencoFiles)
            {
                if (fi.CreationTime < dataLimite && fi.Name != "PlaceHolder.file")
                {
                    fi.Delete();
                }
            }
            // eliminazione directory!
            var elencoDir = fileMover.obj.elencoSubdir_DI();
            foreach (var di in elencoDir)
            {
                if (di.CreationTime < dataLimite)
                {
                    // SE richeisto di aggiornare DB...
                    if (updateDb)
                    {
                        // registro che ho ELIMINATO il job...
                        int jobId = 0;
                        try
                        {
                            string pathName = di.Name.Replace("J", "");
                            int.TryParse(pathName, out jobId);
                            // registro che ho eliminato!
                            man.taJL.updateDeleted(jobId, DateTime.Now);
                        }
                        catch
                        { }
                    }
                    // effettiva delete!
                    di.Delete(true);
                }
            }
        }

        private void initAdapters()
        {
            taJL = new DS_AppTableAdapters.JobsListTableAdapter();
        }

        private void setupConnection()
        {
            string connString = memLayer.ML.CRS("AdmodellingConnectionString");
            taJL.Connection.ConnectionString = connString;
        }

        #endregion Private Methods

        #region Public Methods

        /// <summary>
        /// Elenco dei JOBS selezionati e salvati in cache
        /// </summary>
        /// <returns></returns>
        public static ICollection getSelectedJobs()
        {
            ArrayList al = new ArrayList();
            string rawdata = memLayer.ML.StringSessionObj("jobSelection");
            if (rawdata != "")
            {
                al = JsonConvert.DeserializeObject<ArrayList>(rawdata);
            }
            // restituisco array!
            return al;
        }

        /// <summary>
        /// Effettua verifica jobs
        /// </summary>
        public void checkJobs()
        {
            string jobName = "";
            string resultsDir = "";
            // verifica se ci siano JOB in corso --> completati
            DS_App.JobsListDataTable tabJobsAperti = taJL.getIncomp();
            if (tabJobsAperti.Count > 0)
            {
                // dir di riferimento
                string completedDir = $"{memLayer.ML.CRS("clusterBaseDir")}OUT\\";
                // cerco SE siano finiti su filesystem...
                fileMover.obj.setDirectory(completedDir);
                foreach (var currJob in tabJobsAperti)
                {
                    // calcolo nome folder...
                    jobName = "J" + currJob.JobId.ToString("D9");
                    // cerco se ci sia...
                    System.IO.DirectoryInfo[] elencoDir = fileMover.obj.elencoSubdir_DI(jobName);
                    if (elencoDir.Length > 0)
                    {
                        foreach (var currDir in elencoDir)
                        {
                            bool copyDone = false;
                            bool delDone = false;
                            bool dbDone = false;
                            try
                            {
                                // calcolo dir locale...
                                resultsDir = System.Web.HttpContext.Current.Server.MapPath($"{memLayer.ML.CRS("resultsDir")}\\{jobName}");
                                // sposto folder in dir locale..
                                fileMover.DirectoryCopy(currDir.FullName, resultsDir, true, true);
                                copyDone = true;
                            }
                            catch (Exception exc)
                            {
                                logger.lg.scriviLog($"Eccezione in copia folder a fine job:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                            }
                            if (copyDone)
                            {
                                // status: parto da default = incomplete...
                                int newStatus = (int)JStatus.PROC_INCOMPLETE;
                                // se ho il file message.err --> errore
                                int downlSize = 0;
                                var elFilesRes = fileMover.obj.elencoFilesDir(resultsDir);
                                if (elFilesRes.Count > 0)
                                {
                                    // cerco eventuale file .err
                                    foreach (var file in elFilesRes)
                                    {
                                        // se è "message.err" --> ho errore
                                        if (file.Nome.Contains("message.err"))
                                        {
                                            newStatus = (int)JStatus.PROC_ERROR;
                                            break;
                                        }
                                        // se ho txt --> completato
                                        else if (file.Nome.EndsWith(".txt"))
                                        {
                                            newStatus = (int)JStatus.COMPLETED;
                                            break;
                                        }
                                    }
                                    // ora calcolo dimensione da somma files...
                                    foreach (var file in elFilesRes)
                                    {
                                        downlSize += (int)(file.size * 1024);
                                    }
                                }
                                try
                                {
                                    // registro su DB
                                    man.taJL.updateProcessed(currJob.JobId, newStatus, DateTime.Now, downlSize, $"{memLayer.ML.CRS("resultsDir")}{jobName}");
                                    dbDone = true;
                                }
                                catch (Exception exc)
                                {
                                    logger.lg.scriviLog($"Eccezione in salvataggio su DB a fine job:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                                }
                                if (dbDone)
                                {
                                    try
                                    {
                                        //elimino
                                        fileMover.obj.setDirectory(currDir.FullName);
                                        fileMover.obj.eliminaDir();
                                        fileMover.obj.setDirectory(resultsDir);
                                        delDone = true;
                                    }
                                    catch (Exception exc)
                                    {
                                        logger.lg.scriviLog($"Eccezione in eliminazione folder OUT a fine job:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                                    }
                                    if (delDone)
                                    {
                                        try
                                        {
                                            string siteUrl = memLayer.ML.CRS("baseUrl");
                                            // invio email ad utenti al completamento
                                            string oggetto = $"Job <b>{currJob.JobDescr}</b> execution has just been completed.<br/>" +
                                              $"Job was submitted at {currJob.dtSubmiss} and ended at {DateTime.Now}.<br/>" +
                                              $"Please access to <a href=\"{siteUrl}\">{siteUrl}</a> in order to download results";
                                            gestEmail.geAuth.mandaEmail(memLayer.ML.CRS("_fromEmail"), currJob.USER_NAME, $"JOB {currJob.JobDescr} completed", oggetto);
                                        }
                                        catch (Exception exc)
                                        {
                                            logger.lg.scriviLog($"Eccezione in invio email a fine job:{Environment.NewLine}{exc}", tipoLog.EXCEPTION);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// pulisce folder OUT/download
        /// - elimino folder oltre 4 settimane (conf)
        /// </summary>
        public void cleanupJobsDir()
        {
            int ageMaxResultFile = memLayer.ML.CRI("ageMaxResultFile");
            string sourceDir = $"{memLayer.ML.CRS("resultsDir")}\\";
            DateTime dataLimite = DateTime.Now.AddDays(-ageMaxResultFile);
#if DEBUG
            // in debug elimino dopo 10 min...
            dataLimite = DateTime.Now.AddMinutes(-1440);
#endif
            forceClean(sourceDir, dataLimite, true);
        }

        /// <summary>
        /// pulisce folder upload da files in IN lasciati da oltre 30 minuti (conf)
        /// </summary>
        public void cleanupTempDir()
        {
            int ageMaxTempFile = memLayer.ML.CRI("ageMaxTempFile");
            if (ageMaxTempFile > 1)
            {
                string sourceDir = $"{memLayer.ML.CRS("tempUploadDir")}";
                DateTime dataLimite = DateTime.Now.AddMinutes(-ageMaxTempFile);
                forceClean(sourceDir, dataLimite, false);
            }
        }

        #endregion Public Methods
    }

    /// <summary>
    /// Classe oggetto plot
    /// </summary>
    public class jobData
    {
        #region Public Properties

        public string jobCode { get; set; } = "";
        public int jobId { get; set; } = 0;
        public string jobName { get; set; } = "";

        #endregion Public Properties
    }
}