using GPW.CORE.Data;
using GPW.CORE.Data.DbModels;
using Microsoft.Extensions.Caching.Distributed;
using Newtonsoft.Json;
using RestSharp;
using System.Diagnostics;
using System.Text;
using System.Web;

namespace GPW.CORE.UI.Data
{
    /// <summary>
    /// Servizi e dati condivisi a livello applicazione
    /// </summary>
    public class LicenseService
    {
        #region Private Fields

        private static ILogger<LicenseService> _logger;
        private static IConfiguration _configuration;
        private readonly IDistributedCache distributedCache;

        /// <summary>
        /// Chiave redis x attivazioni della licenza
        /// </summary>
        protected const string rKeyAttByLic = "LongCache:AttByLic";

        /// <summary>
        /// Durata assoluta massima della cache IN SECONDI
        /// </summary>
        private int chAbsExp = 60 * 5;

        /// <summary>
        /// Durata della cache IN SECONDI in modalità inattiva (non acceduta) prima di venire rimossa
        /// NON estende oltre il tempo massimo di validità della cache (chAbsExp)
        /// </summary>
        private int chSliExp = 60 * 1;

        /// <summary>
        /// Fattorte conversione cache sliding --> 1 h
        /// </summary>
        private int cacheFact = 12;

        /// <summary>
        /// Opzioni cache con moltiplicatore durata risp durata base (1/5 minuti)
        /// </summary>
        /// <param name="multFact"></param>
        /// <returns></returns>
        private DistributedCacheEntryOptions cacheOpt(int multFact)
        {
            var numSecAbsExp = chAbsExp * multFact;
            var numSecSliExp = chSliExp * multFact;
            return new DistributedCacheEntryOptions().SetAbsoluteExpiration(DateTime.Now.AddSeconds(numSecAbsExp)).SetSlidingExpiration(TimeSpan.FromSeconds(numSecSliExp));
        }

        /// <summary>
        /// Elenco obj in cache
        /// </summary>
        private List<string> cachedDataList = new List<string>();

        /// <summary>
        /// Init classe
        /// </summary>
        /// <param name="configuration"></param>
        /// <param name="logger"></param>
        /// <param name="distributedCache"></param>
        public LicenseService(IConfiguration configuration, ILogger<LicenseService> logger, IDistributedCache distributedCache)
        {
            _logger = logger;
            _configuration = configuration;
            this.distributedCache = distributedCache;
        }

