using global::Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using MP.Data.DbModels;
using MP.Data.DTO;
using MP.Data.Services;
using NLog.LayoutRenderers.Wrappers;

namespace MP_TAB3.Components
{
    public partial class NotesMan
    {
        #region Private Fields

        private int durataMinCurr = 5;

        private int durataMinLast = 0;

        private int numGiorniCurr = 3;

        private int numGiorniLast = 0;

        #endregion Private Fields

        #region Public Properties

        [Parameter]
        public MappaStatoExplModel? RecMSE { get; set; } = null;

        #endregion Public Properties

        #region Protected Properties

        protected CommentiModel? currComm { get; set; } = null;
        protected EventListModel? currEv { get; set; } = null;

        protected int DurataMin
        {
            get => durataMinCurr;
            set
            {
                if (durataMinCurr != value)
                {
                    durataMinCurr = value;
                    var pUpd = Task.Run(async () =>
                    {
                        await ReloadData();
                    });
                    pUpd.Wait();
                }
            }
        }

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

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

        protected int NumGiorni
        {
            get => numGiorniCurr;
            set
            {
                if (numGiorniCurr != value)
                {
                    numGiorniCurr = value;
                    var pUpd = Task.Run(async () =>
                    {
                        await ReloadData();
                    });
                    pUpd.Wait();
                }
            }
        }

        protected List<CommentiModel>? RecordListComments { get; set; } = new List<CommentiModel>();
        protected List<FermiNonQualModel> RecordListFnq { get; set; } = new List<FermiNonQualModel>();
        protected List<FermiCommentatiDTO> RecordListFull { get; set; } = new List<FermiCommentatiDTO>();

        [Inject]
        protected TabDataService TabServ { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected async Task DeteleRec(CommentiModel currRec)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Sicuro di voler eliminare il record?"))
                return;

            RecordListComments = null;
            await Task.Delay(1);
            await TabServ.EvListDelete(currRec.IdxMacchina, currRec.InizioStato, currRec.IdxTipo);
            // ricarico
            await ReloadData();
        }

        protected async Task EditRec(CommentiModel currRec)
        {
            await Task.Delay(1);
            currEv = new EventListModel()
            {
                InizioStato = currRec.InizioStato,
                Value = currRec.Value
            };
        }

        protected override async Task OnParametersSetAsync()
        {
            if (durataMinCurr != durataMinLast || numGiorniCurr != numGiorniLast)
            {
                durataMinLast = durataMinCurr;
                numGiorniLast = numGiorniCurr;
                await ReloadData();
            }
        }

        protected async Task reloadAfterDelOrUpd(bool rel)
        {
            if (rel)
            {
                await ReloadData();
                currComm = null;
                await InvokeAsync(StateHasChanged);
            }
        }

        protected async Task setCurrComm(CommentiModel _CurrComm)
        {
            await Task.Delay(1);
            if (_CurrComm != null)
            {
                currComm = _CurrComm;
            }
        }

        #endregion Protected Methods

        #region Private Methods

        private async Task DoUpdate(bool forceReload)
        {
            if (forceReload)
            {
                currEv = null;
                await ReloadComments();
            }
        }

        private async Task ReloadComments()
        {
            RecordListComments = await TabServ.CommentiGetLastByMacc(RecMSE?.IdxMacchina, NumGiorni);
        }

        private async Task ReloadData()
        {
            await ReloadComments();
            await ReloadFnq();
            // preparo i DTO...
            RecordListFull = RecordListFnq
                                .Select(x => new FermiCommentatiDTO()
                                {
                                    Fermata = x,
                                    CommentiFermata = RecordListComments?
                                                        .Where(c => c.InizioStato >= x.InizioStato
                                                                && c.InizioStato <= x.InizioStato.AddMinutes(x.DurataMinuti))
                                                        .ToList()
                                }).ToList();
        }

        private async Task ReloadFnq()
        {
            RecordListFnq = await TabServ.FermiNonQualificatiFilt(RecMSE?.IdxMacchina, NumGiorni, DurataMin);
        }

        private string setSemaforo(string sem)
        {
            string answ = "";
            if (sem == "sBl")
            {
                answ = "bg-primary text-warning";
            }
            else if (sem == "sGr")
            {
                answ = "bg-secondary text-dark";
            }
            else if (sem == "sGi")
            {
                answ = "bg-warning text-dark";
            }
            return answ;
        }

        #endregion Private Methods
    }
}