using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.EtaCalculation.SHYS
{
    internal class EtaAnalyCalculator4Logic
    {
        List<IStation.Calculation.Eta.Model.StationAnaInfoBundle> _allStationBundles = null;
        public void AnaContext(IStation.Model.EtaCorpAnalyContext context, List<IStation.Calculation.Eta.Model.StationAnaInfoBundle> allStationBundles)
        {
            this._allStationBundles = allStationBundles;
            foreach (var logicCatalogContextItem in context.LogicCatalogContextItems)
            {
                if (logicCatalogContextItem.UseStatus != IStation.Model.eUseStatus.Enable)
                {
                    continue;
                }

                foreach (var node in logicCatalogContextItem.LogicTreeContextItems)
                {
                     AnaLogic(node);
           
                }
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="context_item"></param>  
        private IStation.Calculation.Eta.Model.LogicAnaInfoBundle AnaLogic(IStation.Model.EtaLogicTreeAnalyContextItem context_item)
        {

            var logic_area = context_item.LogicContextItem as IStation.Model.EtaLogicAreaAnalyContextItem;

            IStation.Calculation.Eta.Model.LogicAnaInfoBundle current_logic_ana = new Calculation.Eta.Model.LogicAnaInfoBundle();
            current_logic_ana.LogicID = logic_area.ID;
            current_logic_ana.ChildStationBundleList = new List<Calculation.Eta.Model.StationAnaInfoBundle>();
            current_logic_ana.ChildLogicBundleList = new List<Calculation.Eta.Model.LogicAnaInfoBundle>();

            List<IStation.Model.EtaBasicRealRecord> child_ana_records = new List<Model.EtaBasicRealRecord>();//只含一级,不含下一集
            foreach (var child in context_item.Children)
            {
                if (child.IsStation())
                {
                    var station_ana = this._allStationBundles.Find(x => x.StationID == child.ObjectID);
                    if (station_ana == null)
                    {
                        continue;
                    }
                    current_logic_ana.ChildStationBundleList.Add(station_ana);
                    child_ana_records.Add(station_ana.AnaResult);
                }
                else
                {
                    var child_logic_ana = AnaLogic(child);
                    current_logic_ana.ChildLogicBundleList.Add(child_logic_ana);
                    child_ana_records.Add(child_logic_ana.AnaResult);
                }
            }



            IStation.Model.EtaLogicRealRecordPure current_result = new Model.EtaLogicRealRecordPure();
            current_result.CorpID = 0;
            current_result.ObjectType = IStation.ObjectType.LogicArea;
            current_result.ObjectID = logic_area.ID;
            if (child_ana_records.Count() == 0)
            {
                current_result.Qa = 0;
                current_result.Ha = 0;
                current_result.Pa = 0;
                current_result.Ea = 0;
                current_result.WPa = 0;
                current_result.UWPa = 0;
                current_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
            }
            else
            {
                current_result.Qa = Math.Round( (from x in child_ana_records where (x.Qa.HasValue && x.Qa.Value>10)  select x.Qa.Value).Sum(),1);//暂时取合计值
                current_result.Ha = Math.Round((from x in child_ana_records where x.Ha.HasValue select x.Ha.Value).Sum(),2);//暂时取合计值
                current_result.Pa = Math.Round((from x in child_ana_records where x.Pa.HasValue select x.Pa.Value).Sum(),1);//暂时取合计值
                double qa_total = 0;
                foreach (var item in child_ana_records)
                {
                    if (item.Ea.HasValue && item.Qa.HasValue && item.Ea.Value > 10 && item.Qa.Value > 10)
                    {
                        qa_total += item.Qa.Value;
                    }
                }
                
                if(qa_total > 100)
                {
                    double eta = 0;
                    foreach (var item in child_ana_records)
                    {
                        if (item.Ea.HasValue && item.Qa.HasValue && item.Ea.Value > 10 && item.Qa.Value > 10)
                        {
                            eta += item.Ea.Value * item.Qa.Value / qa_total;
                        }
                    }

                    double wpa = 0;
                    foreach (var item in child_ana_records)
                    {
                        if (item.WPa.HasValue && item.Qa.HasValue && item.WPa.Value > 0 && item.Qa.Value > 10)
                        {
                            wpa += item.WPa.Value * item.Qa.Value / qa_total;
                        }
                    }

                    double uwpa = 0;
                    foreach (var item in child_ana_records)
                    {
                        if (item.UWPa.HasValue && item.Qa.HasValue && item.UWPa.Value > 0 && item.Qa.Value > 10)
                        {
                            uwpa += item.UWPa.Value * item.Qa.Value / qa_total;
                        }
                    }

                    current_result.Ea = Math.Round(eta, 1);
                    current_result.WPa = Math.Round(wpa, 2);
                    current_result.UWPa = Math.Round(uwpa, 2);
                }
                else
                {
                    current_result.Ea = 0;
                    current_result.WPa = 0;
                    current_result.UWPa = 0;
                }
                current_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                current_result.AnalyInfo = null;
            }

            current_logic_ana.AnaResult = current_result;

            if (current_result != null)
                _allLogicRecordList.Add(current_result);

            return current_logic_ana;
        }
     
        List<Model.EtaLogicRealRecordPure> _allLogicRecordList = new List<Model.EtaLogicRealRecordPure>();
        internal List<Model.EtaLogicRealRecordPure> GetAllLogicAnaRecord()
        {
            return _allLogicRecordList;
        }
    }
}