        /// <summary>
        /// Recupero chiave da redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <returns></returns>
        protected async Task<string> getRSV(string rKey)
        {
            string answ = "";
            var redisDataList = await distributedCache.GetAsync(rKey);
            if (redisDataList != null)
            {
                answ = Encoding.UTF8.GetString(redisDataList);
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio chiave in redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <param name="rVal"></param>
        /// <param name="cacheMult"></param>
        /// <returns></returns>
        protected async Task<bool> setRSV(string rKey, string rVal, int cacheMult)
        {
            bool fatto = false;
            var redisDataList = Encoding.UTF8.GetBytes(rVal);
            await distributedCache.SetAsync(rKey, redisDataList, cacheOpt(cacheMult));
            fatto = true;
            return fatto;
        }

        /// <summary>
        /// Salvataggio chiave in redis
        /// </summary>
        /// <param name="rKey"></param>
        /// <param name="rValInt"></param>
        /// <param name="cacheMult"></param>
        /// <returns></returns>
        protected async Task<bool> setRSV(string rKey, int rValInt, int cacheMult)
        {
            bool fatto = false;
            var redisDataList = Encoding.UTF8.GetBytes($"{rValInt}");
            await distributedCache.SetAsync(rKey, redisDataList, cacheOpt(cacheMult));
            fatto = true;
            return fatto;
        }
        /// <summary>
        /// Registra in cache chiave se non fosse già in elenco
        /// </summary>
        /// <param name="newKey"></param>
        protected void trackCache(string newKey)
        {
            if (!cachedDataList.Contains(newKey))
            {
                cachedDataList.Add(newKey);
            }
        }

        #endregion Private Fields

        #region Public Events

        public event Action EA_InfoUpdated = null!;

        public List<LiManObj.AttivazioneDTO> ActivList { get; set; } = new List<LiManObj.AttivazioneDTO>();

        #endregion Public Events

        #region Public Properties

        public async Task<List<LiManObj.AttivazioneDTO>> ActivListCache()
        {
            List<LiManObj.AttivazioneDTO> dbResult = new List<LiManObj.AttivazioneDTO>();
            string cacheKey = $"{rKeyAttByLic}:{MasterKey}";
            trackCache(cacheKey);
            string rawData = await getRSV(cacheKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                dbResult = JsonConvert.DeserializeObject<List<LiManObj.AttivazioneDTO>>(rawData);
            }
            return await Task.FromResult(dbResult);
        }
        public async Task<bool> setActivList(List<LiManObj.AttivazioneDTO> newActList, int numDays)
        {
            bool fatto = false;
            string cacheKey = $"{rKeyAttByLic}:{MasterKey}";
            var rawData = JsonConvert.SerializeObject(newActList);
            await setRSV(cacheKey, rawData, numDays * cacheFact * 24);
            fatto = true;
            if (EA_InfoUpdated != null)
            {
                EA_InfoUpdated?.Invoke();
            }
            return fatto;
        }

        public List<AnagKeyValueModel> AKVList { get; set; } = new List<AnagKeyValueModel>();

        public string Installazione { get; set; } = "";
        public string Applicazione { get; set; } = "";
        public string MasterKey { get; set; } = "";

        public bool ValidData
        {
            get
            {
                // controllo valori string base
                bool checkData = !string.IsNullOrEmpty(Installazione) && !string.IsNullOrEmpty(Applicazione) && !string.IsNullOrEmpty(MasterKey);
                return checkData;
            }
        }

        public bool HasActivData
        {
            get
            {
                bool answ = ValidData;
                // se ok controllo che ci siano attivazioni
                if (answ)
                {
                    // provo classe locale...
                    answ = ActivList != null && ActivList.Count > 0;
                    // se non le avessi carico!
                    if (!answ)
                    {
                        var pUpd = Task.Run(async () =>
                        {
                            ActivList = await ActivListCache();
                        });
                        pUpd.Wait();
                    }

                }
                return answ;
            }
        }

        public DateTime infoExpiry { get; set; } = DateTime.Today.AddDays(1);

        #endregion Public Properties

        #region Private Methods

        private void ReportUpdated()
        {
            if (EA_InfoUpdated != null)
            {
                EA_InfoUpdated?.Invoke();
            }
        }

        /// <summary>
        /// Cerca di recuperare valore string da elenco AKV
        /// </summary>
        /// <param name="varReq">Chiave AKV richiesta</param>
        /// <returns></returns>
        protected string getAVKStr(string varReq)
        {
            string answ = "";
            if (AKVList != null && AKVList.Count > 0)
            {
                var currRec = AKVList.Where(x => x.NomeVar == varReq).FirstOrDefault();
                if (currRec != null)
                {
                    answ = $"{currRec.ValString}";
                }
            }
            return answ;
        }

        /// <summary>
        /// Init della classe con variabili di base da Redis/DB
        /// </summary>
        public bool InitAkv()
        {
            bool fatto = false;
            Installazione = getAVKStr("installazione");
            MasterKey = getAVKStr(Installazione);
            fatto = !string.IsNullOrEmpty($"{Installazione}{MasterKey}");
            return fatto;
        }

        /// <summary>
        /// Init della classe con variabili di base da Redis/DB
        /// </summary>
        public async Task<bool> RefreshLicense()
        {
            bool fatto = false;
            var onlineAct = await OnlineActivationList();
            if (onlineAct != null)
            {
                if (onlineAct.Count > 0)
                {
                    // scadenza info a 15 gg...
                    int numDays = 15;
                    infoExpiry = DateTime.Now.AddDays(numDays);
                    ActivList = onlineAct;
                    fatto = await setActivList(onlineAct, numDays);
                }
            }
            await Task.Delay(1);
            return fatto;
        }

        /// <summary>
        /// URL dell'API x chiamate gestione licenze
        /// </summary>
        private static string apiUrl = "https://liman.egalware.com/ELM.API/";

        /// <summary>
        /// Elenco attivazioni attuali
        /// </summary>
        private async Task<List<LiManObj.AttivazioneDTO>> OnlineActivationList()
        {
            List<LiManObj.AttivazioneDTO> answ = new List<LiManObj.AttivazioneDTO>();
            // cerco online
            RestClient client = new RestClient(apiUrl);
            //client.Authenticator = new HttpBasicAuthenticator("username", "password");
            string MKeyEnc = HttpUtility.UrlEncode(MasterKey);
            var request = new RestRequest($"/api/attivazioni/?chiave={MKeyEnc}", Method.Get);
            var response = await client.GetAsync(request);
            // controllo risposta
            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                // salvo in redis contenuto serializzato
                string rawData = response.Content;
                answ = JsonConvert.DeserializeObject<List<LiManObj.AttivazioneDTO>>(rawData);
            }
            return await Task.FromResult(answ);
        }

        #endregion Private Methods
    }
}