using Microsoft.AspNetCore.Components;
using MP.Data.DbModels;
using MP.Data;
using MP.Data.Services;
using Newtonsoft.Json;
using MP_TAB3.Components;

namespace MP_TAB3.Pages
{
    /// <summary>
    /// Pagina base da cui ereditare metodi x refresh dati da RedisChannel (MessagePipe)
    /// </summary>
    public partial class BasePage : IDisposable
    {
        #region Public Properties

        /// <summary>
        /// Dato di dettaglio MSE per macchina
        /// </summary>
        public MappaStatoExplModel? CurrMSE { get; set; } = null;

        [Inject]
        public MessageService MsgServ { get; set; } = null!;

        [Inject]
        public TabDataFeeder TDFeeder { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Metodo dispose
        /// </summary>
        public virtual void Dispose()
        {
            IdxMacc = "";
            CurrMSE = null;
            TDFeeder.dataPipe.EA_NewMessage -= DataPipe_EA_NewMessage;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// IdxMacchinaSub (tavola)
        /// </summary>
        protected string IdxMaccSubSel = "";

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Macchina selezionata
        /// </summary>
        protected string IdxMacc { get; set; } = "";

        protected bool IsManual { get; set; } = false;

        [Inject]
        protected SharedMemService MStor { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Override Oninit x aggancio evento update da MessagePipe
        /// </summary>
        /// <returns></returns>
        protected override async Task OnInitializedAsync()
        {
            await base.OnInitializedAsync();
            TDFeeder.dataPipe.EA_NewMessage += DataPipe_EA_NewMessage;
        }

        protected override async Task OnParametersSetAsync()
        {
            await ReloadData();
        }

        /// <summary>
        /// Metodo refresh con controllo salvataggio in LocalStorage ogni 5 sec
        /// </summary>
        /// <param name="ListMSE"></param>
        /// <returns></returns>
        protected async Task RefreshData(List<MappaStatoExplModel> ListMSE)
        {
            // se vecchio salvo sul browser...
            if (DateTime.Now.Subtract(lastSave).TotalSeconds > 5)
            {
                // salvo in LocalStorage...
                await MsgServ.SaveMse(ListMSE);
                lastSave = DateTime.Now;
            }
            if (!string.IsNullOrEmpty(IdxMacc))
            {
                var rawData = ListMSE.Find(x => x.IdxMacchina == IdxMacc);
                if (rawData != null)
                {
                    CurrMSE = rawData;
                }
                else
                {
                    await RefreshMBlock();
                }
            }
        }

        /// <summary>
        /// Refresh con rilettura da LocalStorage
        /// </summary>
        /// <returns></returns>
        protected async Task RefreshMBlock()
        {
            // recupero MSE macchina....
            if (!string.IsNullOrEmpty(IdxMacc))
            {
                CurrMSE = await MsgServ.GetMachineMse(IdxMacc);
            }
        }

        protected virtual async Task ReloadData()
        {
            if (string.IsNullOrEmpty(IdxMacc))
            {
                IdxMacc = await MsgServ.IdxMaccGet();
            }
            // recupero MSE macchina....
            if (!string.IsNullOrEmpty(IdxMacc))
            {
                CurrMSE = await MsgServ.GetMachineMse(IdxMacc);
            }
            if (!string.IsNullOrEmpty(IdxMacc) && MStor.DictMacchManual.ContainsKey(IdxMacc))
            {
                IsManual = MStor.DictMacchManual[IdxMacc];
            }
            else
            {
                IsManual = false;
            }
        }

        /// <summary>
        /// Selezione macchina SUB
        /// </summary>
        /// <param name="selIdxMacc"></param>
        protected void SetMacc(string selIdxMacc)
        {
            IdxMaccSubSel = selIdxMacc;
        }

        /// <summary>
        /// Variabile caricamento
        /// </summary>
        protected bool IsLoading = false;
        #endregion Protected Methods

        #region Private Fields

        private bool doBlink = false;

        /// <summary>
        /// DateTime ultimo salvataggio in LocalStorage
        /// </summary>
        private DateTime lastSave = DateTime.Now;

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Ricevuto nuovi dati da mostrare!
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void DataPipe_EA_NewMessage(object? sender, EventArgs e)
        {
            PubSubEventArgs currArgs = (PubSubEventArgs)e;
            // conversione on-the-fly List<string> --> allarmi
            if (!string.IsNullOrEmpty(currArgs.newMessage))
            {
                try
                {
                    List<MappaStatoExplModel>? dataList = JsonConvert.DeserializeObject<List<MappaStatoExplModel>>(currArgs.newMessage);
                    if (dataList != null)
                    {
                        InvokeAsync(() => RefreshData(dataList));
                    }
                }
                catch
                { }
            }
            InvokeAsync(() =>
            {
                StateHasChanged();
            });
        }

        #endregion Private Methods
    }
}