using global::Microsoft.AspNetCore.Components;
using MP.Data.DatabaseModels;
using MP.Data.Services;
using NLog;
using NLog.Fluent;

namespace MP_TAB3.Components
{
    public partial class ProdConfirm
    {
        #region Public Properties

        /// <summary>
        /// registrato nuovo valore
        /// </summary>
        [Parameter]
        public EventCallback<bool> E_inserting { get; set; }

        [Parameter]
        public EventCallback<string> E_MachSel { get; set; }

        /// <summary>
        /// registrato nuovo valore
        /// </summary>
        [Parameter]
        public EventCallback<bool> E_reset { get; set; }

        /// <summary>
        /// Post update restituisco nuova lista dati
        /// </summary>
        [Parameter]
        public EventCallback<List<MappaStatoExpl>> E_Updated { get; set; }

        [Parameter]
        public MappaStatoExpl? RecMSE
        {
            get => currRecMSE;
            set
            {
                // salvo SOLO SE non sono in conferma
                if (!confProdActive)
                {
                    currRecMSE = value;
                }
            }
        }

        #endregion Public Properties

        #region Protected Properties

        protected string ConfBg
        {
            get => confProdActive ? "bg-warning text-dark" : "bg-success text-light";
        }

        protected string ConfCssWidth
        {
            get => enableMagPrint ? "col-6" : "col-12";
        }

        protected string ConfTitle
        {
            get => confProdActive ? "Nascondi conferma" : "Mostra conferma";
        }

        /// <summary>
        /// Dati produzione rilevati
        /// </summary>
        protected StatoProdModel? datiProdAct { get; set; } = null;

        protected DateTime dtFine { get; set; } = DateTime.Today.AddMonths(-1);

        protected DateTime dtInizio { get; set; } = DateTime.Today.AddMonths(-2);

        /// <summary>
        /// Restituisce il codice IdxMacchina dell'altra tavola (se multi) altrimenti la stessa macchina...
        /// </summary>
        protected string idxMaccAltraTav
        {
            get
            {
                string answ = "";
                try
                {
                    // verifico se SIA una tavola (ha char "#")
                    int iSharp = IdxMaccSel.IndexOf('#');
                    if (iSharp > 0)
                    {
                        // ora verifico SE ALTRA TAVOLA ha ODL...
                        string nomeTav = IdxMaccSel.Substring(iSharp);
                        string altraTav = nomeTav.Substring(0, nomeTav.Length - 1);
                        altraTav += nomeTav.EndsWith("1") ? "2" : "1";
                        // sistemo nome
                        answ = IdxMaccSel.Replace(nomeTav, altraTav);
                    }
                }
                catch
                { }
                return answ;
            }
        }

        protected int lblPz2RecBuoni
        {
            get => numPzConfermati - numPzLasciati;
        }

        protected int lblPz2RecScarto
        {
            get => numPzScarto2Rec;
        }

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

        protected int numPz2Rec { get; set; } = 0;

        protected int numPzBuoniConf { get; set; } = 0;

        /// <summary>
        /// Numero pezzi confermati (buoni - scarto)
        /// </summary>
        protected int numPzConfermati
        {
            get
            {
                return numPzProdotti2Rec - numPzScarto2Rec;
            }
        }

        protected int numPzLasciati
        {
            get => numPzLasc;
            set
            {
                if (value <= numPzConfermati)
                {
                    numPzLasc = value;
                }
            }
        }

        protected int numPzProdotti { get; set; } = 0;

        protected int numPzProdotti2Rec { get; set; } = 0;

        protected int numPzScaConf { get; set; } = 0;

        protected int numPzScarto2Rec { get; set; } = 0;

        /// <summary>
        /// Verifica ODL OK (ovvero caricato x macchina...)
        /// </summary>
        protected bool odlOk
        {
            get
            {
                bool answ = (RecMSE != null && RecMSE.IdxOdl > 0);
                if (isMulti && (!answ && RecMSE != null && IdxMaccSel != RecMSE?.IdxMacchina))
                {
                    int idxOdlSel = 0;
                    try
                    {
                        var pUpd = Task.Run(async () =>
                        {
                            var tabOdlSel = await TabDServ.OdlCurrByMacc(IdxMaccSel, true);
                            idxOdlSel = tabOdlSel.IdxOdl;
                        });
                        pUpd.Wait();
                        answ = idxOdlSel > 0;
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Errore Durante recupero idxOdlSel {Environment.NewLine}{exc}");
                    }
                }
                else
                {
                    answ = (RecMSE != null && RecMSE.IdxOdl > 0);
                }
                return answ;
            }
        }

        [Inject]
        protected StatusData SDService { get; set; } = null!;

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

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

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Aggiorno valori produzione alla data richiesta...
        /// </summary>
        /// <param name="newDate"></param>
        protected async Task DoUpdate()
        {
            isProcessing = true;
            await Task.Delay(1);
            datiProdAct = await TabDServ.StatoProdMacchina(IdxMaccSel, dtReqUpdate);
            // aggiorno visualizzazione...
            numPzProdotti = datiProdAct.PzTotODL;
            numPz2Rec = datiProdAct.Pz2RecTot;
            numPzScaConf = datiProdAct.PzConfScarto;
            numPzBuoniConf = datiProdAct.PzConfBuoni;
            numPzProdotti2Rec = datiProdAct.Pz2RecTot;
            numPzScarto2Rec = datiProdAct.Pz2RecScarto;
            dtInizio = RecMSE?.DataInizioOdl ?? DateTime.Today.AddMonths(-2);
            dtFine = dtReqUpdate;
            isProcessing = false;
            await Task.Delay(1);
        }

