using Microsoft.AspNetCore.Components;
using MP.Data.DbModels;
using MP.SPEC.Components;
using MP.SPEC.Data;
using NLog;
using EgwCoreLib.Razor;

namespace MP.SPEC.Pages
{
    public partial class PARAMS : IDisposable
    {
        #region Public Methods

        public void Dispose()
        {
            aTimer.Elapsed -= ElapsedTimer;
            aTimer.Stop();
            aTimer.Close();
            aTimer.Dispose();
            GC.Collect();
        }

        public void ElapsedTimer(object? source, System.Timers.ElapsedEventArgs e)
        {
            // controllo se sia scaduto tempo massimo (in redis) x ricaricare pagina in modo completo...
            var dtRif = MDService.ExpiryReloadParamGet();
            if (dtRif > DateTime.Now)
            {
                Log.Trace("----- Elapsed check PARAMS.cs -----");
            }
            else
            {
                var pUpd = Task.Run(async () =>
                {
                    MDService.ExpiryReloadParamSet(DateTime.Now.AddSeconds(intForceReload));
                    aTimer.Elapsed -= ElapsedTimer;
                    aTimer.Stop();
                    aTimer.Close();
                    aTimer.Dispose();
                    await Task.Delay(1);
                    await InvokeAsync(() => forceReloadCache());
                });
                pUpd.Wait();
            }
        }

        public void StartTimer()
        {
            Random random = new Random();
            double multPer = 0.01 * random.Next(50, 300);
            aTimer = new System.Timers.Timer(RefreshPeriod * multPer);
            aTimer.Elapsed += ElapsedTimer;
            aTimer.Enabled = true;
            aTimer.AutoReset = true;
            aTimer.Start();
        }

        #endregion Public Methods

        #region Protected Fields

        protected int CurrCounter = 0;
        protected int intForceReload = 600;
        protected DataPager? pagerODL = null!;

        #endregion Protected Fields

        #region Protected Properties

        [Inject]
        protected MpDataService MDService { get; set; } = null!;

        protected int RefreshPeriod
        {
            get => currFilter.TempoAgg;
        }

        #endregion Protected Properties

        #region Protected Methods

        protected async Task detailSel(FluxLogModel newRec)
        {
            await Task.Delay(1);
            var updFilter = currFilter;
            DateTime adesso = DateTime.Now.AddSeconds(1);
            updFilter.LiveUpdate = (newRec == null);
            // sistemo la data di riferimento x eventuale snapshot nel passato
            updFilter.dtRif = newRec != null ? newRec.dtEvento : null;
            if (newRec != null)
            {
                updFilter.lastUpdate = updFilter.lastUpdate == "-" ? $"{adesso:yyyy/MM/dd HH:mm:ss}" : updFilter.lastUpdate;
                updFilter.IdxMacchina = newRec.IdxMacchina;
                //updFilter.CodFlux = newRec.CodFlux;
            }
            else
            {
                updFilter.lastUpdate = "-";
            }
            // salvo filtro
            currFilter = updFilter;
        }

        protected void ForceReload(int newNum)
        {
            numRecord = newNum;
        }

        /// <summary>
        /// Esegue svuotamento forzato cache + reload pagina ogni minuto...
        /// </summary>
        protected async Task forceReloadCache()
        {
            Log.Debug("----- forceReloadCache on PARAMS.cs -----");
            await Task.Delay(1);
            await MDService.FlushRedisCache();
            await Task.Delay(1);
            // rimando a pagina corrente
            NavManager.NavigateTo(NavManager.Uri, true, true);
        }

        protected void ForceReloadPage(int newNum)
        {
            currPage = newNum;
            DateTime adesso = DateTime.Now.AddSeconds(1);
            var updFilter = currFilter;
            //updFilter.LiveUpdate = (currPage == 1);
            updFilter.LiveUpdate = (currFilter.CurrPage == 1);
            updFilter.lastUpdate = updFilter.LiveUpdate ? "-" : $"{adesso:yyyy/MM/dd HH:mm:ss}";
            // salvo filtro
            currFilter = updFilter;
            StateHasChanged();
        }

        protected override async Task OnInitializedAsync()
        {
            isLoading = true;
            isFiltering = true;
            // fix pagina
            await Task.Delay(1);
            var modFilter = currFilter;
            modFilter.CurrPage = 1;
            modFilter.LiveUpdate = (currPage == 1);
            currFilter = modFilter;
            await Task.Delay(1);
            setExpiryReload();
            StartTimer();
            isFiltering = false;
        }

        protected async Task pgResetReq(bool doReset)
        {
            if (doReset)
            {
                await Task.Delay(1);
                if (pagerODL != null)
                {
                    pagerODL.resetCurrPage();
                }
            }
        }

        protected void updateTotal(int newTotCount)
        {
            totalCount = newTotCount;
        }

        protected void UpdateTotCount(int newTotCount)
        {
            totalCount = newTotCount;
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private System.Timers.Timer aTimer = null!;

        #endregion Private Fields

        #region Private Properties

        private SelectFluxParams currFilter { get; set; } = new SelectFluxParams();

        private int currPage
        {
            get => currFilter.CurrPage;
            set => currFilter.CurrPage = value;
        }

        private bool isFiltering { get; set; } = false;

        private bool isLoading { get; set; } = true;

        [Inject]
        private NavigationManager NavManager { get; set; } = null!;

        private int numRecord
        {
            get => currFilter.NumRec;
            set => currFilter.NumRec = value;
        }

        private int totalCount { get; set; } = 0;

        #endregion Private Properties

        #region Private Methods

        private void setExpiryReload()
        {
            // verifico se ho una scadenza expiry del periodo desiderato, sennò imposto nuova...
            var dtRif = MDService.ExpiryReloadParamGet();
            if (dtRif <= DateTime.Now)
            {
                MDService.ExpiryReloadParamSet(DateTime.Now.AddSeconds(intForceReload));
            }
        }

        private async Task updateFilter(SelectFluxParams newParams)
        {
            isFiltering = false;
            isLoading = true;
            await Task.Delay(1);
            currPage = 1;
            if (newParams.CurrPage == 0)
            {
                newParams.CurrPage = 1;
                //newParams.LiveUpdate = false;
            }
            else
            {
                //newParams.LiveUpdate = (currPage == 1);
            }
            await Task.Delay(1);
            await InvokeAsync(() => StateHasChanged());
            currFilter = newParams;
            isLoading = false;
        }

        #endregion Private Methods
    }
}