using AppData;
using NKC_SDK;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NKC_WF.WebUserControls
{
    public partial class cmp_batchDetail : BaseUserControl
    {
        #region Protected Fields

        // place master hard-coded
        protected string PlaceCod = "VIRTNE";

        #endregion Protected Fields

        #region Protected Properties

        protected double fullTime
        {
            get
            {
                double answ = 1;
                if (!string.IsNullOrEmpty(hfFullTime.Value))
                {
                    double.TryParse(hfFullTime.Value, out answ);
                }
                return answ;
            }
            set
            {
                hfFullTime.Value = $"{value}";
            }
        }

        protected int lastValRatio
        {
            get
            {
                int answ = 50;
                if (!string.IsNullOrEmpty(hfLastRatio.Value))
                {
                    int.TryParse(hfLastRatio.Value, out answ);
                }
                return answ;
            }
            set
            {
                hfLastRatio.Value = $"{value}";
            }
        }

        protected bool needSave
        {
            get
            {
                bool answ = true;
                bool.TryParse(hfNeedSave.Value, out answ);
                return answ;
            }
            set
            {
                hfNeedSave.Value = $"{value}";
            }
        }

        /// <summary>
        /// Tabella dei batch Descendant di quello corrente
        /// </summary>
        protected DS_App.BatchListDataTable TabBatchDesc
        {
            get
            {
                return ComLib.BatchDescendant(BatchId);
            }
        }

        protected DS_App.OrderListTreeDataTable TabOrders
        {
            get
            {
                // cerco in redis
                return ComLib.OrdersExtByBatch(BatchId);
            }
        }

        protected int valRatio
        {
            get
            {
                int answ = 50;
                if (!string.IsNullOrEmpty(txtRatio.Text))
                {
                    int.TryParse(txtRatio.Text, out answ);
                }
                return answ;
            }
            set
            {
                txtRatio.Text = $"{value}";
                // scrivo ANCHE i valori assoluti
                lblRatio01.Text = $"{valRatio} %";
                lblRatio02.Text = $"{100 - valRatio} %";
                lblTime01.Text = $"{fullTime * value / (100 * 60):N2} h";
                lblTime02.Text = $"{fullTime * (100 - value) / (100 * 60):N2} h";
            }
        }

        #endregion Protected Properties

        #region Public Properties

        public int BatchId
        {
            set
            {
                hfBatchId.Value = value.ToString();
                frmView.DataBind();
                lblMatDet.Text = "";
                lblProdDet.Text = "";
                if (memLayer.ML.CRB("enableMongo"))
                {
                    // cerco da lista salvataggi Estim/Nest...
                    var estimAnsw = ComLib.man.getEstAnsw(value);
                    var nestAnsw = ComLib.man.getNestAnsw(value);
                    StringBuilder sbDebug = new StringBuilder();
                    sbDebug.AppendLine("Debug Info:");
                    // elenchi x ricerca duplicati
                    List<int> partListEstim = new List<int>();
                    List<int> partListEstimDupl = new List<int>();
                    List<int> partListNest = new List<int>();
                    List<int> partListNestDupl = new List<int>();
                    if (estimAnsw != null)
                    {
                        try
                        {
                            foreach (var part in estimAnsw.PartList)
                            {
                                if (partListEstim.Contains(part.PartId))
                                {
                                    partListEstimDupl.Add(part.PartId);
                                }
                                else
                                {
                                    partListEstim.Add(part.PartId);
                                }
                            }
                        }
                        catch
                        { }
                        try
                        {
                            sbDebug.AppendLine($"ESTIM: EnvNum: {estimAnsw.EnvNum} | Worktime: {estimAnsw.EstimatedWorktime / 60:N2} min | Processing Runtime {estimAnsw.ProcessingRuntime / 60:N2} min | Parts #: {estimAnsw.PartList.Count} | Distinct Part # {partListEstim.Count}");
                            // se ho duplicati indico:
                            if (partListEstimDupl.Count > 0)
                            {
                                sbDebug.AppendLine("---------------------");
                                sbDebug.AppendLine($"ESTIM: FOUND {partListEstimDupl.Count} duplicate:");
                                foreach (var partId in partListEstimDupl)
                                {
                                    sbDebug.AppendLine($"{partId}");
                                }
                                sbDebug.AppendLine("---------------------");
                            }
                        }
                        catch
                        { }
                    }
                    if (nestAnsw != null)
                    {
                        try
                        {
                            if (nestAnsw.BunkList != null)
                            {
                                foreach (var bunk in nestAnsw.BunkList)
                                {
                                    foreach (var sheet in bunk.SheetList)
                                    {
                                        foreach (var part in sheet.PartList)
                                        {
                                            if (partListNest.Contains(part.PartId))
                                            {
                                                partListNestDupl.Add(part.PartId);
                                            }
                                            else
                                            {
                                                partListNest.Add(part.PartId);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        catch
                        { }
                        int totKit = 0;
                        try
                        {
                            if (nestAnsw.CartList != null)
                            {
                                foreach (var cart in nestAnsw.CartList)
                                {
                                    totKit += cart.KitList.Count;
                                }
                            }
                        }
                        catch
                        { }
                        //il tot delle part è in bunk > Sheet > part
                        int totPartNum = 0;
                        int totSheet = 0;
                        List<int> materialsList = new List<int>();
                        double num = 0;
                        double den = 1;
                        double currRatio = 0;
                        List<double> workRatio = new List<double>();
                        try
                        {
                            if (nestAnsw.BunkList != null)
                            {
                                foreach (var bunk in nestAnsw.BunkList)
                                {
                                    totSheet += bunk.SheetList.Count;
                                    foreach (var sheet in bunk.SheetList)
                                    {
                                        totPartNum += sheet.PartList.Count;
                                        num = sheet.SurfaceWork > 0 ? sheet.SurfaceWork : 0;
                                        den = sheet.SurfaceTotal > 0 ? sheet.SurfaceTotal : 1;
                                        currRatio = ratioProt(num, den);
                                        workRatio.Add(currRatio);
                                        if (!materialsList.Contains(sheet.MatId))
                                        {
                                            materialsList.Add(sheet.MatId);
                                        }
                                    }
                                }
                            }
                        }
                        catch
                        { }
                        try
                        {
                            // ordino le medie
                            workRatio.Sort();
                            // elimino le + basse quanti materiali ci sono...
                            workRatio.RemoveRange(0, materialsList.Count);
                            double avgRatio = workRatio.Average();
                            double minRatio = workRatio.Min();
                            double maxRatio = workRatio.Max();
                            sbDebug.AppendLine($"NEST: EnvNum: {nestAnsw.EnvNum} | Worktime: {nestAnsw.EstimatedWorktime / 60:N2} min | Processing Runtime {nestAnsw.ProcessingRuntime / 60:N2} min");
                            lblMatDet.Text = $"avg: <b>{avgRatio:P1}</b> (<b>{minRatio:P1}</b> &rarr; <b>{maxRatio:P1}</b>) | {materialsList.Count} materials";
                            lblProdDet.Text = $"Bunks: <b>{nestAnsw.BunkList.Count}</b> | Sheets: <b>{totSheet}</b> | Carts: <b>{nestAnsw.CartList.Count}</b> | Bins: <b>{nestAnsw.BinList.Count}</b>";
                            // se ho duplicati indico:
                            if (partListNestDupl.Count > 0)
                            {
                                sbDebug.AppendLine("---------------------");
                                sbDebug.AppendLine($"NEST: FOUND {partListNestDupl.Count} duplicate:");
                                foreach (var partId in partListNestDupl)
                                {
                                    sbDebug.AppendLine($"{partId}");
                                }
                                sbDebug.AppendLine("---------------------");
                            }
                            // s enon corrispondono
                            if (partListEstim.Count != partListNest.Count)
                            {
                                sbDebug.AppendLine("---------------------");
                                if (partListEstim.Count > partListNest.Count)
                                {
                                    sbDebug.AppendLine($"EST OK | NEST missing:");
                                    foreach (var partId in partListEstim)
                                    {
                                        if (!partListNest.Contains(partId))
                                        {
                                            sbDebug.AppendLine($"{partId}");
                                        }
                                    }
                                }
                                else
                                {
                                    sbDebug.AppendLine($"EST missing | NEST OK:");
                                    foreach (var partId in partListNest)
                                    {
                                        if (!partListEstim.Contains(partId))
                                        {
                                            sbDebug.AppendLine($"{partId}");
                                        }
                                    }
                                }
                                sbDebug.AppendLine("---------------------");
                            }
                        }
                        catch
                        { }
                    }
                    if (memLayer.ML.CRS("environment") == "DEV")
                    {
                        lblTestJson.Text = "<hr/>" + sbDebug.Replace("\r\n", "<br/>").ToString();
                    }
                }
                if (BatchId > 0)
                {
                    checkCreateDescendant();
                    showBatchDescendant();
                    fixChildBatch();
                }
            }
            get
            {
                int answ = 0;
                int.TryParse(hfBatchId.Value, out answ);
                return answ;
            }
        }

        /// <summary>
        /// verifica possibilità avvio TASK x presenza task NON chiusi
        /// </summary>
        /// <returns></returns>
        public bool canStartNew
        {
            get
            {
                return ComLib.canStartNew;
            }
        }

        #endregion Public Properties

        #region Private Methods

        private void checkCreateDescendant()
        {
            // se ho un batchId...
            if (BatchId != 0)
            {
                // verifico se ho descendant
                if (TabBatchDesc.Rows.Count == 0)
                {
                    // altrimenti creo...
                    DLMan.taBL.makeDescendantByKey(BatchId, PlaceCod);
                }
            }
        }

        private void fixChildBatch()
        {
            DS_App.BatchListDataTable TabBatch = TabBatchDesc;
            cmp_orderExtListNE01.BatchId = TabBatch.Rows.Count > 0 ? TabBatchDesc[0].BatchID : 0;
            cmp_orderExtListNE02.BatchId = TabBatch.Rows.Count > 0 ? TabBatchDesc[1].BatchID : 0;
            cmp_orderExtListNE01.doUpdate();
            cmp_orderExtListNE02.doUpdate();
        }

        private void fixRatio()
        {
            // sistemazione ratio calcolata...
            DS_App.OrderListTreeDataTable tabNe01 = DLMan.taOLT.getByBatch(cmp_orderExtListNE01.BatchId);
            DS_App.OrderListTreeDataTable tabNe02 = DLMan.taOLT.getByBatch(cmp_orderExtListNE02.BatchId);

            double totTime01 = tabNe01.Sum(x => x.EstProcTime);
            double totTime02 = tabNe02.Sum(x => x.EstProcTime);

            // aggiorno valore ratio e ratio last...
            fullTime = totTime01 + totTime02;
            fullTime = fullTime > 0 ? fullTime : 1;
            double newRatio = (totTime01 * 100 / fullTime);
            valRatio = (int)newRatio;
            lastValRatio = valRatio;
        }

        /// <summary>
        ///  effettua ribilanciamento ordini partendo da elenco completo e poi assegnando a impianti
        /// </summary>
        private void rebalanceOrder()
        {
            // solo se variato il ratio...
            if (valRatio != lastValRatio)
            {
                // costruisco vettore durata ordini
                OrderSetSim FullSet = new OrderSetSim();
                OrderSetSim SetNe01 = new OrderSetSim();
                OrderSetSim SetNe02 = new OrderSetSim();

                // creo liste x i valori da processare...
                Dictionary<int, double> RawList = new Dictionary<int, double>();
                Dictionary<int, double> OrderedList = new Dictionary<int, double>();

                foreach (var item in TabOrders)
                {
                    RawList.Add(item.OrdID, item.EstProcTime);
                }

                // ordino la lista x processing successivo
                OrderedList = RawList.OrderBy(x => x.Value).ToDictionary(t => t.Key, t => t.Value);

                // salvo i set
                FullSet.OrderSet = OrderedList;

                // lavoro sull'ottimizzare il MINORE
                double ValRatio = (double)valRatio / 100;
                if (ValRatio <= 0.5)
                {
                    SetNe01.TargetValue = FullSet.ActualValue * ValRatio;
                    SetNe01.OrderSet = findLocalMin(OrderedList, SetNe01.TargetValue);
                    // l'altro è la differenza
                    SetNe02.OrderSet = OrderedList;
                    foreach (var item in SetNe01.OrderSet)
                    {
                        SetNe02.OrderSet.Remove(item.Key);
                    }
                }
                else
                {
                    SetNe02.TargetValue = FullSet.ActualValue * (1 - ValRatio);
                    SetNe02.OrderSet = findLocalMin(OrderedList, SetNe02.TargetValue);
                    // l'altro è la differenza
                    SetNe01.OrderSet = OrderedList;
                    foreach (var item in SetNe02.OrderSet)
                    {
                        SetNe01.OrderSet.Remove(item.Key);
                    }
                }

                // riorganizzo tabOrders...
                foreach (var orderItem in TabOrders)
                {
                    if (SetNe01.OrderSet.ContainsKey(orderItem.OrdID))
                    {
                        if (orderItem.BatchID != cmp_orderExtListNE01.BatchId)
                        {
                            DLMan.taOLT.updateBatch(orderItem.BatchID, orderItem.OrdID, cmp_orderExtListNE01.BatchId);
                        }
                    }
                    else
                    {
                        if (orderItem.BatchID != cmp_orderExtListNE02.BatchId)
                        {
                            DLMan.taOLT.updateBatch(orderItem.BatchID, orderItem.OrdID, cmp_orderExtListNE02.BatchId);
                        }
                    }
                }

                // --> richiede salvataggio
                needSave = true;
            }
            fixRatio();
        }

        /// <summary>
        /// Mostro dati dei Batch descendant
        /// </summary>
        private void showBatchDescendant()
        {
            // suddivido
            rebalanceOrder();
        }

        #endregion Private Methods

        #region Protected Methods

        /// <summary>
        /// Cerca il set con lo score migliore calcolando x subset della lista ordinata
        /// </summary>
        /// <param name="OrderedList">Lista ordinata oggetti (INT) + valore</param>
        /// <param name="TargetVal">Valore desiderato (comeSOMMA)</param>
        /// <returns></returns>
        protected Dictionary<int, double> findLocalMin(Dictionary<int, double> OrderedList, double TargetVal)
        {
            Dictionary<int, double> answ = new Dictionary<int, double>();
            List<OrderSetSim> Candidates = new List<OrderSetSim>();
            OrderSetSim CurrSimSet = new OrderSetSim();

            // parte dal valore (singolo) più piccolo tra quelli maggiori del target... se c'è...
            var OrdSup = OrderedList.Where(x => x.Value > TargetVal).OrderBy(x => x.Value);
            if (OrdSup != null && OrdSup.Any())
            {
                var currOrder = OrdSup.FirstOrDefault();
                CurrSimSet = new OrderSetSim();
                CurrSimSet.TargetValue = TargetVal;
                CurrSimSet.OrderSet.Add(currOrder.Key, currOrder.Value);
                Candidates.Add(CurrSimSet);
            }

            // ora guardo gli elementi restanti.. se ci sono
            var OrdInf = OrderedList.Where(x => x.Value <= TargetVal).OrderByDescending(x => x.Value).ToDictionary(t => t.Key, t => t.Value);
            if (OrdInf != null && OrdInf.Any())
            {
                var currOrder = OrdInf.FirstOrDefault();
                CurrSimSet = new OrderSetSim();
                CurrSimSet.TargetValue = TargetVal;
                CurrSimSet.OrderSet.Add(currOrder.Key, currOrder.Value);
                Candidates.Add(CurrSimSet);
                // prendo i restanti tranne il primo
                OrdInf.Remove(currOrder.Key);
                // se rimane qualcosa...
                if (OrdInf != null && OrdInf.Any())
                {
                    // calcolo il minimo locale nei 2 casi, da soli
                    Dictionary<int, double> TestOrderSet01 = findLocalMin(OrdInf, TargetVal);
                    if (TestOrderSet01.Count > 0)
                    {
                        OrderSetSim CurrSet = new OrderSetSim();
                        CurrSet.TargetValue = TargetVal;
                        CurrSet.OrderSet = TestOrderSet01;
                        Candidates.Add(CurrSet);
                    }
                    // ...e con il primo valore...
                    Dictionary<int, double> TestOrderSet02 = findLocalMin(OrdInf, TargetVal - currOrder.Value);
                    TestOrderSet02.Add(currOrder.Key, currOrder.Value);
                    // verifico se migliorativo...
                    if (TestOrderSet02.Count > 0)
                    {
                        OrderSetSim CurrSet = new OrderSetSim();
                        CurrSet.TargetValue = TargetVal - currOrder.Value;
                        CurrSet.OrderSet = TestOrderSet02;
                        Candidates.Add(CurrSet);
                    }
                }
            }
            // cerco il minimo...
            if (Candidates != null && Candidates.Count > 0)
            {
                answ = Candidates.OrderBy(x => x.IndexScore).FirstOrDefault().OrderSet;
            }

            // calcolo il minimo e lo restituisco...
            return answ;
        }

        protected void lbtAccept_Click(object sender, EventArgs e)
        {
            // registro accettazione Nesting
            DLMan.taBL.acceptBatch(BatchId, DLMan.CodSoggCurrUser);
            raiseEvent();
        }

        protected void lbtSendEstim_Click(object sender, EventArgs e)
        {
            // invia a redis una richiesta...
            ComLib.sendMaterials();
            ComLib.sendBatchReq(BatchId, "Estimation", 3, false);

            // registro su DB nesting iniziato...
            DLMan.taBL.updateStatus(BatchId, (int)BatchStatus.EstimationRequested, "", 0);
            raiseEvent();
        }

        protected void lbtSendNesting_Click(object sender, EventArgs e)
        {
            // invia a redis a a richiesta...
            ComLib.sendMaterials();
            ComLib.sendBatchReq(BatchId, "Nesting", 2, false);

            // registro su DB nesting iniziato...
            DLMan.taBL.updateStatus(BatchId, (int)BatchStatus.NestRequested, "", -1);
            raiseEvent();
        }

        protected void lbtStopEstim_Click(object sender, EventArgs e)
        {
            // resetto richiesta
            ComLib.resetBatchReq();
            // registro su DB nesting iniziato...
            DLMan.taBL.updateStatus(BatchId, (int)BatchStatus.Imported, "", -1);
            raiseEvent();
        }

        protected void lbtStopNesting_Click(object sender, EventArgs e)
        {
            // resetto richiesta
            ComLib.resetBatchReq();
            // registro su DB nesting iniziato...
            DLMan.taBL.updateStatus(BatchId, (int)BatchStatus.EstimationDone, "", -1);
            raiseEvent();
        }

        /// <summary>
        /// Init di base
        /// </summary>
        /// <param name="e"></param>
        protected override void OnInit(EventArgs e)
        {
            checkCreateDescendant();
        }

        protected void Page_Load(object sender, EventArgs e)
        {
        }

        /// <summary>
        /// Effettua divisione evitando zeri a den...
        /// </summary>
        /// <param name="num"></param>
        /// <param name="den"></param>
        /// <returns></returns>
        protected double ratioProt(double num, double den)
        {
            den = den == 0 ? 1 : den;
            return num / den;
        }

        protected void txtRatio_TextChanged(object sender, EventArgs e)
        {
            rebalanceOrder();
            fixChildBatch();
        }

        #endregion Protected Methods

        #region Internal Methods

        internal void doUpdate()
        {
            frmView.DataBind();
        }

        #endregion Internal Methods

        #region Public Methods

        /// <summary>
        /// Converte il codice stato in effettivo campo
        /// </summary>
        /// <param name="_status"></param>
        /// <returns></returns>
        public string BStatus(object _status)
        {
            string answ = ComLib.BatchStatusDescr(_status);
            return answ;
        }

        /// <summary>
        /// Controlla se lo stato sia uguale a quello richiesto
        /// </summary>
        /// <param name="_status"></param>
        /// <param name="statusReq"></param>
        /// <returns></returns>
        public bool checkStatus(object _status, BatchStatus statusReq)
        {
            bool answ = false;
            int status = -1;
            int.TryParse(_status.ToString(), out status);
            answ = (status == (int)statusReq);
            return answ;
        }

        #endregion Public Methods
    }
}