ShakerControl/ShakerManger/ViewModel/ShakersViewModel.cs


using HandyControl.Interactivity;
using HandyControl.Interactivity.Commands;
using ShakerManger.Data;
using ShakerManger.ViewModel;
using SharpCompress.Compressors.Xz;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using System.Windows.Media;

namespace ShakerManger.ViewModel
{
    internal class ShakersViewModel:Shaker.ViewModel.DisplayViewModel<Shaker.Model.ModelBase>,IMainPageViewModel
    {
        private LayoutViewModel layout = new LayoutViewModel(2, 2);

        public ShakersViewModel()
        {
        }

        public LayoutViewModel Layout 
        { 
            get => layout;
            set
            {
                UpdateProperty(ref layout, value);
                if (LayoutShakers.Count > 0)
                {
                    if (value.ColumnCount == 1 && value.RowCount == 1)
                    {
                        for(int i=0;i<LayoutShakers.Count;i++)
                        {
                            LayoutShakers[i].IsMax = i==0;
                        }
                    }
                    else
                    {
                        for (int i = 0; i < LayoutShakers.Count; i++)
                        {
                            LayoutShakers[i].IsMax = false;
                        }
                    }
                }
            }
        }
        protected async override void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            base.OnPropertyChanged(propertyName);
            if(propertyName == nameof(IsSelected))
            {
                if (IsSelected)
                {
                    await Task.Delay(200);
                }
                foreach (var item in Shakers)
                {
                    item.IsSelected = IsSelected;
                }
            }
        }
        public override void Init()
        {
            base.Init();
            var shakers = Sql.Default.Find<Shaker.Model.ShakerControlModel>(x =>!string.IsNullOrEmpty(x.ClientID)).ToList();
            if(shakers ==null || shakers.Count ==0)
            {
                Tools.MessageBoxHelper.Error("没找到可用的振动台信息");
                App.Current.Shutdown();
                return;
            }
            MainWindowViewModel.Default.DataManger.Shakers.Clear();
            MainWindowViewModel.Default.LogManger.Shakers.Clear();
            MainWindowViewModel.Default.LogManger.Shakers.Add(new KeyValuePair<string, string>("全部","All"));
            MainWindowViewModel.Default.LogManger.SelectedShaker = MainWindowViewModel.Default.LogManger.Shakers.First().Value;

            MainWindowViewModel.Default.WarnManger.Shakers.Clear();
            MainWindowViewModel.Default.WarnManger.Shakers.Add(new KeyValuePair<string, string>("全部", "All"));
            MainWindowViewModel.Default.WarnManger.SelectedShaker = MainWindowViewModel.Default.WarnManger.Shakers.First().Value;

            shakers.ForEach(x =>
            {
                MainWindowViewModel.Default.DataManger.Shakers.Add(new KeyValuePair<string, string>(x.Description,x.Id));
                MainWindowViewModel.Default.LogManger.Shakers.Add(new KeyValuePair<string, string>(x.Description, x.Id));
                MainWindowViewModel.Default.WarnManger.Shakers.Add(new KeyValuePair<string, string>(x.Description, x.Id));
                Shakers.Add(new ShakerControlViewModel(x));
                LayoutShakers.Add(Shakers[^1]);
                LayoutShakers[^1].IsVisible = LayoutShakers.Count <= Layout.RowCount * Layout.ColumnCount;
            });
            MainWindowViewModel.Default.SystemConfig.ShakerPage.CurrentShaker = MainWindowViewModel.Default.Shakers.Shakers.First();
            MainWindowViewModel.Default.DataManger.SelectedShaker = MainWindowViewModel.Default.DataManger.Shakers.First().Value;
        }
        public ICommand MaxOrMinCommand => new DelegateCommand<ExCommandParameter>(MaxOrMin);
        [AllowNull]
        private LayoutViewModel lastlayout;
        private void MaxOrMin(ExCommandParameter parameter)
        {
            if(parameter.Parameter is ShakerControlViewModel shaker)
            {
                var tempshaker = Shakers.First(x => x.Model.Id == shaker.Model.Id);
                if(tempshaker.IsMax)
                {
                    LayoutShakers.Clear();
                    if (tempshakers.Count == 0)
                    {
                        foreach (var item in Shakers)
                        {
                            item.IsMax = false;
                            item.IsVisible = false;
                            LayoutShakers.Add(item);
                        }
                    }
                    else
                    {
                        tempshakers.ForEach(x =>
                        {
                            x.IsMax = false;
                            x.IsVisible = false;
                            LayoutShakers.Add(x);
                        });
                    }
                    if (lastlayout == null) lastlayout = new LayoutViewModel(2, 2);
                    MainWindowViewModel.Default.LayoutManger.Selected = MainWindowViewModel.Default.LayoutManger.Layouts.First(x => x.ColumnCount == lastlayout.ColumnCount && x.RowCount == lastlayout.RowCount);
                    Layout = MainWindowViewModel.Default.LayoutManger.Selected;
                }
                else
                {
                    tempshakers.Clear();
                    foreach (var item in LayoutShakers)
                    {
                        tempshakers.Add(item);
                        item.IsVisible = false;
                        item.IsMax = false;
                    }
                    LayoutShakers.Clear();
                    tempshaker.IsMax = true;
                    tempshaker.IsVisible = true;
                    LayoutShakers.Add(tempshaker);
                    lastlayout = new LayoutViewModel(Layout.RowCount, Layout.ColumnCount);
                    Layout = MainWindowViewModel.Default.LayoutManger.Layouts.First(x => x.ColumnCount == 1 && x.RowCount == 1);
                    MainWindowViewModel.Default.LayoutManger.Selected = Layout;
                }
            }
        }
        private List<ShakerControlViewModel> tempshakers = new List<ShakerControlViewModel>();
        private bool isEnabled = true;

