using EgwControlCenter.Core.Models;
using Newtonsoft.Json;
using NLog;
using RestSharp;
using RestSharp.Serializers;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EgwControlCenter.Core
{
    public class ReleaseChecker
    {
        #region Public Constructors

        /// <summary>
        /// Init classe ReleaseChecker
        /// </summary>
        /// <param name="appDir"></param>
        /// <param name="dataDir"></param>
        /// <param name="confName"></param>
        public ReleaseChecker(string appDir, string dataDir, string confName)
        {
            InitObj(appDir, dataDir, confName);
        }

        /// <summary>
        /// Init classe ReleaseChecker
        /// </summary>
        /// <param name="appDir"></param>
        /// <param name="dataDir"></param>
        public ReleaseChecker(string appDir, string dataDir)
        {
            InitObj(appDir, dataDir, CPName);
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Path file di conf check
        /// </summary>
        public string ConfPath
        {
            get => Path.Combine(AppDir, ConfName);
        }

        /// <summary>
        /// Configurazione degli oggetti da monitorare
        /// </summary>
        public PatrolSettings CurrPatrolCont { get; set; } = new PatrolSettings();

        /// <summary>
        /// Elenco degli oggetti stato dei programmi monitorati
        /// </summary>
        public List<VersStatusDTO> ListAppStatus { get; set; } = new List<VersStatusDTO>();

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Esegue verifica remota versioni x i sw tracciati
        /// </summary>
        /// <returns></returns>
        public bool CheckRemoteReleases()
        {
            bool fatto = false;
            try
            {
                // ciclo x ogni item da controllare
                foreach (var item in ListStatus)
                {
                    if (item.CurrLocal != null)
                    {
                        // verifico release da remoto aggiorno obj
                        var ListRem = GetRemoteRel(item.CodApp, item.CurrLocal.VersNum);
                        if (ListRem != null)
                        {
                            item.ListRemote = ListRem;
                            item.LastUpdateRem = DateTime.Now;
                        }
                    }
                }
                // salvo status...
                SaveStatus();
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in CheckRemoteReleases{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        public bool HasUpdate()
        {
            bool answ = false;
            //se ho record locali cerco il + recente
            if (ListStatus != null && ListStatus.Count > 0)
            {
                foreach (var item in ListStatus)
                {
                    answ = item.HasUpdate();
                    if (answ)
                    {
                        break;
                    }
                }
            }
            return answ;
        }

        /// <summary>
        /// DataOra ultimo check locale
        /// </summary>
        public DateTime LastChecked()
        {
            DateTime answ = new DateTime(DateTime.Today.Year, 1, 1);
            //se ho record locali cerco il + recente
            if (ListStatus != null && ListStatus.Count > 0)
            {
                var primo = ListStatus
                            .OrderByDescending(x => x.LastUpdateLoc)
                            .FirstOrDefault();
                if (primo != null)
                {
                    answ = primo.LastUpdateLoc;
                }
            }
            return answ;
        }

        /// <summary>
        /// Aggiorna (se necessario) lo stato degli oggetti da monitorare
        /// </summary>
        /// <param name="doRefresh"></param>
        /// <returns></returns>
        public bool UpdateLocalStatus(bool doRefresh)
        {
            bool fatto = false;
            // se non forzato verifico file dello status salvato x necessità refresh
            if (!doRefresh)
            {
                doRefresh = CheckScaduto();
            }
            // verifico se procedere...
            if (doRefresh)
            {
                // nuovo obj controlli
                List<TargetStatus> newListStatus = new List<TargetStatus>();
                // ciclo x ogni item da controllare
                foreach (var item in CurrPatrolCont.TargetList)
                {
                    // verifico contenuto secondo tipo
                    if (item != null && item.IsEnabled)
                    {
                        switch (item.ApplicationType)
                        {
                            case CoreEnum.AppType.None:
                                break;

                            case CoreEnum.AppType.Cli:
                                break;

                            case CoreEnum.AppType.Machine:
                                // processo la folder indicata e cerco tutte le macchine contenute
                                if (Directory.Exists(item.BasePath))
                                {
                                    // recupero elenco sottodirectory = macchine
                                    var dirList = Directory.GetDirectories(item.BasePath);
                                    // ciclo e cerco i file mlde...
                                    foreach (var currDir in dirList)
                                    {
                                        // cerco se ci sia un file mlde...
                                        var fileFound = Directory.GetFiles(currDir, "*.mlde");
                                        if (fileFound != null && fileFound.Count() > 0)
                                        {
                                            // prendo il primo...
                                            var tgtFile = fileFound.FirstOrDefault() ?? "";
                                            var currRelDto = MldeGetRelease(tgtFile);
                                            if (currRelDto != null)
                                            {
                                                string codApp = Path.GetFileName(currDir);
                                                newListStatus.Add(new TargetStatus()
                                                {
                                                    CodApp = codApp,
                                                    CurrLocal = currRelDto,
                                                    LastUpdateLoc = DateTime.Now
                                                });
                                            }
                                        }
                                    }
                                }

                                break;

                            case CoreEnum.AppType.WebApp:
                                break;

                            case CoreEnum.AppType.WinApp:
                                break;

                            default:
                                break;
                        }
                    }

                    // aggiungo oggetto TargetStatus
                }
                // aggiorno obj...
                ListStatus = newListStatus;
                // salvo status...
                SaveStatus();
                fatto = true;
            }
            return fatto;
        }

        #endregion Public Methods

        #region Protected Fields

        protected static string apiUrl = "https://liman.egalware.com/ELM.Api/";

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Elenco degli oggetti stato dei programmi monitorati
        /// </summary>
        protected List<TargetStatus> ListStatus { get; set; } = new List<TargetStatus>();

        #endregion Protected Properties

        #region Private Fields

        /// <summary>
        /// Classe logger
        /// </summary>
        private static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Private Properties

        private string AppDir { get; set; } = "";

        /// <summary>
        /// Periodo minimo per autorefresh versioni default 1 gg) protected TimeSpan AutoRefreshVeto
        /// { get; set; } = TimeSpan.FromDays(1);
        /// </summary>
        private TimeSpan AutoRefreshVeto { get; set; } = TimeSpan.FromSeconds(30);

        private string ConfName { get; set; } = "";
        private string CPName { get; set; } = "ConfPatrol.json";

        private string DataDir { get; set; } = "";

        private string LSName { get; set; } = "LastStatus.json";

        /// <summary>
        /// Path file salvataggio status
        /// </summary>
        private string StatusPath
        {
            get => Path.Combine(DataDir, LSName);
            //get => Path.Combine(ApplicationDeployment.CurrentDeployment.DataDirectory, LSName);
        }

        #endregion Private Properties

        #region Private Methods

        private static List<ReleaseDTO> GetRemoteRel(string CodApp, string CurrVers)
        {
            List<ReleaseDTO> answ = new List<ReleaseDTO>();
            try
            {
                // client chiamate rest
                var client = new RestClient(apiUrl);
                string rawData = "";
                // Chiamo il metodo!
                var checkRel = new RestRequest($"/api/Release/filt/{CodApp}?VersMin={CurrVers}", Method.Get);
                // effettuo vera chiamata
                var pUpd = Task.Run(async () =>
                {
                    var currResp = await client.GetAsync(checkRel);
                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
                    {
                        var currList = JsonConvert.DeserializeObject<List<ReleaseDTO>>(currResp.Content);
                        if (currList != null)
                        {
                            answ = currList;
                        }
                    }
                });
                pUpd.Wait();
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in fase gestione REST services{Environment.NewLine}{exc}");
            }

            return answ;
        }

        /// <summary>
        /// Verifica se il check sia scaduto rispetto ad AutoRefreshVeto
        /// </summary>
        /// <returns></returns>
        private bool CheckScaduto()
        {
            bool answ = false;
            DateTime adesso = DateTime.Now;
            // ciclo per ogni oggetto della lista...
            foreach (var item in ListStatus)
            {
                if (item.LastUpdateLoc.Add(AutoRefreshVeto) < adesso)
                {
                    answ = true;
                    // esco!
                    break;
                }
            }
            return answ;
        }

        /// <summary>
        /// init privato oggetti
        /// </summary>
        /// <param name="appDir"></param>
        /// <param name="dataDir"></param>
        /// <param name="confName"></param>
        private void InitObj(string appDir, string dataDir, string confName)
        {
            AppDir = appDir;
            DataDir = dataDir;
            ConfName = confName;
            // imposto veto controlli secondo config verifico path...
            if (string.IsNullOrEmpty(AppDir))
            {
                AppDir = AppDomain.CurrentDomain.BaseDirectory;
            }
            if (File.Exists(ConfPath))
            {
                var rawData = File.ReadAllText(ConfPath);
                if (!string.IsNullOrEmpty(rawData))
                {
                    CurrPatrolCont = JsonConvert.DeserializeObject<PatrolSettings>(rawData) ?? new PatrolSettings();
                    // imposto il veto dalla conf...
                    AutoRefreshVeto = TimeSpan.FromMinutes(CurrPatrolCont.VetoCheckMinutes);
                }
            }
            // cerco se presente file status precedente e lo ricarico...
            if (File.Exists(StatusPath))
            {
                var rawData = File.ReadAllText(StatusPath);
                if (!string.IsNullOrEmpty(rawData))
                {
                    ListStatus = JsonConvert.DeserializeObject<List<TargetStatus>>(rawData) ?? new List<TargetStatus>();
                }
            }
        }

        /// <summary>
        /// Recupera oggetto releaseDTO da file indicato
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        private ReleaseDTO? MldeGetRelease(string filePath)
        {
            ReleaseDTO? answ = null;
            if (File.Exists(filePath))
            {
                string versNum = "";
                string versTxt = "";
                string codApp = "";
                // leggo una riga alla volta e cerco le chaivi
                using (StreamReader reader = new StreamReader(filePath))
                {
                    string? line;
                    bool stop = false;
                    while ((line = reader.ReadLine()) != null && !stop)
                    {
                        if (line.StartsWith("PP_VER"))
                        {
                            // splitto e prendo secondo
                            var splitTxt = line.Split("=");
                            if (splitTxt.Length > 1)
                            {
                                versTxt = splitTxt[1].Trim().Replace("'", "").Trim();
                            }
                        }
                        else if (line.StartsWith("PP_NVER"))
                        {
                            // splitto e prendo secondo
                            var splitTxt = line.Split("=");
                            if (splitTxt.Length > 1)
                            {
                                versNum = splitTxt[1].Trim().Replace("'", "").Trim();
                            }
                        }
                        else if (line.StartsWith("MACH_NAME"))
                        {
                            // splitto e prendo secondo
                            var splitTxt = line.Split("=");
                            if (splitTxt.Length > 1)
                            {
                                codApp = splitTxt[1].Trim().Replace("'", "").Trim();
                            }
                        }
                        // se ho trovato tutto esco!
                        stop = !string.IsNullOrEmpty(versNum) && !string.IsNullOrEmpty(versTxt) && !string.IsNullOrEmpty(codApp);
                    }
                }
                // creo OBJ e lo restituisco...
                answ = new ReleaseDTO()
                {
                    CodApp = codApp,
                    ReleaseDate = DateTime.Now,
                    VersNum = versNum,
                    VersText = versTxt
                };
            }
            return answ;
        }

        /// <summary>
        /// Effettua salvataggio obj status
        /// </summary>
        private void SaveStatus()
        {
            var rawData = JsonConvert.SerializeObject(ListStatus, Formatting.Indented);
            if (rawData != null && rawData.Length > 2)
            {
                File.WriteAllText(StatusPath, rawData);
            }
            // aggiorno obj calcolato versioni...
            ListAppStatus = ListStatus
                            //.Where(x => x.HasUpdate())
                            .Select(x => new VersStatusDTO
                            {
                                CodApp = x.CodApp,
                                VersNumCurr = x.CurrLocal.VersNum,
                                VersNumLast = x.CurrRemote.VersNum,
                                RelTagsLast = x.CurrRemote.RelTags,
                                HasUpdate= x.HasUpdate()
                            })
                            .ToList();
        }

        #endregion Private Methods
    }
}