namespace EgwCoreLib.Lux.Core.RestPayload
{
    /// <summary>
    /// Classe per definizione WorkLoad in dettaglio x un dato task (POR tipicamente)
    /// </summary>
    public class WorkLoadDetailDTO
    {
        #region Public Constructors

        /// <summary>
        /// Init classe partendo dal valore serializzato di una stima di lavorabilità di un item d'ordine minimo (POR)
        /// </summary>
        /// <param name="UID"></param>
        /// <param name="rawData"></param>
        public WorkLoadDetailDTO(string UID, string rawData)
        {
            uID = UID;
            // deserializzo risultati calcolo
            machineCalcResults = JsonConvert.DeserializeObject<List<MachineCalcResultDTO>>(rawData) ?? new List<MachineCalcResultDTO>();
            if (!string.IsNullOrEmpty(rawData) && rawData.Count() > 2)
            {
                // calcolo "esito sinteitco" della lavorabilità (NESSUNA part UnHealthy su ogni macchina)
                workable = machineCalcResults.Sum(x => x.NumPartsKo) == 0;
                // cerco la prima macchina (in caso multi macchina), da valutare se fosse suddiviso
                var firstMachine = machineCalcResults.FirstOrDefault();
                if (firstMachine != null)
                {
                    // lista completa...
                    listComplete = firstMachine.PartList.Select(x => x.Tag).ToList();
                    // pezzi lavorabili
                    listWorkable = MachineCalc.Utils.IntersectTags(machineCalcResults, p => p.CalcResult == Enums.PartVerificationResult.MACHINABLE).ToList();
                    // cerco l'insieme dei pezzi NON lavorabili
                    listUnWorkable = MachineCalc.Utils.IntersectTags(machineCalcResults, p => p.CalcResult != Enums.PartVerificationResult.MACHINABLE).ToList();
                    listVincolated = listComplete
                                        .Except(listWorkable)
                                        .Except(ListUnWorkable)
                                        .ToList();
                    numKo = listUnWorkable.Count();
                    numOk = listWorkable.Count();
                    numOkVin = listVincolated.Count();
                    time = firstMachine.Time;
                    // se non ok verifico SE ci siano part unhealty su OGNI macchina (altrimenti è cmq lavorabile
                    if (!workable)
                    {
                        workable = !listUnWorkable.Any();
                    }
                }
            }
            LoadDetail = MachineCalc.Utils.CalculateIntersections(machineCalcResults);
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Elenco effettivo macchine
        /// </summary>
        public List<string> ListMachines
        {
            get => machineCalcResults.Select(x => x.Name).OrderBy(x => x).ToList();
        }

        /// <summary>
        /// Elenco Macchine in formato stringa join
        /// </summary>
        public string ListMachinesJoin
        {
            get => string.Join(", ", machineCalcResults.Select(x => x.Name).OrderBy(x => x).ToList());
        }

        /// <summary>
        /// Elenco delle etichette parts non OK
        /// </summary>
        public List<string> ListUnWorkable
        {
            get => listUnWorkable ?? new List<string>();
        }

        /// <summary>
        /// Elenco parts vincolate (=non ogni impianto)
        /// </summary>
        public List<string> ListVincolated
        {
            get => listVincolated ?? new List<string>();
        }

        /// <summary>
        /// Elenco etichette parts OK
        /// </summary>
        public List<string> ListWorkable
        {
            get => listWorkable ?? new List<string>();
        }

        /// <summary>
        /// Dettaglio combinazioni carico di lavoro
        /// </summary>
        public List<MachineTagDTO> LoadDetail { get; set; } = new List<MachineTagDTO>();

        public List<MachineCalcResultDTO> MachineCalcResults
        {
            get => machineCalcResults;
        }

        /// <summary>
        /// Numero di parts non lavorabili
        /// </summary>
        public int NumKo
        {
            get => numKo;
        }

        /// <summary>
        /// Num Macchine
        /// </summary>
        public int NumMachines
        {
            get => machineCalcResults.Count();
        }

        /// <summary>
        /// Numero di parts lavorabili su OGNI macchina
        /// </summary>
        public int NumOk
        {
            get => numOk;
        }

        /// <summary>
        /// Numero pezzi vincolati (su una SOLA macchina)
        /// </summary>
        public int NumOkVin
        {
            get => numOkVin;
        }

        public int NumParts
        {
            get => listComplete?.Count() ?? 0;
        }

        /// <summary>
        /// Tempo massimo complessivo in ORE
        /// </summary>
        public decimal TotMaxTime
        {
            get
            {
                decimal ans = 0;
                // eventualmente decisione sul tipo di timing con una variabile esplicita (bool)?
                if (time > 0)
                {
                    ans = time;
                }
                else
                {
                    if (LoadDetail != null)
                        ans = LoadDetail.Max(x => x.MaxTime);
                    else
                        ans = 0;
                }
                return ans;
            }
        }

        /// <summary>
        /// Tempo minimo complessivo in ORE
        /// </summary>
        public decimal TotMinTime
        {
            //get => TimeSpan.FromSeconds((double)LoadDetail.Min(x => x.MinTime));
            get => LoadDetail.Min(x => x.MinTime);
        }

        public string UID
        {
            get => uID;
        }

        public bool Workable
        {
            get => workable;
        }

        #endregion Public Properties

        #region Private Fields

        private List<string>? listComplete = null;
        private List<string>? listUnWorkable = null;
        private List<string>? listVincolated = null;
        private List<string>? listWorkable = null;
        private List<MachineCalcResultDTO> machineCalcResults = new List<MachineCalcResultDTO>();
        private int numKo = 0;
        private int numOk = 0;
        private int numOkVin = 0;
        private decimal time = 0;
        private string uID = "";
        private bool workable = false;

        #endregion Private Fields
    }
}