using EgwCoreLib.Lux.Core.Generic;
using EgwCoreLib.Razor;
using static Lux.UI.Components.Compo.Order.OrderRowMan;

namespace Lux.UI.Components.Compo.WorkLoad
{
    public partial class TimeEstim
    {
        #region Public Properties

        [Parameter]
        public MergedOrderRow MergeOrderRow { get; set; } = null!;

        [Parameter]
        public EventCallback<bool> EC_ClosePopup { get; set; }

        [Parameter]
        public EventCallback<DirectAssignReqDto> EC_DirectAssign { get; set; }

        [Parameter]
        public EventCallback<bool> EC_ReRunReq { get; set; }

        [Parameter]
        public EventCallback<int> EC_ResetAssign { get; set; }

        [Parameter]
        public EventCallback<BalanceReqDto> EC_RunBalance { get; set; }

        #endregion Public Properties

        #region Public Enums

        public enum SetMode
        {
            /// <summary>
            /// Modalit� non definita
            /// </summary>
            None = 0,

            /// <summary>
            /// Modalit� preparazione richiesta balance
            /// </summary>
            Balance,

            /// <summary>
            /// Assegnazione diretta pezzi OK
            /// </summary>
            AssignOk,

            /// <summary>
            /// Assegnazione pezzi non lavorabili
            /// </summary>
            AssignUnwork
        }

        #endregion Public Enums

        #region Private Fields

        private List<string> BalancePlantList = new();
        private BalanceReqDto cBalanceReq = new();

        /// <summary>
        /// Gestione modalit� assegnazione Parts a macchine
        /// </summary>
        private SetMode CurrMode = SetMode.None;

        private string mMessage = "";

        private BootstrapModal.ModalMode mMode = BootstrapModal.ModalMode.ND;

        private BootstrapModal Modal = new();

        private Dictionary<bool, string> modalOpt = new Dictionary<bool, string>();

        private string mTitle = "";

        #endregion Private Fields

        #region Private Properties

        private Dictionary<string, double> DictPercReq
        {
            get => cBalanceReq.MachineBalance;
            set => cBalanceReq.MachineBalance = value;
        }

        [Inject]
        private IDataLayerServices DLService { get; set; } = null!;

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

        private List<ProductionGroupModel> GroupOkList
        {
            get
            {
                List<ProductionGroupModel> ans = new();
                if (MergeOrderRow.CurrProdGroup != null && MergeOrderRow.CurrProdGroup.Count > 0 && MergeOrderRow.WorkLoad != null)
                {
                    ans = MergeOrderRow.CurrProdGroup.Where(x => x.PlantList.Count > 1 || x.NumParts == MergeOrderRow.WorkLoad.NumOk).ToList() ?? new();
                }
                return ans;
            }
        }

        private List<ProductionGroupModel> GroupOkVincList
        {
            get
            {
                List<ProductionGroupModel> ans = new();
                if (MergeOrderRow.CurrProdGroup != null && MergeOrderRow.CurrProdGroup.Count > 0 && MergeOrderRow.WorkLoad != null)
                {
                    ans = MergeOrderRow.CurrProdGroup.Where(x => (x.PlantList.Count == 1 && x.PlantListJoin.Count() > 2) || x.NumParts == MergeOrderRow.WorkLoad.NumOkVin).ToList() ?? new();
                }
                return ans;
            }
        }

        private List<ProductionGroupModel> GroupKoList
        {
            get
            {
                List<ProductionGroupModel> ans = new();
                if (MergeOrderRow.CurrProdGroup != null && MergeOrderRow.CurrProdGroup.Count > 0 && MergeOrderRow.WorkLoad != null)
                {
                    ans = MergeOrderRow.CurrProdGroup.Where(x => x.PlantList.Contains("") || x.NumParts == MergeOrderRow.WorkLoad.NumKo).ToList() ?? new();
                }
                return ans;
            }
        }

        #endregion Private Properties

        #region Private Methods

        private string TitleTableCss(ProdMachineDetailDto machDetail)
        {
            string ans = "";
            if (GroupOkList != null && GroupOkList.Count > 0 && machDetail.BarQty == 0)
                ans = "text-secondary";
            return ans;
        }

        private Task ClosePopup()
        {
            return EC_ClosePopup.InvokeAsync(true);
        }

