Shaker/Avalonia/ShakerApp/ViewModels/ShakerConfig/ShakerConfigViewModel.cs

using Avalonia.Collections;
using Shaker.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ShakerApp.ViewModels
{
    internal class ShakerConfigViewModel : ViewModelBase<Shaker.Models.ShakerConfigModel>
    {
        public AccelerationSynthesisType SynthesisType { get => Model.SynthesisType; set => SetProperty(ref Model.SynthesisType, value); }
        public float OutSignalGain { get => Model.OutSignalGain; set => SetProperty(ref Model.OutSignalGain, value); }
        public override bool CanResize => false;
        public override double Width => 960;
        public override double Height => 560;
        public uint MaxRiseCount => Model.MaxRiseCount;
        public uint MaxZeroChangedCount => Model.MaxZeroChangedCount;
        public uint MaxSignalCount => Model.MaxSignalCount;
        public uint MaxEmergencyStopCount => Model.MaxEmergencyStopCount;
        public uint MaxStopWindowCount => MaxStopWindowCount;
        public uint MaxAdjustCount => Model.MaxAdjustCount;
        public uint MaxFallCount => Model.MaxFallCount;
        public uint StartCount => Model.StartCount;
        public float InitialLocation { get => Model.InitialLocation; set => SetProperty(ref Model.InitialLocation, value); }
        public uint SampleRate => Model.SampleRate;
        public uint FPGAClock => Model.FPGAClock;
        public int ChannelCount => Model.AnalogSignalConfigs.Count;
        public float MaxFrequency { get => Model.MaxFrequency; set => SetProperty(ref Model.MaxFrequency, value); }
        public float MinFrequency { get => Model.MinFrequency; set => SetProperty(ref Model.MinFrequency, value); }

        public float MaxOutInput { get => Model.MaxOutInput; set => SetProperty(ref Model.MaxOutInput, value); }
        public float MaxAcceleration { get => Model.MaxAcceleration; set => SetProperty(ref Model.MaxAcceleration, value); }
        public float MaxDisplacement { get => Model.MaxDisplacement; set => SetProperty(ref Model.MaxDisplacement, value); }
        public float MaxDriver { get => Model.MaxDriver; set => SetProperty(ref Model.MaxDriver, value); }
        public float MaxJitterAcceleration { get => Model.MaxJitterAcceleration; set => SetProperty(ref Model.MaxJitterAcceleration, value); }
        public float MaxJitterDisplacement { get => Model.MaxJitterDisplacement; set => SetProperty(ref Model.MaxJitterDisplacement, value); }
        public float MaxVelocity { get => Model.MaxVelocity; set => SetProperty(ref Model.MaxVelocity, value); }
        public int AccelerationSensorCount => Model.AccelerationConfigs.Count;
        public AvaloniaList<IndexValueItemViewModel<AnalogSignalConfigViewModel>> AnalogSignals { get; } = new AvaloniaList<IndexValueItemViewModel<AnalogSignalConfigViewModel>>();
        public AvaloniaList<IndexValueItemViewModel<AccelerationConfigViewModel>> Accelerations { get; } = new AvaloniaList<IndexValueItemViewModel<AccelerationConfigViewModel>>();
        public float DisplacementSensitivity { get => Model.DisplacementSensitivity; set => SetProperty(ref Model.DisplacementSensitivity, value); }
        private ShakerConfigViewModel()
        {
            
            Content = typeof(Views.ShakerConfigView);
            for(int i=0;i<Model.AccelerationConfigs.Count;i++)
            {
                Accelerations.Add(new IndexValueItemViewModel<AccelerationConfigViewModel>(i + 1,new AccelerationConfigViewModel(Model.AccelerationConfigs[i])));
                Accelerations[^1].Value.PropertyChanged += (sender, args) =>
                {
                    SaveIsEnabled = true;
                };
            }
            for(int i=0;i<Model.AnalogSignalConfigs.Count;i++)
            {
                AnalogSignals.Add(new IndexValueItemViewModel<AnalogSignalConfigViewModel>(i + 1, new AnalogSignalConfigViewModel(Model.AnalogSignalConfigs[i])));
            }
            GetEvent<AllConfig>().Subscrip((sender, args) =>
            {
                UpDateModel(args.Data.ShakerConfig);
                if(CommunicationViewModel.Intance.ServiceIsStart)
                {
                    CommunicationViewModel.Intance.ServiceCommunication.GetEvent<Shaker.Models.ShakerConfigModel>().Publish(this, args.Data.ShakerConfig);
                }
                CommunicationViewModel.Intance.LocalCommunication?.GetEvent<Shaker.Models.ShakerConfigModel>()?.Subscrip((sender, args) =>
                {
                    if (args.Data == null) return;
                    UpDateModel(args.Data);
                    CommunicationViewModel.Intance.ServiceCommunication?.GetEvent<Shaker.Models.ShakerConfigModel>()?.Publish(this, args.Data);
                });
            });
        }
        static ShakerConfigViewModel()
        {

        }
        public override void UpDateModel(Shaker.Models.ShakerConfigModel model)
        {
            base.UpDateModel(model);
            Accelerations.Clear();
            for(int i=0;i<model.AccelerationConfigs.Count;i++)
            {
                Accelerations.Add(new IndexValueItemViewModel<AccelerationConfigViewModel>(i + 1, new AccelerationConfigViewModel(model.AccelerationConfigs[i])));
                Accelerations[^1].Value.PropertyChanged += (sender, args) =>
                {
                    SaveIsEnabled = true;
                };
            }
            AnalogSignals.Clear();
            for(int i=0;i<model.AnalogSignalConfigs.Count;i++)
            {
                AnalogSignals.Add(new IndexValueItemViewModel<AnalogSignalConfigViewModel>(i + 1, new AnalogSignalConfigViewModel(model.AnalogSignalConfigs[i])));
            }
        }
        public static ShakerConfigViewModel Instance { get; } = new ShakerConfigViewModel();
        protected override void Save()
        {
            base.Save();
            CommunicationViewModel.Intance.LocalCommunication?.GetEvent<Shaker.Models.ShakerConfigModel>()?.Publish(this, Model);
            CommunicationViewModel.Intance.ServiceCommunication?.GetEvent<Shaker.Models.ShakerConfigModel>()?.Publish(this, Model);
        }
    }
}