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.Runtime.CompilerServices;
using System.Windows.Input;

namespace ShakerApp.ViewModels;

public class MainViewModel : ViewModelBase<IModel>
{
    private bool isMenuVisible = true;
    public bool IsMenuVisible { get => isMenuVisible; set => SetProperty(ref isMenuVisible, value); }
    public AvaloniaList<MenuItemViewModel> Menus { get; } = new AvaloniaList<MenuItemViewModel>();
    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));
        });
        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);
            });
    }
    static MainViewModel()
    {

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

    public override string Title => GetTitle();

    public bool CanDebug { get => canDebug; set =>SetProperty(ref canDebug, 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);
    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);
    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.Intance.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 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.Intance.LocalCommunication?.GetEvent(Topic.STOP).Publish(this, null);
            CommunicationViewModel.Intance.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($"同步控制器设置参数");
        var config= CommunicationViewModel.Intance.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.Intance.LocalCommunication.Close();
            return;
        }
        LogViewModel.Instance.AddLog($"同步控制器设置参数成功");
        GetEvent<AllConfig>().Publish(this, config);
        CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.START).Publish(this);
        OnPropertyChanged(nameof(Title));
        OnPropertyChanged(nameof(TitleColor));
    }
    public static MainViewModel Default { get; } = new MainViewModel();

}