Shaker/Avalonia/ShakerApp/ViewModels/MainViewModel.cs

using Avalonia;
using Avalonia.Collections;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Controls.Documents;
using Avalonia.Media;
using Avalonia.Threading;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using FxpConvert.Common;
using Shaker.Models;
using ShakerApp.Tools;
using ShakerApp.ViewModels;
using SukiUI.Dialogs;
using SukiUI.Toasts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows.Input;

namespace ShakerApp.ViewModels;

public class MainViewModel : DisplayViewModelBase<IModel>
{
    public ICalc Calc { get; } = new SIMDFxpConvert.SIMDCalc();
    private AvaloniaDictionary<string, Window?> OpenedWindows = new AvaloniaDictionary<string, Window?>();
    private bool canDebug = false;

    private MainViewModel()
    {
#if DEBUG
        CanDebug = true;
#else
        CanDebug = false;
#endif
        GetEvent(ShakerSettingViewModel.LANGUAGECHANGEDEVENT).Subscrip((_, _) =>
        {
            OnPropertyChanged(nameof(Title));
        });
        GetEvent(Topic.DisConnect).Subscrip((_, _) =>
        {
            OnPropertyChanged(nameof(Title));
            OnPropertyChanged(nameof(TitleColor));
            CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.DisConnect)?.Publish(this);
        });
        CommunicationViewModel.Instance.PropertyChanged += (sender, args) =>
        {
            switch (args.PropertyName)
            {
                case nameof(CommunicationViewModel.LocalIsConnect):
                    OnPropertyChanged(nameof(TitleColor));
                    OnPropertyChanged(nameof(Title));
                    break;
            }
        };
        MainPageViewModel.Instance.PropertyChanged += (sender, args) =>
        {
            switch(args.PropertyName)
            {
                case nameof(MainPageViewModel.MainPageType):
                    OnPropertyChanged(nameof(Title));
                    break;
            }
        };
        this.GetType().Assembly.GetTypes()
            .Where(x => x.IsAnsiClass && !x.IsAbstract && x.IsAssignableTo(typeof(ObservableObject)))
            .ToList()
            .ForEach(x =>
            {
                var val = x.GetProperties(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)
                .FirstOrDefault(y => y.PropertyType == x);
                val?.GetValue(null);
            });

