Kepler-Release/Venus/Venus_MainPages/ViewModels/RFCalibrationViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using Venus_Core;
using Prism.Commands;
using Prism.Mvvm;
using MECF.Framework.Common.DataCenter;
using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.CommonData;
using System.Xml.Serialization;
using Aitex.Core.Util;
using MECF.Framework.Common.OperationCenter;
using LiveCharts;

namespace Venus_MainPages.ViewModels
{
    public class RFCalibrationViewModel : BindableBase
    {
        #region 字段
        public ObservableCollection<CalibrationTableItem> m_CalibrationItems = new ObservableCollection<CalibrationTableItem>();
        public string ModuleName;
        private CalibrationTableItem m_CurrentSelection;
        public AITRfData rf;
        private string _GeneratorSerialNumber;
        private string _SensorSerialNumber;
        private double _RFPhysicalMaxPower;
        private double _CurrentRFMaxPower;
        private double _RFCalibratedMaxPower;
        private bool _IsSelectedAllEnable;
        private ObservableCollection<NotifiableCalibrationTableItem> _TableData;
        private AITRfData _CurrentSelectionRF;
        private bool _IsNextEnable;
        private JetChamber _JetChamber;
        private bool _firstLoad = true;
        private List<int> selectedIndexs = new List<int>();
        public bool _IsSaveEnable = true;
        private int _TableDataSelectedIndex;
        ChartValues<double> m_SetPointLineSeries = new ChartValues<double>();
        ChartValues<double> m_FeedBackLineSeries = new ChartValues<double>();
        #endregion

        #region 属性
        public ObservableCollection<CalibrationTableItem> CalibrationItems
        {
            get { return m_CalibrationItems; }
            set { SetProperty(ref m_CalibrationItems, value); }

        }
        public CalibrationTableItem CurrentSelection
        {
            get { return m_CurrentSelection; }
            set
            {
                ChangeSelection(value);
                SetProperty(ref m_CurrentSelection, value);
            }

        }
        public string GeneratorSerialNumber
        {
            get { return _GeneratorSerialNumber; }
            set { SetProperty(ref _GeneratorSerialNumber, value); }

        }
        public string SensorSerialNumber
        {
            get { return _SensorSerialNumber; }
            set { SetProperty(ref _SensorSerialNumber, value); }

        }
        public double RFPhysicalMaxPower
        {
            get { return _RFPhysicalMaxPower; }
            set { SetProperty(ref _RFPhysicalMaxPower, value); }
        }
        public double CurrentRFMaxPower
        {
            get { return _CurrentRFMaxPower; }
            set { SetProperty(ref _CurrentRFMaxPower, value); }
        }
        public double RFCalibratedMaxPower
        {
            get { return _RFCalibratedMaxPower; }
            set { SetProperty(ref _RFCalibratedMaxPower, value); }
        }
        public ObservableCollection<NotifiableCalibrationTableItem> TableData
        {
            get { return _TableData; }
            set { SetProperty(ref _TableData, value); }
        }
        public AITRfData CurrentSelectionRF
        {
            get { return _CurrentSelectionRF; }
            set { SetProperty(ref _CurrentSelectionRF, value); }
        }
        public bool IsSelectedAllEnable
        {
            get { return _IsSelectedAllEnable; }
            set { SetProperty(ref _IsSelectedAllEnable, value); }
        }