        private string DisplayDurata(ProdMachineDetailDto machineDetail)
        {
            string ans = "";
            decimal TotalEstimTime = machineDetail.Time;

            int ore = (int)TotalEstimTime / 3600;
            int min = (int)(TotalEstimTime % 3600) / 60;
            int sec = (int)TotalEstimTime % 60;

            // Tempo in formato HH:MM:SS
            ans = $"{ore:D2}:{min:D2}:{sec:D2}";

            if (MergeOrderRow.CurrProdGroup != null && MergeOrderRow.CurrProdGroup.Count > 1 && machineDetail.BarQty > 0)
                ans = ans + " / " + ($"{TotMaxTimeRatio(TotalEstimTime):P1}");
            return ans;
        }
        private async Task ForceResetAssign()
        {
            mTitle = "Attenzione";
            mMessage = "Confermi di vole resettare tutte le assegnazioni per gli articoli?";
            mMode = BootstrapModal.ModalMode.Confirm;
            modalOpt = new();
            modalOpt.Add(true, "Si");
            modalOpt.Add(false, "No");
            if (!await Modal!.ShowAsync<bool>())
                return;

            await EC_ResetAssign.InvokeAsync(MergeOrderRow.Original.OrderRowID);
        }

        private double NumPartRatio(int numPart)
        {
            double ans = 0.0;
            if(MergeOrderRow.WorkLoad != null && MergeOrderRow.WorkLoad.NumParts > 0)
            {
                ans = (double)numPart / MergeOrderRow.WorkLoad.NumParts;
            }
            return ans;
        }

        private string NumParts(int numParts)
        {
            string ans = numParts.ToString() + " / " + ($"{NumPartRatio(numParts):P1}");
            return ans;
        }

        private void PrepareSendReq()
        {
            DictPercReq.Clear();
            var cList = BalancePlantList;
            double stdPerc = 1.0;
            if (cList != null && cList.Count > 1)
            {
                stdPerc = 1.0 / (cList.Count);
            }

            if (cList != null)
            {
                // valutare se determinare EXT/manuale in modo diverso da ProdPlantModel
                switch (CurrMode)
                {
                    case SetMode.None:
                        break;

                    case SetMode.Balance:
                        DictPercReq = cList.ToDictionary(x => x, x => x != "EXT" ? stdPerc : 0.0);
                        break;

                    case SetMode.AssignOk:
                        DictPercReq = cList.ToDictionary(x => x, x => stdPerc);
                        break;

                    //case SetMode.AssignUnwork:
                    //    DictPercReq = cList.ToDictionary(x => x.ProdPlantCod, x => x.ProdPlantCod == "EXT" ? 1.0 : 0.0);
                    //    break;

                    default:
                        break;
                }
            }
        }

        private Task ReqBalance(BalanceReqDto currReq)
        {
            cBalanceReq = currReq;
            CurrMode = SetMode.None;
            return EC_RunBalance.InvokeAsync(cBalanceReq);
        }

        private Task ReRunJob()
        {
            return EC_ReRunReq.InvokeAsync(true);
        }

        private void AssignUnwork(List<ProductionGroupModel> currGroupList, SetMode reqMode)
        {
            // se era gia attivo --> chiude... altrimenti assegna!
            CurrMode = CurrMode == reqMode ? SetMode.None : reqMode;
            // ora imposto secondo modo...
            if (CurrMode == reqMode && CurrMode != SetMode.None)
            {
                foreach (var currGroup in currGroupList)
                {
                    cBalanceReq.TagList = currGroup.WorkGroupList.Values.FirstOrDefault()?.TagList ?? new();
                    BalancePlantList = currGroup.PlantList;
                    PrepareSendReq();
                }
            }
        }

        private void ToggleAssignMode(List<ProductionGroupModel> currGroupList, SetMode reqMode)
        {
            // se era gia attivo --> chiude... altrimenti assegna!
            CurrMode = CurrMode == reqMode ? SetMode.None : reqMode;
            // ora imposto secondo modo...
            if (CurrMode == reqMode && CurrMode != SetMode.None)
            {
                foreach (var currGroup in currGroupList)
                {
                    cBalanceReq.TagList = currGroup.WorkGroupList.Values.FirstOrDefault()?.TagList ?? new();
                    BalancePlantList = currGroup.PlantList;
                    PrepareSendReq();
                }
            }
        }

        private void ToggleAssignMode(ProductionGroupModel currGroup, SetMode reqMode)
        {
            // se era gia attivo --> chiude... altrimenti assegna!
            CurrMode = CurrMode == reqMode ? SetMode.None : reqMode;
            // ora imposto secondo modo...
            if (CurrMode == reqMode)
            {
                //cBalanceReq.TagList = currGroup.WorkGroupList.Values.FirstOrDefault()?.TagList ?? new();
                List<string> allTag = new();
                foreach (var wgl in currGroup.WorkGroupList.Values)
                {
                    allTag.AddRange(wgl.TagList);
                }
                cBalanceReq.TagList = allTag.Distinct().ToList();
                cBalanceReq.GroupIdx = currGroup.GrpIdx;
                BalancePlantList = currGroup.PlantList;
                PrepareSendReq();
            }
        }

        private decimal TotMaxTimeRatio(decimal currTime)
        {
            return MergeOrderRow.TotalMaxTime() > 0 ? currTime / MergeOrderRow.TotalMaxTime() : (decimal)0.0;
        }

        #endregion Private Methods
    }
}