Shaker/Avalonia/ShakerApp/ViewModels/MainPage/RandomMainPageViewModel.cs

using Avalonia;
using Avalonia.Collections;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using CommunityToolkit.Mvvm.Input;
using OxyPlot;
using OxyPlot.Series;
using Shaker.Models;
using ShakerApp.Tools;
using ShakerApp.Views;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace ShakerApp.ViewModels
{
    internal class RandomMainPageViewModel:BaseMainPageViewModel<RandomDataModel>
    {
        public const string SpectrumData = "SpectrumData";

        [PropertyAssociation(nameof(RandomDataModel.TestTotalRunTime))]
        public uint TestTotalRunTime => Model.TestTotalRunTime;
        [PropertyAssociation(nameof(RandomDataModel.CurrentIdentifyDisplacement))]
        public double CurrentIdentifyDisplacement => Model.CurrentIdentifyDisplacement;
        [PropertyAssociation(nameof(RandomDataModel.CurrentIdentifyRms))]
        public double CurrentIdentifyRms => Model.CurrentIdentifyRms;
        [PropertyAssociation(nameof(RandomDataModel.IdentifyIndex))]
        public double IdentifyIndex => Model.IdentifyIndex;
        [PropertyAssociation(nameof(RandomDataModel.RandomStatus))]
        public RandomStatus RandomStatus => Model.RandomStatus;
        [PropertyAssociation(nameof(RandomDataModel.TimeDomainRMS))]
        public double TimeDomainRMS => Model.TimeDomainRMS;
        public bool NextButtonVisilily => RandomTestStep == RandomTestStep.Test;
        [PropertyAssociation(nameof(RandomDataModel.RandomTestStep))]
        public RandomTestStep RandomTestStep => Model.RandomTestStep;
        [PropertyAssociation(nameof(RandomDataModel.RandomTestStep))]
        public string RandomTestStepKey => RandomTestStep.Description();
        public bool NextButtonIsEnabled { get => nextButtonIsEnabled; set =>SetProperty(ref nextButtonIsEnabled , value); }
        [PropertyAssociation(nameof(RandomDataModel.CurrentTestLevel))]
        public double CurrentTestLevel => Model.CurrentTestLevel;
        [PropertyAssociation(nameof(RandomDataModel.CurrentTestTime))]
        public uint CurrentTestTime => Model.CurrentTestTime;
        [PropertyAssociation(nameof(RandomDataModel.CurrentLevelTestMaxTime))]
        public uint CurrentLevelTestMaxTime => Model.CurrentLevelTestMaxTime;
        public AvaloniaList<LineSeries> LineSeries { get; } = new AvaloniaList<LineSeries>();
        List<OxyColor> oxyColors = new List<OxyColor>() {OxyColors.Blue, OxyColors.Black, OxyColors.Green, OxyColors.Red, OxyColors.Red, OxyColors.Yellow, OxyColors.Yellow };
        List<LineStyle> lineStyles = new List<LineStyle>() { LineStyle.Solid, LineStyle.Solid, LineStyle.Solid, LineStyle.Solid, LineStyle.Solid, LineStyle.LongDashDotDot, LineStyle.LongDashDotDot };
        List<string> properties = new List<string>() {nameof(RandomData.Driver), nameof(RandomData.Acceleration), nameof(RandomData.TargetAcceleration), nameof(RandomData.UpStopAcceleration), nameof(RandomData.DownStopAcceleration), nameof(RandomData.UpWarnAcceleration), nameof(RandomData.DownWarnAcceleration) };
        List<RandomData> datas = new List<RandomData>();
        private bool nextButtonIsEnabled = true;

        private RandomMainPageViewModel()
        {
            Content = typeof(Views.RandomMainPage);
            #region 加速度谱曲线
            PlotModel.Axes.Add(new OxyPlot.Axes.LogarithmicAxis()
            {
                MaximumPadding = 0,
                MinimumPadding = 0,
                Title = App.Current?.FindResource(ShakerConstant.FrequencyKey) + "",
                Unit = "Hz",
                MajorGridlineStyle = LineStyle.Solid,
                Position = OxyPlot.Axes.AxisPosition.Bottom,
                Key = "Freq"
            });
            PlotModel.Axes.Add(new OxyPlot.Axes.LogarithmicAxis()
            {
                Key = "Ampt",
                Title = App.Current?.FindResource(ShakerConstant.AmptAxisTitleKey) + "",
                Unit = App.Current?.FindResource("RandomValueUnit")?.ToString() ?? string.Empty,
                MajorGridlineStyle = LineStyle.Solid,
                Position = OxyPlot.Axes.AxisPosition.Left,
            });
            PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";

            for (int i = 0; i < oxyColors.Count; i++)
            {
                LineSeries line = new LineSeries();
                line.Title = App.Current?.FindResource(ShakerConstant.ShowRandomAccelerationSpectrumNames[i]) + "";
                line.Color = oxyColors[i];
                line.StrokeThickness = 1;
                line.DataFieldX = nameof(SweepData.Frequency);
                line.DataFieldY = properties[i];
                line.LineStyle = lineStyles[i];
                line.XAxisKey = "Freq";
                line.YAxisKey = "Ampt";
                line.Tag = App.Current?.FindResource("RandomValueUnit")?.ToString() ?? string.Empty;
                LineSeries.Add(line);
                PlotModel.Series.Add(line);
            }
            PlotModel.Legends.Add(new OxyPlot.Legends.Legend()
            {
                ShowInvisibleSeries = true,
            });
            PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";
            #endregion

            GetEvent(ShakerSettingViewModel.LANGUAGECHANGEDEVENT).Subscrip((_, _) =>
            {
                PlotModel.InvalidatePlot(false);
                PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";
                PlotModel.Axes[0].Title = App.Current?.FindResource("Frequency") + "";
                PlotModel.Axes[1].Title = Title = App.Current?.FindResource("Ampt") + "";
                PlotModel.InvalidatePlot(true);
            });
            GetEvent<AllConfig>().Subscrip((_, _) =>
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent<RandomDataModel>()?.Subscrip((_, args) =>
                {
                    UpdateData(new List<IResultDataModel>() { args.Data });
                    CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<RandomDataModel>()?.Publish(this, args.Data);
                });
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(nameof(RandomDataModel.TransferFunction))?.Subscrip((sender, args) =>
                {
                    if (args.Data.Length > 0 && args.Data[0] is double[] func)
                    {
                        Tools.DispatherInovke.Inovke(()=> ShowTransferFunction(func));
                        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(nameof(RandomDataModel.TransferFunction))?.Publish(this, null, func);
                    }
                });
            });
        }
        private async void ShowTransferFunction(double[] data)
        {
            if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
            {
                RandomTransferFunctionViewModel.Instance.InitData();
                RandomTransferFunctionViewModel.Instance.InitTransferFunctionData(data);
                RandomTransferFunctionViewModel.Instance.Title = "TransferFunction";
                BaseDialogWindow window = new BaseDialogWindow();
                window.DataContext = RandomTransferFunctionViewModel.Instance;
                bool isclose = false;
                RandomTransferFunctionViewModel.Instance.CloseWindowAction = () =>
                {
                    if (isclose) return;
                    isclose = true;
                    window?.Close();
                };
                await window.ShowDialog(desktop.MainWindow!);
            }
        }
        static RandomMainPageViewModel()
        {

        }
        public override void InitUI()
        {

        }
        public ICommand NextLevelCommand => new RelayCommand(NextLevel);
        private async void NextLevel()
        {
            NextButtonIsEnabled = false;
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.RANDOMNEXTLEVEL)?.Publish(this);
            await Task.Delay(1000);
            NextButtonIsEnabled = true;
        }
        public override void SaveTdmsConfig(TDMS.ITDMSFile? config)
        {
            if (config == null) return;
            base.SaveTdmsConfig(config); 
            var group = config.Contains(nameof(RandomConfigModel)) ? config[nameof(RandomConfigModel)]:config.AddGroup(nameof(RandomConfigModel));
            if (group == null) return;
            typeof(RandomConfigModel).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
                .Select(x => (x, x.GetValue(RandomConfigViewModel.Instance.Model)))
                .ToList()
                .ForEach(x =>
                {
                    if (x.Item2 == null)
                    {
                        return;
                    }
                    if (x.x.FieldType.IsAssignableTo(typeof(IList)) || x.x.FieldType.IsArray)
                    {
                        group.CreateOrUpdateProperty($"{x.x.Name}", string.Join("", Tools.Tools.Serialize(x.x.FieldType, x.Item2).Select(x => $"{x:X2}")));
                    }
                    else
                    {
                        group.CreateOrUpdateProperty($"{x.x.Name}", x.Item2?.ToString() ?? string.Empty);
                    }
                });
        }
        public override void SaveTestData(TDMS.ITDMSFile? file)
        {
            if (file == null) return;
            base.SaveTestData(file);
            var group = file.Contains(SpectrumData) ? file[SpectrumData] : file.AddGroup(SpectrumData);
            if (group == null) return;
            var acc = ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs.Where(x => x.AnalogType == AnalogType.DivideAcceleration).ToArray();
            if(acc.Length>0)
            {
                for(int i=0;i<acc.Length;i++)
                {
                    var ch = group.Contains(acc[i].Name) ? group[acc[i].Name] : group.AddChannel(TDMS.Common.TDMSDataType.Double, acc[i].Name, App.Current?.FindResource("RandomValueUnit") + "");
                    ch?.AppendData(Model.CurrentAccelerationPSD[i]);
                }
            }

            {
                var ch = group.Contains("AccelerationSpectrum") ? group["AccelerationSpectrum"] : group.AddChannel(TDMS.Common.TDMSDataType.Double, "AccelerationSpectrum", App.Current?.FindResource("RandomValueUnit") + "");
                ch?.AppendData(Model.CurrentAccelerationSynthesisPSD);
            }
            {
                var dr = ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs.FirstOrDefault(x => x.AnalogType == AnalogType.GivenDriver);
                if (dr != null)
                {
                    var ch = group.Contains(dr.Name) ? group[dr.Name] : group.AddChannel(TDMS.Common.TDMSDataType.Double, dr.Name, App.Current?.FindResource("RandomValueUnit") + "");
                    ch?.AppendData(Model.DriverPSD);
                }
            }
        }
        public override bool Start()
        {
            SetRefSpectrum(RandomConfigViewModel.Instance.RefSpectrum);
            return true;
        }

        public override void Stop()
        {
        }
        public override void UpDateModel(RandomDataModel model)
        {
            if (RandomConfigViewModel.Instance.Model.PlanItems.Count > 0)
            {
                if (model.CurrentTestLevel == RandomConfigViewModel.Instance.Model.PlanItems[^1].Level)
                {
                    NextButtonIsEnabled = false;
                }
                else
                {
                    NextButtonIsEnabled = true;
                }
            }
            base.UpDateModel(model);
            int startindex = (int)(RandomConfigViewModel.Instance.MinFrequency / RandomConfigViewModel.Instance.FrequencyResolution);
            for(int i=0;i<datas.Count;i++)
            {
                datas[i].SetAcceleration(model.CurrentAccelerationSynthesisPSD[i + startindex]);
                datas[i].SetDriver(model.DriverPSD[i + startindex]);
            }
            PlotModel.InvalidatePlot(false);
            for(int i=0;i<LineSeries.Count;i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
            SaveSpectrumData();
        }

        private void SaveSpectrumData()
        {
            var file = ViewModels.ShakerDataViewModel.Instance.File;
            if (file == null) return;
            var group= file.Contains(SpectrumData) ? file[SpectrumData]:file.AddGroup(SpectrumData);
            if (group == null) return;

        }
        public override void UpdateData(List<IResultDataModel> model)
        {
            if(model !=null &&model.Count >0 && model.First() is RandomDataModel randomdata)
            {
                UpDateModel(randomdata);
            }
        }
        public void SetRefSpectrum(List<RandomData> data)
        {
            datas.Clear();
            datas.AddRange(data);
            PlotModel.InvalidatePlot(false);
            for (int i = 0; i < LineSeries.Count; i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
        }
        public override MainPageType PageType => MainPageType.RandomPage;

        public OxyPlot.PlotModel PlotModel { get; private set; } = new OxyPlot.PlotModel();
        public static RandomMainPageViewModel Instance { get; } = new RandomMainPageViewModel();
    }
}