        protected override void OnInitialized()
        {
            enablePzProdLasciati = SMServ.GetConfBool("enablePzProdLasciati");
            chkPzBuoniNeg = SMServ.GetConfBool("TAB_ChkConfPz");
            confRett = SMServ.GetConfBool("confRett");
            enableMagPrint = SMServ.GetConfBool("enableMagPrint");
            modoConfProd = SMServ.GetConfInt("modoConfProd");
        }

        protected override async Task OnParametersSetAsync()
        {
            lblOut = "";
            if (RecMSE != null && (string.IsNullOrEmpty(IdxMaccSel) || !RecMSE.MostlyEquals(lastRecMSE)))
            {
                await TabDServ.FlushCache("StatoProd");
                if (!confProdActive)
                {
                    numPzLasciati = 0;
                }
                // verifico se la macchina sia configurata tra le MSFD...
                if (SMServ.DictMacchMulti.ContainsKey(RecMSE.IdxMacchina))
                {
                    isMulti = SMServ.DictMacchMulti[RecMSE.IdxMacchina] == 1;
                }
                IdxMaccSel = RecMSE.IdxMacchina;
                if (isMulti)
                {
                    var idxMSel = MsgServ.UserPrefGet(IdxMaccSel);
                    if (!string.IsNullOrEmpty(idxMSel))
                    {
                        IdxMaccSel = idxMSel;
                    }
                }
                //salvo lastRec...
                lastRecMSE = RecMSE;
                dtReqUpdate = DateTime.Now.AddMilliseconds(100);
                await DoUpdate();
            }
        }

        protected async Task SalvaConfPz()
        {
            isProcessing = true;
            // effettua conferma con conf da DB del tipo (giorni / turni / periodo
            bool fatto = effettuaConfermaProd();
            await TabDServ.FlushCache("StatoProd");
            // refresh tabella dati tablet...
            await TabDServ.RicalcMse(IdxMaccSel, 0);
            // rileggo e salvo..
            var ListMSE = await SDService.MseGetAll(true);
            if (ListMSE != null)
            {
                // salvo in LocalStorage...
                await MsgServ.SaveMse(ListMSE);
                // aggiorno MSE attuale
                RecMSE = ListMSE.Find(x => x.IdxMacchina == IdxMaccSel);
            }
            // mostro output
            lblOut = $"Confermata produzione {numPzConfermati - numPzLasciati} pezzi (+{numPzLasciati} pz lasciati, +{numPzScarto2Rec} pz scarto) |{dtReqUpdate:HH:mm:ss} | {dtReqUpdate:ddd yyyy.MM.dd}";
            // cambio button conferma...
            confProdActive = false;
            numPzLasciati = 0;
            dtReqUpdate = DateTime.Now;
            // azzero cache pezzi conf
            SDService.MachNumPzSet(IdxMaccSel, -1);
            await DoUpdate();
            await Task.Delay(1);
            await RefreshData();
            isProcessing = false;
        }

        protected void setConfirmBtn(bool newVal)
        {
            showConfirm = newVal;
        }

        protected async Task SetMacc(string selIdxMacc)
        {
            isProcessing = true;
            await Task.Delay(1);
            IdxMaccSel = selIdxMacc;
            await DoUpdate();
            isProcessing = false;
            await Task.Delay(1);
            await E_MachSel.InvokeAsync(selIdxMacc);
        }

        /// <summary>
        /// Cambio stato visibilit� pannello e testo button
        /// </summary>
        protected async Task ToggleConfProd()
        {
            confProdActive = !confProdActive;
            if (confProdActive)
            {
                // svuoto cache conf prod sicurezza
                await TabDServ.FlushCache("StatoProd");
                numPzLasc = 0;
            }
            dtReqUpdate = DateTime.Now;
            await DoUpdate();
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private bool chkPzBuoniNeg = false;
        private bool confRett = false;
        private bool enableMagPrint = false;
        private bool enablePzProdLasciati = false;
        private bool isMulti = false;
        private string lblOut = "";
        private int modoConfProd = 0;

        #endregion Private Fields

        #region Private Properties

        private bool confProdActive { get; set; } = false;
        private MappaStatoExpl? currRecMSE { get; set; } = null;
        private DateTime dtReqUpdate { get; set; } = DateTime.Now;
        private string IdxMaccSel { get; set; } = "";
        private bool isProcessing { get; set; } = false;
        private MappaStatoExpl? lastRecMSE { get; set; } = null;

        private int MatrOpr
        {
            get => MsgServ.MatrOpr;
        }

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

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

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Registra conferma produzione in modalita nuova (con rettifica pezzi lasciati) o legacy
        /// (con anticipo periodo)
        /// </summary>
        private bool effettuaConfermaProd()
        {
            bool fatto = false;
            if (confRett)
            {
                // confermo al netto dei pezzi lasciati...
                fatto = TabDServ.ConfermaProdMacchinaFull(IdxMaccSel, modoConfProd, numPzConfermati - numPzLasciati, numPzLasciati, numPzScarto2Rec, dtReqUpdate, MatrOpr);
            }
            else
            {
                fatto = TabDServ.ConfermaProdMacchina(IdxMaccSel, modoConfProd, numPzConfermati, numPzScarto2Rec, dtReqUpdate, MatrOpr);
            }
            return fatto;
        }

        private async Task RefreshData()
        {
            List<MappaStatoExpl> ListMSE = await SDService.MseGetAll(true);
            await MsgServ.SaveMse(ListMSE);
            await E_Updated.InvokeAsync(ListMSE);
        }

        #endregion Private Methods
    }
}