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

namespace MP.SPEC.Pages
{
    public partial class ODL
    {
        #region Public Methods

        /// <summary>
        /// Inizializzazione con periodo e arrotondamento
        /// </summary>
        /// <param name="minRound"></param>
        /// <returns></returns>
        public static DateTime RoundDatetime(int minRound)
        {
            TimeSpan DayElapsed = DateTime.Now.Subtract(DateTime.Today);
            int minDay = (int)Math.Ceiling((double)(DayElapsed.TotalMinutes / minRound)) * minRound;
            DateTime endRounded = DateTime.Today.AddMinutes(minDay);
            return endRounded;
        }

        #endregion Public Methods

        #region Protected Fields

        protected DataPager? pagerODL = null!;

        #endregion Protected Fields

        #region Protected Properties

        protected bool isActive
        {
            get => currFilter.IsActive;
            set => currFilter.IsActive = value;
        }

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

        [Inject]
        protected ILocalStorageService localStorage { get; set; } = null!;

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

        protected DateTime selDtEnd
        {
            get => currFilter.DtEnd;
            set
            {
                if (currFilter.DtEnd != value)
                {
                    currFilter.DtEnd = value;
                }
            }
        }

        protected DateTime selDtStart
        {
            get => currFilter.DtStart;
            set
            {
                if (currFilter.DtStart != value)
                {
                    currFilter.DtStart = value;
                }
            }
        }

        #endregion Protected Properties

        #region Protected Methods

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

        protected void ForceReloadPage(int newNum)
        {
            currPage = newNum;
        }

        protected async Task getReparto()
        {
            string keyStor = "reparto";
            string localReparto = await localStorage.GetItemAsync<string>(keyStor, "");
            if (!string.IsNullOrEmpty(localReparto))
            {
                selReparto = localReparto;
            }
            else
            {
                selReparto = "*";
                await localStorage.SetItemAsync(keyStor, selReparto);
            }
        }

        protected override async Task OnInitializedAsync()
        {
            await getReparto();
            var allGruppiData = await MDService.ElencoGruppiFaseAsync();
            if (allGruppiData != null)
            {
                ListGruppiFase = allGruppiData.Where(x => x.SelEnabled).ToList();
            }
            ListStati = await MDService.AnagStatiCommAsync();
            ListMacchine = await MDService.MacchineGetFiltAsync(selReparto);
            padCodXdl = await MDService.ConfigTryGetAsync("PadCodXdl");
        }

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

        protected void resetFase()
        {
            selStato = "*";
        }

        protected void resetMacchina()
        {
            selMacchina = "*";
        }

        protected void resetReparto()
        {
            selReparto = "*";
        }

        protected void setDtMax()
        {
            if (currFilter.HasOdl == true)
            {
                currFilter.DtEnd = RoundDatetime(5);
                currFilter.DtStart = RoundDatetime(5).AddDays(-10);
            }
        }

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

        #endregion Protected Methods

        #region Private Fields

        private List<MacchineModel>? ListMacchine;
        private List<MP.Data.DbModels.ListValuesModel>? ListStati;

        #endregion Private Fields

        #region Private Properties

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

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

        private bool filtActive
        {
            get => selMacchina != "*" || selStato != "*" || selReparto != "*";
        }

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

        private string leftStringCSS
        {
            get => isActive ? "text-secondary" : "text-dark fw-bold";
        }

        private List<AnagGruppiModel>? ListGruppiFase { get; set; } = null;
        private string localReparto { get; set; } = "";

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

        private string padCodXdl { get; set; } = "00000";

        private string rightStringCSS
        {
            get => isActive ? "text-dark fw-bold" : "text-secondary";
        }

        private string selMacchina
        {
            get => currFilter.IdxMacchina;
            set => currFilter.IdxMacchina = value;
        }

        private string selReparto
        {
            get => currFilter.CodReparto;
            set => currFilter.CodReparto = value;
        }

        private string selStato
        {
            get => currFilter.CodFase;
            set => currFilter.CodFase = value;
        }

        private int totalCount
        {
            get => currFilter.TotCount;
            set => currFilter.TotCount = value;
        }

        #endregion Private Properties

        #region Private Methods

        private async Task updateFilter(SelectXdlParams newParams)
        {
            isLoading = true;
            await Task.Delay(1);
            currPage = 1;
            // salvo comunque filtro reparto x utente
            await localStorage.SetItemAsync("reparto", selReparto);
            await Task.Delay(1);
            await InvokeAsync(() => StateHasChanged());
            currFilter = newParams;
            isLoading = false;
        }

        #endregion Private Methods
    }
}