        public bool IsNextEnable
        {
            get { return _IsNextEnable; }
            set { SetProperty(ref _IsNextEnable, value); }
        }
        public bool IsSaveEnable
        {
            get { return _IsSaveEnable; }
            set { SetProperty(ref _IsSaveEnable, value); }
        }
        public int TableDataSelectedIndex
        {
            get { return _TableDataSelectedIndex; }
            set
            {
                SetProperty(ref _TableDataSelectedIndex, value);
            }
        }
        public ChartValues<double> SetPointLineSeries
        {
            get { return m_SetPointLineSeries; }
            set { SetProperty(ref m_SetPointLineSeries, value); }
        }
        public ChartValues<double> FeedBackLineSeries
        {
            get { return m_FeedBackLineSeries; }
            set { SetProperty(ref m_FeedBackLineSeries, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _CheckCommand;
        public DelegateCommand CheckCommand =>
            _CheckCommand ?? (_CheckCommand = new DelegateCommand(OnCheck));

        private DelegateCommand _UnCheckCommand;
        public DelegateCommand UnCheckCommand =>
            _UnCheckCommand ?? (_UnCheckCommand = new DelegateCommand(OnUnCheck));

        private DelegateCommand _StartCommand;
        public DelegateCommand StartCommand =>
            _StartCommand ?? (_StartCommand = new DelegateCommand(OnStart));

        private DelegateCommand _NextCommand;
        public DelegateCommand NextCommand =>
            _NextCommand ?? (_NextCommand = new DelegateCommand(OnNext));

        private DelegateCommand _EndCommand;
        public DelegateCommand EndCommand =>
            _EndCommand ?? (_EndCommand = new DelegateCommand(OnEnd));

        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(OnLoaded));

        private DelegateCommand _SaveCommand;
        public DelegateCommand SaveCommand =>
            _SaveCommand ?? (_SaveCommand = new DelegateCommand(OnSave));
        #endregion

        #region 构造函数
        public RFCalibrationViewModel()
        {


        }
        #endregion

        #region 命令方法
        private void OnLoaded()
        {
            if (_firstLoad)
            {
                _firstLoad = false;
                _JetChamber = (JetChamber)Enum.Parse(typeof(JetChamber), QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.ChamberType").ToString());
                CalibrationItems.Add(new CalibrationTableItem()
                {
                    DisplayName = "Source RF",
                    ItemEnableScName = $"{ModuleName}.Rf.EnableCalibration",
                    ItemTableScName = $"{ModuleName}.Rf.CalibrationTable",
                });
                //CalibrationItems.Add(new CalibrationTableItem()
                //{
                //    DisplayName = "Bias RF",
                //    ItemEnableScName = $"{ModuleName}.BiasRf.EnableCalibration",
                //    ItemTableScName = $"{ModuleName}.BiasRf.CalibrationTable",
                //});
                if (_JetChamber != JetChamber.Kepler2200A && _JetChamber != JetChamber.Kepler2200B)
                {
                    CalibrationItems.Add(new CalibrationTableItem()
                    {
                        DisplayName = "Bias RF",
                        ItemEnableScName = $"{ModuleName}.BiasRf.EnableCalibration",
                        ItemTableScName = $"{ModuleName}.BiasRf.CalibrationTable",
                    });
                }
            }
        }
        public void OnCheck()
        {
            if (TableData != null && TableData.Count > 0)
            {
                for (int i = 0; i < TableData.Count; i++)
                {
                    TableData[i].IsSelected = true;
                }
            }
           

        }

        public void OnUnCheck()
        {          
            if (TableData != null && TableData.Count > 0)
            {
                for (int i = 0; i < TableData.Count; i++)
                {
                    TableData[i].IsSelected = false;
                }
            }           
        }

        public void OnStart()
        {
            selectedIndexs = new List<int>();
            for (int i = 0; i < TableData.Count; i++)
            {
                if (TableData[i].IsSelected)
                {
                    TableData[i].ForwardPowerUI = 0;
                    TableData[i].ForwardPowerMeter = 0;
                    TableData[i].ReflectedPower = 0;
                    selectedIndexs.Add(i);
                }

                IsSelectedAllEnable = false;
                TableData[i].SetPointEnable = false;
                TableData[i].IsSelectedEnable = false;
                TableData[i].InvokePropertyChanged("SetPointEnable");
                TableData[i].InvokePropertyChanged("IsSelectedEnable");
            }

            IsNextEnable = true;
            IsSaveEnable = false;
            Next();
        }
        public void OnNext()
        {
            Next();
        }
        public  void OnEnd()
        {
            var rf = GetRFbyDisplayName(CurrentSelection.DisplayName);
            if (rf == null)
                return;
            InvokeClient.Instance.Service.DoOperation($"{rf.Module}.{rf.DeviceName}.{AITRfOperation.SetPower}", 0F);
            
            InvokeClient.Instance.Service.DoOperation($"{rf.Module}.{rf.DeviceName}.{AITRfOperation.SetPowerOnOff}", "false");
            selectedIndexs = new List<int>();
            TableDataSelectedIndex = 0;
            CalcResult();
        }

        #endregion

        #region 私有方法
        protected void ChangeSelection(CalibrationTableItem item)
        {
            string name = item.DisplayName == "Source RF" ? VenusDevice.Rf.ToString() : VenusDevice.BiasRf.ToString();
            CurrentSelectionRF = rf = (AITRfData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.{name}.DeviceData");
            if (rf == null) return;


            GeneratorSerialNumber = QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.GeneratorSerialNumber")?.ToString();
            SensorSerialNumber = QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.SensorSerialNumber")?.ToString();
            double result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.RFPhysicalMaxPower")?.ToString(), out result);
            RFPhysicalMaxPower = result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.CurrentRFMaxPower")?.ToString(), out result);
            CurrentRFMaxPower = result;
            double.TryParse(QueryDataClient.Instance.Service.GetConfig($"{rf.Module}.{rf.DeviceName}.RFCalibratedMaxPower")?.ToString(), out result);
            RFCalibratedMaxPower = result;

            var tableValues = QueryDataClient.Instance.Service.GetConfig($"{item.ItemTableDetailScName}");
            if (tableValues == null)
                return;

            var scValue = (string)tableValues;

            if (string.IsNullOrEmpty(scValue))
            {
                InitTableData(item);
                return;
            }

            try
            {
                var tableData = CustomXmlSerializer.Deserialize<List<NotifiableCalibrationTableItem>>(scValue);
                TableData = new ObservableCollection<NotifiableCalibrationTableItem>(tableData);
            }
            catch
            {
                InitTableData(item);
            }


        }
        private void InitTableData(CalibrationTableItem item)
        {
            var tableData = new List<NotifiableCalibrationTableItem>();
            for (int i = 0; i < 20; i++)
            {
                tableData.Add(new NotifiableCalibrationTableItem() { DisplayName = item.DisplayName, SetPoint = (i + 1) * 100, ForwardPowerUI = (i + 1) * 100, ForwardPowerMeter = (i + 1) * 100 });
            }

            TableData = new ObservableCollection<NotifiableCalibrationTableItem>(tableData);
        }

        public void Next()
        {
            if (selectedIndexs.Count > 0)
            {
                TableDataSelectedIndex = selectedIndexs[0];
                RFCalibration(TableData[TableDataSelectedIndex]);
                selectedIndexs.RemoveAt(0);
            }
            else
            {
                CalcResult();
            }
        }
        private void RFCalibration(NotifiableCalibrationTableItem tableItem)
        {
            var rf = GetRFbyDisplayName(tableItem.DisplayName);
            if (rf == null)
                return;

            IsNextEnable = false;
            InvokeClient.Instance.Service.DoOperation($"{rf.Module}.{rf.DeviceName}.{AITRfOperation.SetPower}", tableItem.SetPoint);
            if (!rf.IsRfOn)
                InvokeClient.Instance.Service.DoOperation($"{rf.Module}.{rf.DeviceName}.{AITRfOperation.SetPowerOnOff}", "true");
            Task.Delay(10*1000).ContinueWith(x =>
            {
                UpdateForwardPower(tableItem);
                IsNextEnable = true;
            });

        }

        private AITRfData GetRFbyDisplayName(string displayName)
        {
            switch (displayName)
            {
                case "Source RF":

                    return (AITRfData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.{VenusDevice.Rf}.DeviceData");
                case "Bias RF":
                    return (AITRfData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.{VenusDevice.BiasRf}.DeviceData");
            }
            return null;
        }
        private void UpdateForwardPower(NotifiableCalibrationTableItem tableItem)
        {
            var tableDataItem = TableData.FirstOrDefault(x => x.SetPoint == tableItem.SetPoint);
            if (tableDataItem != null)
                tableDataItem.ForwardPowerUI = GetRFbyDisplayName(tableItem.DisplayName).ForwardPower;
        }
        private void CalcResult()
        {
            IsNextEnable = false;
            IsSaveEnable = true;
            //RenderableSeries = new ObservableCollection<IRenderableSeries>();
            //var ForwardPowerMeterLine = new ChartDataLine(CurrentSelection.DisplayName + " ForwardPowerMeter/SetPoint", CurrentSelection.DisplayName + " ForwardPowerMeter/SetPoint", System.Windows.Media.Color.FromRgb(Color.Red.R, Color.Red.G, Color.Red.B));
            //var SetPointLine = new ChartDataLine(CurrentSelection.DisplayName + " SetPoint/SetPoint", CurrentSelection.DisplayName + " SetPoint/SetPoint", System.Windows.Media.Color.FromRgb(Color.Blue.R, Color.Blue.G, Color.Blue.B));
            for (int i = 0; i < TableData.Count; i++)
            {
                //if (TableData[i].IsSelected)
                //{
                //    ForwardPowerMeterLine.Append(TableData[i].SetPoint, TableData[i].ForwardPowerMeter);
                //    SetPointLine.Append(TableData[i].SetPoint, TableData[i].SetPoint);
                //}
                IsSelectedAllEnable = true;
                TableData[i].SetPointEnable = true;
                TableData[i].IsSelectedEnable = true;
                TableData[i].InvokePropertyChanged("SetPointEnable");
                TableData[i].InvokePropertyChanged("IsSelectedEnable");
            }
            //RenderableSeries.Add(ForwardPowerMeterLine);
            //RenderableSeries.Add(SetPointLine);
            if (TableData.Count(x => x.IsSelected) == 0)
                return;
            RFCalibratedMaxPower = CurrentRFMaxPower * 100 / (100 - TableData.Where(x => x.IsSelected).Average(x => x.Difference));
        }
        private void OnSave()
        {
            SetPointLineSeries.Clear();
            FeedBackLineSeries.Clear();

            for (int i = 0; i < TableData.Count; i++)
            {
                SetPointLineSeries.Add(TableData[i].SetPoint);
                FeedBackLineSeries.Add(TableData[i].ForwardPowerUI);
            }
            InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{rf.Module}.{rf.DeviceName}.RFCalibratedMaxPower", RFCalibratedMaxPower);
        }
        #endregion
    }
    public class CalibrationTableItem
    {
        public string DisplayName { get; set; }
        public string ItemTableScName { get; set; }
        public string ItemTableDetailScName
        {
            get => ItemTableScName + "Detail";
        }
        public string ItemEnableScName { get; set; }
    }
    public class NotifiableCalibrationTableItem : NotifiableItem
    {
        public string DisplayName { get; set; }

        private bool _IsSelected;
        public bool IsSelected
        {
            get
            {
                return _IsSelected;
            }
            set
            {
                _IsSelected = value;
                InvokePropertyChanged("IsSelected");
            }
        }

        [XmlIgnore]
        public bool IsSelectedEnable { get; set; } = true;

        public float _setPoint;
        public float SetPoint
        {
            get
            {
                return _setPoint;
            }
            set
            {
                _setPoint = value;
                InvokePropertyChanged("SetPoint");
            }
        }

        [XmlIgnore]
        public bool SetPointEnable { get; set; } = true;

        public float _forwardPowerUI;
        public float ForwardPowerUI
        {
            get
            {
                return _forwardPowerUI;
            }
            set
            {
                _forwardPowerUI = value;
                InvokePropertyChanged("ForwardPowerUI");
            }
        }

        private float _forwardPowerMeter;
        public float ForwardPowerMeter
        {
            get
            {
                return _forwardPowerMeter;
            }
            set
            {
                _forwardPowerMeter = value;
                InvokePropertyChanged("ForwardPowerMeter");
                InvokePropertyChanged("Difference");
                InvokePropertyChanged("DifferenceBackground");
            }
        }

        public float ReflectedPower { get; set; }

        public float Difference
        {
            get
            {
                if (SetPoint == 0)
                    return 0;
                return (ForwardPowerMeter - SetPoint) * 100 / SetPoint;
            }
        }

        public string DifferenceBackground
        {
            get
            {
                return Math.Abs(Difference) <= 3 ? "LightGreen" : "Red";
            }
        }
    }
}