using DevExpress.Xpo.Helpers;
using Yw.Model;
using Yw.Vmo;

namespace HStation.WinFrmUI
{
    /// <summary>
    /// 颜色分级辅助类
    /// </summary>
    public class SimulationGradingHelper
    {
        /// <summary>
        /// 
        /// </summary>
        public SimulationGradingHelper(SimulationVisualListHelper visualListHelper, SimulationCalcuResultHelper calcuResultHelper, ISimulationGradingView view)
        {
            _visualListHelper = visualListHelper;
            _calcuResultHelper = calcuResultHelper;
            _views = new List<ISimulationGradingView>() { view };
        }

        private SimulationVisualListHelper _visualListHelper = null;//可见列表辅助类
        private SimulationCalcuResultHelper _calcuResultHelper = null;//计算结果辅助类
        private List<ISimulationGradingView> _views = null;//视图列表
        private List<HydroGradingVmo> _allGradingList = null;//所有颜色分级列表
        private List<HydroGradingResultViewModel> _allResultList = null;//所有结果列表

        /// <summary>
        /// 可见性
        /// </summary>
        public bool Visible
        {
            get { return _visible; }
            set { _visible = value; }
        }
        private bool _visible = false;

        /// <summary>
        /// 应用列表
        /// </summary>
        public List<HydroGradingApplyViewModel> Applies
        {
            get
            {
                if (_applies == null)
                {
                    _applies = HydroGradingHelper.GetApplyList(_visualListHelper.HydroInfo);
                    if (_applies == null)
                    {
                        _applies = new List<HydroGradingApplyViewModel>();
                    }
                }
                return _applies;
            }
            set
            {
                _applies = value;
                if (_applies == null)
                {
                    _applies = new List<HydroGradingApplyViewModel>();
                }
            }
        }
        private List<HydroGradingApplyViewModel> _applies = null;

        /// <summary>
        /// 初始化数据
        /// </summary>
        public void InitialData()
        {
            _allGradingList = null;
            _applies = null;
        }

        /// <summary>
        /// 获取颜色分级列表
        /// </summary>
        public async Task<List<HydroGradingVmo>> GetGradingList()
        {
            if (_allGradingList == null)
            {
                _allGradingList = await HydroGradingHelper.GetGradingList(_visualListHelper.HydroInfo);
                if (_allGradingList == null)
                {
                    _allGradingList = new List<HydroGradingVmo>();
                }
            }
            return _allGradingList;
        }

        /// <summary>
        /// 设置颜色分级列表
        /// </summary>
        public void SetGradingList(List<HydroGradingVmo> allGradingList)
        {
            _allGradingList = allGradingList;
            if (_allGradingList == null)
            {
                _allGradingList = new List<HydroGradingVmo>();
            }
        }

        /// <summary>
        /// 更新应用
        /// </summary>
        public void UpdateApply(string catalog, string propName)
        {
            var apply = this.Applies.Find(x => x.Catalog == catalog);
            if (apply == null)
            {
                return;
            }
            apply.PropName = propName;
        }

        //获取结果列表
        private async Task<List<HydroGradingResultViewModel>> GetResultList()
        {
            var allGradingList = await GetGradingList();
            _allResultList = HydroGradingHelper.GetResultList(_visualListHelper.HydroInfo, allGradingList, this.Applies, _calcuResultHelper.GetVisualDict());
            if (_allResultList == null)
            {
                _allResultList = new List<HydroGradingResultViewModel>();
            }
            return _allResultList;
        }

        /// <summary>
        /// 设置
        /// </summary>
        public async void Set()
        {
            if (this.Visible)
            {
                var allResultList = await GetResultList();
                var groupList = allResultList.GroupBy(x => x.Color).ToList();
                foreach (var group in groupList)
                {
                    var codes = group.Select(x => x.Code).Distinct().ToList();
                    _views?.ForEach(x => x.OverrideComponentsColor(codes, group.Key, 1));
                }
            }
            else
            {
                var codes = _allResultList?.Select(x => x.Code).Distinct().ToList();
                _views?.ForEach(x => x.RestoreComponentsColor(codes));
            }
        }

        /// <summary>
        /// 设置
        /// </summary>
        public async void Set(HydroVisualInfo visual)
        {
            if (visual == null)
            {
                return;
            }
            var oldResult = _allResultList?.Find(x => x.Code == visual.Code);
            if (oldResult != null)
            {
                _allResultList.Remove(oldResult);
            }
            var allGradingList = await GetGradingList();
            var newResult = HydroGradingHelper.GetResult(visual, allGradingList, this.Applies, _calcuResultHelper.GetVisualDict());
            if (newResult != null)
            {
                if (_allResultList != null)
                {
                    _allResultList.Add(newResult);
                }
            }
            if (this.Visible)
            {
                if (newResult == null)
                {
                    if (oldResult != null)
                    {
                        _views?.ForEach(x => x.RestoreComponentsColor(oldResult.Code));
                    }
                }
                else
                {
                    _views?.ForEach(x => x.OverrideComponentsColor(newResult.Code, newResult.Color, 1));
                }
            }
        }

        /// <summary>
        /// 设置
        /// </summary>
        public void Set(List<HydroVisualInfo> visuals)
        {
            visuals?.ForEach(x => Set(visuals));
        }



    }
}