using Shaker.Model;
using Shaker.Models;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace ShakerApp.ViewModels
{
    public class ShakerControlViewModel : ViewModelBase<ShakerControlModel>
    {
        public override bool CanResize => false;
        public override double Width => 960;
        public override double Height => 560;
        public static ShakerControlViewModel Instance { get; } = new ShakerControlViewModel();
        static ShakerControlViewModel()
        {

        }
        private ShakerControlViewModel()
        {
            for (int i = 0; i < ServoValveCount; i++)
            {
                ValveConfig.Add(new IndexValueItemViewModel<ValveConfigItemViewModel>(i + 1, new ValveConfigItemViewModel(Model.ValveConfig[i])));
            }
            ControlItems.CollectionChanged += (sender, args) =>
            {
                switch (args.Action)
                {
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                        OnPropertyChanged(nameof(AddEnabled));
                        OnPropertyChanged(nameof(RemoveEnabled));
                        break;
                }
                Model.ControlItems = ControlItems.Select(x => x.Value.Model).ToList();
            };
            ValveConfig.CollectionChanged += (_, _) =>
            {
                Model.ValveConfig = ValveConfig.Select(x => x.Value.Model).ToList();
            };
            GetEvent<AllConfig>().Subscrip((sender, args) =>
            {
                UpDateModel(args.Data.ShakerControl);
                if(CommunicationViewModel.Intance.ServiceIsStart)
                {
                    CommunicationViewModel.Intance.ServiceCommunication.GetEvent<ShakerControlModel>().Publish(this, args.Data.ShakerControl);
                }
                CommunicationViewModel.Intance.LocalCommunication?.GetEvent<ShakerControlModel>()?.Subscrip((sender, args) =>
                {
                    UpDateModel(args.Data);
                    CommunicationViewModel.Intance.ServiceCommunication?.GetEvent<ShakerControlModel>()?.Publish(this, args.Data);
                });
            });
        }
        public override void UpDateModel(ShakerControlModel model)
        {
            base.UpDateModel(model);

            ValveConfig.Clear();
            for(int i=0;i<model.ValveConfig.Count;i++)
            {
                ValveConfig.Add(new IndexValueItemViewModel<ValveConfigItemViewModel>(i + 1, new ValveConfigItemViewModel(model.ValveConfig[i])));
            }
            if (model.ControlItems == null)
            {
                model.ControlItems = new List<SweepControlItemModel>();
            }
            var items = model.ControlItems.ToArray();
            ControlItems.Clear();
            if (items.Length > 0)
            {
                for (int i = 0; i < model.ControlItems.Count; i++)
                {
                    ControlItems.Add(new IndexValueItemViewModel<SweepControlItemViewModel>(i + 1, new SweepControlItemViewModel(items[i])));
                }
            }
        }
        public MainPageType PageType { get => Model.PageType; set => SetProperty(ref Model.PageType, value); }
        public int MaxControlItemCount => Model.MaxControlItemCount;
        public float MaxDisplacementVoltage => Model.MaxDisplacementVoltage;
        public float MinDisplacementVoltage => Model.MinDisplacementVoltage;
        public float MaxValveVoltage => Model.MaxValveVoltage;
        public float MinValveVoltage => Model.MinValveVoltage;
        public Polarity ValvePolarity { get => Model.ValvePolarity; set => SetProperty(ref Model.ValvePolarity, value); }
        public bool SelfLoop { get => Model.SelfLoop; set => SetProperty(ref Model.SelfLoop, value); }
        public bool Debug { get => Model.Debug; set => SetProperty(ref Model.SelfLoop, value); }
        public float DisplacementP { get => Model.DisplacementP; set => SetProperty(ref Model.DisplacementP, value); }
        public float DisplacementI { get => Model.DisplacementI; set => SetProperty(ref Model.DisplacementI, value); }
        public float FlutterFrequency { get => Model.FlutterFrequency; set => SetProperty(ref Model.FlutterFrequency, value); }
        public float FlutterAmpt { get => Model.FlutterAmpt; set => SetProperty(ref Model.FlutterAmpt, value); }
        public int ServoValveCount => Model.ValveConfig.Count;
        public float MaxDisplacementIntegral { get => Model.MaxDisplacementIntegral; set => SetProperty(ref Model.MaxDisplacementIntegral, value); }
        public float DisplacementBias { get => Model.DisplacementBias; set => SetProperty(ref Model.DisplacementBias, value); }
        public ObservableCollection<IndexValueItemViewModel<ValveConfigItemViewModel>> ValveConfig { get; } = new ObservableCollection<IndexValueItemViewModel<ValveConfigItemViewModel>>();
        public bool OilStopped { get => Model.OilStopped; set => SetProperty(ref Model.OilStopped, value); }
        public bool DisplacementOpenLoop { get => Model.DisplacementOpenLoop; set => SetProperty(ref Model.DisplacementOpenLoop, value); }
        public ObservableCollection<IndexValueItemViewModel<SweepControlItemViewModel>> ControlItems { get; } = new ObservableCollection<IndexValueItemViewModel<SweepControlItemViewModel>>();
        public bool OutSignal { get => Model.OutSignal; set => SetProperty(ref Model.OutSignal, value); }
        public bool AddEnabled => ControlItems.Count < SweepFreqConfigModel.MAXITEM;
        public bool RemoveEnabled => ControlItems.Count > 0;
        public ICommand AddCommand => new CommunityToolkit.Mvvm.Input.RelayCommand(Add);
        private void Add()
        {
            if (ControlItems.Count >= MaxControlItemCount) return;
            ControlItems.Add(new IndexValueItemViewModel<SweepControlItemViewModel>(ControlItems.Count + 1, new SweepControlItemViewModel()));
        }
        public ICommand DeleteLastCommand => new CommunityToolkit.Mvvm.Input.RelayCommand(Delete);
        private void Delete()
        {
            if (ControlItems.Count == 0) return;
            ControlItems.RemoveAt(ControlItems.Count - 1);
        }
        public ICommand RefreshCommand => new CommunityToolkit.Mvvm.Input.RelayCommand(Refresh);
        private void Refresh()
        {
            if (ControlItems.Count == 0) return;
            var items = ControlItems.OrderBy(x => x.Value.Frequency).DistinctBy(x => x.Value.Frequency).Select(x => x.Value).ToList();
            if (items.Count == 0)
            {
                ControlItems.Clear();
                return;
            }
            for (int i = 0; i < items.Count; i++)
            {
                ControlItems[i].Value = items[i];
            }
            if (ControlItems.Count > items.Count)
            {
                int removecount = ControlItems.Count - items.Count;
                for (int i = 0; i < removecount; i++)
                {
                    ControlItems.RemoveAt(items.Count);
                }
            }
        }
        protected override void Save()
        {
            base.Save();
            CommunicationViewModel.Intance.LocalCommunication?.GetEvent<ShakerControlModel>()?.Publish(this, Model);
            CommunicationViewModel.Intance.ServiceCommunication?.GetEvent<ShakerControlModel>()?.Publish(this, Model);
        }
    }
}