        List<(MethodInfo Method, string Key)> infos = this.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
            .Where(x => x.GetCustomAttribute<MenuClickAttribute>() != null)
            .Select(x =>
            {
                var att = x.GetCustomAttribute<MenuClickAttribute>();
                return (x, att!.Key);
            }).ToList();
        MenuViewModel.Instance.MenuClick += (menu) =>
        {
            if (menu == null) return;
            infos.FirstOrDefault(x => x.Key == menu.Header).Method?.Invoke(Default, new[] { menu.Header });
        };
    }
    static MainViewModel()
    {

    }
    public Avalonia.Media.IBrush TitleColor => CommunicationViewModel.Instance.LocalIsConnect ? Brushes.Black : Brushes.Black;
    public ICommand ExitCommand => new RelayCommand(()=>Exit(""));
    [MenuClick("MenuExit")]
    private void Exit(string? p)
    {
        ShowAsk(App.Current?.FindResource("PromptExitMsg")+"",()=>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOP)?.Publish(this, null);
            Environment.Exit(0);
        });
    }
    private string GetTitle()
    {
        string s = string.Empty;
        if(ViewModels.CommunicationViewModel.Instance.LocalIsConnect)
        {
            if(MainPageViewModel.Instance.MainPageType == MainPageType.StartPage)
            {
                s = $"{App.Current?.FindResource("Title")}-{ViewModels.DeviceMangerViewModel.Instance.CurrentDevice!.DeviceName}[{CommunicationViewModel.Instance.LocalCommunication.IP}:{CommunicationViewModel.Instance.LocalCommunication.Port}]";
            }
            else
            {
                s = $"{App.Current?.FindResource("Title")}-{ViewModels.DeviceMangerViewModel.Instance.CurrentDevice!.DeviceName}-[{App.Current?.FindResource(MainPageViewModel.Instance.MainPageType.Description())}]";
            }
        }
        else
        {
            s = App.Current?.FindResource("Title") + "-" + App.Current?.FindResource("Offline");
        }
        return s;
    }

    public ICommand DataReviewCommand =>new RelayCommand<string>(DataReview);
    private async void DataReview(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            SelectTestDataViewModel.Instance.InitData();
            SelectTestDataViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = SelectTestDataViewModel.Instance;
            DeviceMangerViewModel.Instance.CloseWindowAction = () => window?.Close();
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand ConnectCommand => new RelayCommand(Connect);
    private void Connect()
    {
        CommunicationViewModel.Instance.Connect(ViewModels.ShakerSettingViewModel.Instance.RemoteIP, ViewModels.ShakerSettingViewModel.Instance.RemotePort);
    }

    public override string Title => GetTitle();

    public bool CanDebug
    {
        get => canDebug;
        set
        {
            SetProperty(ref canDebug, value); 
            MenuViewModel.Instance["CanDebug"]!.IsVisible = value;
            MenuViewModel.Instance["MenuDebug"]!.IsVisible = value;
        }
    }


    public ICommand SettingCommand => new RelayCommand<string?>(Setting);
    private async void Setting(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            ShakerSettingViewModel.Instance.InitData();
            ShakerSettingViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = ShakerSettingViewModel.Instance;
           await window.ShowDialog(desktop.MainWindow!);
        }
    }

    public ICommand DeviceMangerCommand => new RelayCommand<string?>(DeviceManger);
    private async void DeviceManger(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            DeviceMangerViewModel.Instance.InitData();
            DeviceMangerViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = DeviceMangerViewModel.Instance;
            DeviceMangerViewModel.Instance.CloseWindowAction = () => window?.Close();
            await window.ShowDialog(desktop.MainWindow!);
        }
    }

    public ICommand SelectTestTypeCommand => new RelayCommand<MainPageType>(SelectTestType);

    private void SelectTestType(MainPageType type)
    {
        MainPageViewModel.Instance.MainPageType = type;
    }
    public ICommand SaveConfigCommand => new RelayCommand<string?>(SaveConfig);
    [MenuClick("MenuSaveConfig")]
    private async void SaveConfig(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            SaveConfigViewModel.Instance.InitData();
            SaveConfigViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = SaveConfigViewModel.Instance;
            DeviceMangerViewModel.Instance.CloseWindowAction = () => window?.Close();
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand SignalPreviewCommand=> new RelayCommand<string?>(SignalPreview);
    private void SignalPreview(string? p)
    {
        if (string.IsNullOrEmpty(p)) return;
        if (OpenedWindows.TryGetValue(p, out var w))
        {
            if (w != null && w.IsLoaded)
            {
                w.Activate();
                return;
            }
        }
        SignalPreviewViewModel.Instance.InitData();
        SignalPreviewViewModel.Instance.Title = p;
        BaseDialogWindow window = new BaseDialogWindow();
        window.DataContext = SignalPreviewViewModel.Instance;
        OpenedWindows[p] = window;
        SignalPreviewViewModel.Instance.CloseWindowAction = () =>
        {
            window?.Close();
            OpenedWindows[p] = null;
        };
        window.Show();
    }
    public ICommand LoadConfigCommand => new RelayCommand<string?>(LoadConfig);
    [MenuClick("MenuLoadConfig")]
    private async void LoadConfig(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            LoadConfigViewModel.Instance.InitData();
            LoadConfigViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = LoadConfigViewModel.Instance;
            DeviceMangerViewModel.Instance.CloseWindowAction = () => window?.Close();
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand ShakerConfigCommand => new RelayCommand<string?>(ShakerConfig);
    private async void ShakerConfig(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            ShakerConfigViewModel.Instance.InitData();
            ShakerConfigViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = ShakerConfigViewModel.Instance;
            ShakerConfigViewModel.Instance.CloseWindowAction = () => window?.Close();
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand OilControlCommand => new RelayCommand<string?>(OilControl);
    private void OilControl(string? p)
    {
        if (string.IsNullOrEmpty(p)) return;
        if(OpenedWindows.TryGetValue(p,out var w))
        {
            if(w!=null && w.IsLoaded)
            {
                w.Activate();
                return;
            }
        }
        OilSourceStatusViewModel.Instance.InitData();
        OilSourceStatusViewModel.Instance.Title = p;
        BaseDialogWindow window = new BaseDialogWindow();
        window.DataContext = OilSourceStatusViewModel.Instance;
        OpenedWindows[p] = window;
        OilSourceStatusViewModel.Instance.CloseWindowAction = () =>
        {
            window?.Close();
            OpenedWindows[p] = null;
        };
        window.Show();
    }

    public ICommand CloseCommand => new RelayCommand(Close);
    private void Close()
    {
        CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOP)?.Publish(this, null);
        Environment.Exit(0);
    }
    public ICommand DebugCommand => new RelayCommand<string?>(Debug);
    public async void Debug(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            InputPassWordViewModel.Instance.InitData();
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = InputPassWordViewModel.Instance;
            InputPassWordViewModel.Instance.CloseWindowAction = () => window?.Close();
            InputPassWordViewModel.Instance.InputAction = (pass) =>
            {
                window?.Close();
                if(pass != "123456")
                {
                    ToastManager.CreateSimpleInfoToast().WithTitle(App.Current?.FindResource("PromptTitle")+"").WithContent(App.Current?.FindResource("PassWordError") + "").Queue();
                    return;
                }
                ShowDebug(p);
            };
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    private async void ShowDebug(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            ShakerControlViewModel.Instance.InitData();
            ShakerControlViewModel.Instance.Title = p;
            ShakerControlViewModel.Instance.Content = typeof(Views.DebugView);
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = ShakerControlViewModel.Instance;
            ShakerControlViewModel.Instance.CloseWindowAction = () =>
            {
                window?.Close();
            };
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand UpbitfileCommand => new RelayCommand<string?>(Upbitfile);
    private void Upbitfile(string? p)
    {

    }
    public ICommand SweepConfigCommand => new RelayCommand<string?>(SweepConfig);
    private async void SweepConfig(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            SweepConfigViewModel.Instance.InitData();
            SweepConfigViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = SweepConfigViewModel.Instance;
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public void InitServiceMsg()
    {
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<string>(Topic.SERVICERESULT)?.Subscrip((_, _) => Topic.SERVICERESULT);
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<Shaker.Models.AllConfig>(Shaker.Models.Topic.SYNCCONFIG)?.Subscrip((_, _) =>
        {
            return new AllConfig()
            {
                OilSource = OilSourceStatusViewModel.Instance.Model,
                RandomConfig = RandomConfigViewModel.Instance.Model,
                ShakerConfig = ShakerConfigViewModel.Instance.Model,
                ShakerControl = ShakerControlViewModel.Instance.Model,
                ShakerStatus = ShakerStatusViewModel.Instance.Model,
                SweepConfig = SweepConfigViewModel.Instance.Model,
            };
        });


        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<ShakerConfigModel>()?.Subscrip((sender, args) =>
        {
            ShakerConfigViewModel.Instance.ReceiveServiceModel(args.Data);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<ShakerControlModel>()?.Subscrip((sender, args) =>
        {
            ShakerControlViewModel.Instance.ReceiveServiceModel(args.Data);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<SweepConfigModel>()?.Subscrip((sender, args) =>
        {
            SweepConfigViewModel.Instance.ReceiveServiceModel(args.Data);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<RandomConfigModel>()?.Subscrip((sender, args) =>
        {
            RandomConfigViewModel.Instance.ReceiveServiceModel(args.Data);
        });


        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<DeviceInfoModel?>()?.Publish(this, ViewModels.DeviceMangerViewModel.Instance.CurrentDevice?.Model);
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<RandomTestStep>()?.Subscrip((sender, args) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent<RandomTestStep>()?.Publish(this, args.Data);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<MainPageType>()?.Subscrip((sender, args) =>
        {
            MainPageViewModel.Instance.MainPageType = args.Data;
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent<MainPageType>()?.Publish(this, args.Data);
        });

        CommunicationViewModel.Instance.LocalCommunication?.GetEvent<MainPageType>()?.Subscrip((sender, args) =>
        {
            MainPageViewModel.Instance.MainPageType = args.Data;
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Shaker.Models.Topic.START)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.START)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.STARTRANDOMTEST)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STARTRANDOMTEST)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.STOP)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOP)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.RISETABLE)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.RISETABLE)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.ZEROCHANGE)?.Subscrip((_, e) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.ZEROCHANGE)?.Publish(this, null, e.Data[0]);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.DROPTABLE)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.DROPTABLE)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.STOPSIGNALGEN)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOPSIGNALGEN)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.VALVEPOWER)?.Subscrip((_, e) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOPSIGNALGEN)?.Publish(this, null, e.Data[0]);
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.STARTSIGNALGEN)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STARTSIGNALGEN)?.Publish(this);
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.RESETERROR)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.RESETERROR)?.Publish(this);
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CircuitPressure)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 2 && args.Data[0] is int index && args.Data[1] is float pressure)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CircuitPressure)?.Publish(this, null, index, pressure);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CircuitStart)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 2 && args.Data[0] is int index && args.Data[1] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CircuitStart)?.Publish(this, null, index, state);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CircuitLoad)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 2 && args.Data[0] is int index && args.Data[1] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CircuitLoad)?.Publish(this, null, index, state);
            }
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.ForerunnerPressure)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is float pressure)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.ForerunnerPressure)?.Publish(this, null, pressure);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.ForerunnerStart)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.ForerunnerStart)?.Publish(this, null, state);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.ForerunnerLoad)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.ForerunnerLoad)?.Publish(this, null, state);
            }
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.AssistantPressure)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is float pressure)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.AssistantPressure)?.Publish(this, null, pressure);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.AssistantStart)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.AssistantStart)?.Publish(this, null, state);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.AssistantLoad)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.AssistantLoad)?.Publish(this, null, state);
            }
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CirculatePressure)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is float pressure)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CirculatePressure)?.Publish(this, null, pressure);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CirculateStart)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CirculateStart)?.Publish(this, null, state);
            }
        });
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.CirculateLoad)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.CirculateLoad)?.Publish(this, null, state);
            }
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.OilEmergencyStop)?.Subscrip((sender, args) =>
        {
            if (args.Data.Length >= 1 && args.Data[0] is bool state)
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.OilEmergencyStop)?.Publish(this, null, state);
            }
        });

        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(Topic.RANDOMNEXTLEVEL)?.Subscrip((_, _) =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.RANDOMNEXTLEVEL)?.Publish(this);
        });
    }
    public ICommand RandomConfigCommand => new RelayCommand<string?>(RandomConfig);
    private async void RandomConfig(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            RandomConfigViewModel.Instance.InitData();
            RandomConfigViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = RandomConfigViewModel.Instance;
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand AboutCommand => new RelayCommand<string?>(About);
    private async void About(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            AboutViewModel.Instance.InitData();
            AboutViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = AboutViewModel.Instance;
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public ICommand DisConnectCommand => new RelayCommand(DisConnect);
    private void DisConnect()
    {
        ShowAsk(App.Current?.FindResource("AskDisconnect") + "", () =>
        {
            CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.STOP)?.Publish(this, null);
            CommunicationViewModel.Instance.DisConnect();
        });
    }
    public ICommand ShakerControlCommand => new RelayCommand<string?>(ShakerControl);
    private void ShakerControl(string? p)
    {
        if (string.IsNullOrEmpty(p)) return;
        if (OpenedWindows.TryGetValue(p, out var w))
        {
            if (w != null && w.IsLoaded)
            {
                w.Activate();
                return;
            }
        }
        ShakerStatusViewModel.Instance.InitData();
        ShakerStatusViewModel.Instance.Title = p;
        BaseDialogWindow window = new BaseDialogWindow();
        window.DataContext = ShakerStatusViewModel.Instance;
        OpenedWindows[p] = window;
        ShakerStatusViewModel.Instance.CloseWindowAction = () =>
        {
            window?.Close();
            OpenedWindows[p] = null;
        };
        window.Show();
    }
    public ICommand LogCommand =>new RelayCommand<string?>(Log);
    private async void Log(string? p)
    {
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && !string.IsNullOrEmpty(p))
        {
            LogViewModel.Instance.InitData();
            LogViewModel.Instance.Title = p;
            BaseDialogWindow window = new BaseDialogWindow();
            window.DataContext = LogViewModel.Instance;
            await window.ShowDialog(desktop.MainWindow!);
        }
    }
    public void SyncConfig()
    {
        LogViewModel.Instance.AddLog($"同步控制器设置参数");
        CommunicationViewModel.Instance.LocalCommunication?.GetEvent<DeviceInfoModel?>()?.Subscrip((sender, args) =>
        {
            if (args.Data == null)
            {
                DeviceMangerViewModel.Instance.CurrentDevice = null;
            }
            else
            {
                if (DeviceMangerViewModel.Instance.CurrentDevice == null) DeviceMangerViewModel.Instance.CurrentDevice = new DeviceInfoViewModel();
                DeviceMangerViewModel.Instance.CurrentDevice.UpDateModel(args.Data);
            }
        });
        var config= CommunicationViewModel.Instance.LocalCommunication?.GetEvent<Shaker.Models.AllConfig>(Shaker.Models.Topic.SYNCCONFIG)?.Publish(this);
        if(config ==null)
        {
            LogViewModel.Instance.AddLog($"同步控制器设置参数失败", LogType.Error);
            base.ToastManager.CreateSimpleInfoToast()
                .WithTitle(App.Current?.FindResource("PromptTitle") + "")
                .WithContent(App.Current?.FindResource("GetConfigError")+"")
                .Queue();
            CommunicationViewModel.Instance.LocalCommunication?.Close();
            return;
        }
        LogViewModel.Instance.AddLog($"同步控制器设置参数成功");
        GetEvent<AllConfig>().Publish(this, config);
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<AllConfig>(Topic.SYNCCONFIG)?.Publish(this,null, config);
        CommunicationViewModel.Instance.LocalCommunication?.GetEvent(Topic.START)?.Publish(this);
        OnPropertyChanged(nameof(Title));
        OnPropertyChanged(nameof(TitleColor));
        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<DeviceInfoModel?>()?.Publish(this, DeviceMangerViewModel.Instance.CurrentDevice?.Model);

    }
    public static MainViewModel Default { get; } = new MainViewModel();

}