        public ICommand AutoLayoutCommand => new DelegateCommand(AutoLayout);
        private void AutoLayout()
        {
            MainWindowViewModel.Default.LayoutManger.Selected = MainWindowViewModel.Default.LayoutManger.Layouts.First(x => x.ColumnCount == 2 && x.RowCount == 2);
            Layout = MainWindowViewModel.Default.LayoutManger.Selected;
            LayoutShakers.Clear();
            foreach (var item in Shakers)
            {
                LayoutShakers.Add(item);
                item.IsVisible = LayoutShakers.Count <= Layout.ColumnCount * Layout.RowCount;
            }
        }
        public ICommand SelectShakerCommand => new DelegateCommand<ExCommandParameter>(SelectShaker);
        private void SelectShaker(ExCommandParameter parameter)
        {
            if (parameter.Parameter is ShakerControlViewModel shaker)
            {
                ShakerSelectInfos.Clear();
                for (int i = 0; i < MainWindowViewModel.Default.Shakers.Shakers.Count; i++)
                {
                    var model = MainWindowViewModel.Default.Shakers.Shakers[i].Model;

                    ShakerSelectInfos.Add(new ShakerSelectInfoViewModel(i,model.Id)
                    {
                        Name = model.Description,
                        IsEnble = model.Id != shaker.Model.Id,
                    });
                    if (!ShakerSelectInfos[^1].IsEnble)
                    {
                        SelectedInfo = ShakerSelectInfos[^1];
                    }
                }
                SelectedIsOpen = true;
            }
        }

        public bool SelectedIsOpen { get => selectedIsOpen; set => UpdateProperty(ref selectedIsOpen, value); }


        public ICommand StartCommand => new DelegateCommand(Start);
        public ICommand StopCommand =>new DelegateCommand(Stop);
        public ICommand ResetCommand=>new DelegateCommand(Reset);

        public ICommand CoolingWaterStartCommand => new DelegateCommand(CoolingWaterStart);
        public ICommand CoolingWaterStopCommand => new DelegateCommand(CoolingWaterStop);
        public ICommand CoolingWaterResetCommand => new DelegateCommand(CoolingWaterReset);
        public ICommand GainSwitchCommand => new DelegateCommand<ExCommandParameter>(GainSwitch);
        public ICommand OpenCommand => new DelegateCommand(() =>
        {
            GainSwitch(new ExCommandParameter()
            {
                Parameter = true,
            });
        });
        public ICommand CloseCommand => new DelegateCommand(() =>
        {
            GainSwitch(new ExCommandParameter()
            {
                Parameter = false,
            });
        });
        private void GainSwitch(ExCommandParameter parameter)
        {
            if(parameter.Parameter is bool value)
            {
                foreach (var val in Shakers)
                {
                    if (!val.IsConnected || !val.IsDeviceControl) continue;
                    val.GainSwitchControlNoResult(value);
                }
            }
        }
        public short Gain
        {
            get => gain;
            set
            {
                UpdateProperty(ref gain, value);
                foreach (var val in Shakers)
                {
                    if (!val.IsConnected || !val.IsDeviceControl) continue;
                    val.SetGainNoResult(value);
                }
            }
        }
        private void Start()
        {
            foreach(var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl) continue;
                val.StartNoResult();
            }
        }

        private void Stop()
        {
            foreach (var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl) continue;
                val.StopNoResult();
            }
        }
        private void Reset()
        {
            foreach (var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl) continue;
                val.ResetNoResult();
            }
        }

        private void CoolingWaterStart()
        {
            foreach (var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl || !val.AllowCoolingWater) continue;
                val.CoolingWaterStartNoResult();
            }
        }

        private void CoolingWaterStop()
        {
            foreach (var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl || !val.AllowCoolingWater) continue;
                val.CoolingWaterStopNoResult();
            }
        }
        private void CoolingWaterReset()
        {
            foreach (var val in Shakers)
            {
                if (!val.IsConnected || !val.IsDeviceControl || !val.AllowCoolingWater) continue;
                val.CoolingWaterResetNoResult();
            }
        }
        private bool selectedIsOpen = false;

        private ShakerSelectInfoViewModel? selectedInfo = null;
        private short gain = 0;

        public ShakerSelectInfoViewModel? SelectedInfo
        {
            get => selectedInfo;
            set
            {
                if(selectedInfo ==null)
                {
                    UpdateProperty(ref selectedInfo, value);
                    SelectedIsOpen = false;
                    return;
                }
                if(value ==null)
                {
                    UpdateProperty(ref selectedInfo, value);
                    SelectedIsOpen = false;
                    return;
                }
                if (SelectedIsOpen)
                {

                    int index = -1;
                    for (int i = 0; i < LayoutShakers.Count; i++)
                    {
                        if (LayoutShakers[i].Model.Id == value.Id)
                        {
                            index = i;
                            break;
                        }
                    }
                    if (index == -1) return;
                    var shaker = Shakers[selectedInfo.ShakerIndex];
                    var tempshaker = LayoutShakers[index];
                    int srcindex = -1;
                    for (int i = 0; i < LayoutShakers.Count; i++)
                    {
                        if (LayoutShakers[i].Name == shaker.Name)
                        {
                            srcindex = i;
                            break;
                        }
                    }
                    LayoutShakers[index] = shaker;
                    if (srcindex >= 0)
                    {
                        LayoutShakers[srcindex] = tempshaker;
                    }
                    UpdateProperty(ref selectedInfo, value);
                    SelectedIsOpen = false;
                }
            }
        }
        public bool IsSelected { get; set; }
        public Data.MainPageType MainPageType => Data.MainPageType.ShakerManger;

        public string IconPath { get; } = (string)App.Current.FindResource("ShakerIcon");
        public override Type View { get; } = (typeof(View.ShakersView));
        public ObservableCollection<ShakerSelectInfoViewModel> ShakerSelectInfos { get; } = new ObservableCollection<ShakerSelectInfoViewModel>();
        /// <summary>
        /// 布局用，根据布局的变化会自动变化
        /// </summary>
        public ObservableCollection<ViewModel.ShakerControlViewModel> LayoutShakers { get; } = new ObservableCollection<ShakerControlViewModel>();
        public ObservableCollection<ViewModel.ShakerControlViewModel> Shakers { get; } = new ObservableCollection<ShakerControlViewModel>();

        public bool IsEnabled { get => isEnabled; set =>UpdateProperty(ref isEnabled, value); }
    }
}