PunkHPX8/PunkHPX8_MainPages/ViewModels/RobotCycleViewModel.cs

using Aitex.Core.UI.MVVM;
using Aitex.Sorter.Common;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.ControlDataContext;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using Newtonsoft.Json;
using OpenSEMI.ClientBase.Command;
using Prism.Mvvm;
using PunkHPX8_Core;
using PunkHPX8_MainPages.Roles;
using PunkHPX8_MainPages.Views;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using System.Windows.Input;
using System.Windows.Threading;

namespace PunkHPX8_MainPages.ViewModels
{
    public class RobotCycleViewModel : BindableBase
    {

        #region 内部变量
        /// <summary>
        /// 输入的Cycle次数
        /// </summary>
        private int _inPutCycleTimes = 1;
        /// <summary>
        /// Aligner旋转的角度
        /// </summary>
        private int _alignerAngle = 0;
        /// <summary>
        /// 当前正在执行第几次Cycle
        /// </summary>
        private int _currentCycle;
        /// <summary>
        /// 是否可以输入参数
        /// </summary>
        private bool _isInputParameterEnable;
        /// <summary>
        /// 当前正在执行哪一步
        /// </summary>
        private string _currentStep;
        #region 系统数据
        /// <summary>
        /// 定时器
        /// </summary>
        DispatcherTimer _timer;
        /// <summary>
        /// 查询后台数据集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// rt查询key数值字典
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        #endregion
        #endregion

        #region 属性

        public int InPutCycleTimes
        {
            get { return _inPutCycleTimes; }
            set { SetProperty(ref _inPutCycleTimes, value); }
        }
        public int AlignerAngle
        {
            get { return _alignerAngle; }
            set { SetProperty(ref _alignerAngle, value); }
        }
        public int CurrentCycle
        {
            get { return _currentCycle; }
            set { SetProperty(ref _currentCycle, value); }
        }
        public string CurrentStep
        {
            get { return _currentStep; }
            set { SetProperty(ref _currentStep, value); }
        }
        public bool IsInputParameterEnable
        {
            get { return _isInputParameterEnable; }
            set { SetProperty(ref _isInputParameterEnable, value); }
        }

        #endregion

        public class PositionItem : INotifyPropertyChanged
        {
            private string _destination;
            public string ModuleType { get; set; }
            public ModuleName ModuleName { get; set; }
            public string Parameter { get; set; }
            public Hand RobotHand { get; set; }
            public Flip PickRobotFlip { get; set; }
            public Flip PlaceRobotFlip { get; set; }
            public string Destination {
                get => _destination;
                set
                {
                    _destination = value;
                    OnPropertyChanged(nameof(Destination)); // 触发通知
                }
            }

            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged(string propertyName)
                => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        private ObservableCollection<PositionItem> _positions = new ObservableCollection<PositionItem>();
        public ObservableCollection<PositionItem> Positions
        {
            get { return _positions; }
            set { SetProperty(ref _positions, value); }
        }

        public ObservableCollection<string> PositionTypes { get; } = new ObservableCollection<string>
        {
                "LP", "Aligner", "Dummy", "SRD", "VPW","PlatingCell"
        };

        public ObservableCollection<string> HandsTypes { get; } = new ObservableCollection<string>
        {
                "Blade1", "Blade2"
        };
        public ObservableCollection<string> FlipTypes { get; } = new ObservableCollection<string>
        {
                "Upper", "Down"
        };

        private string _selectedPositionType;
        public string SelectedPositionType
        {
            get { return _selectedPositionType; }
            set
            {
                SetProperty(ref _selectedPositionType, value);
                UpdateAvailableSelections();
            }

        }

        public ObservableCollection<ModuleName> AvailableSelections { get; } = new ObservableCollection<ModuleName>();

        private ModuleName _selectedSelection;
        public ModuleName SelectedSelection
        {
            get { return _selectedSelection; }
            set { SetProperty(ref _selectedSelection, value); }
        }

        private string _parameter;
        public string Parameter
        {
            get { return _parameter; }
            set { SetProperty(ref _parameter, value); }
        }

        private Hand _robotHand;
        public Hand RobotHand
        {
            get { return _robotHand; }
            set { SetProperty(ref _robotHand, value); }
        }

        private Flip _pickRobotFlip;
        public Flip PickRobotFlip
        {
            get { return _pickRobotFlip; }
            set { SetProperty(ref _pickRobotFlip, value); }
        }

        private Flip _placeRobotFlip;
        public Flip PlaceRobotFlip
        {
            get { return _placeRobotFlip; }
            set { SetProperty(ref _placeRobotFlip, value); }
        }

        #region 命令

        public ICommand RobotCycleConfirmCommand { get; set; }
        
        public ICommand RobotCycleStartCommand { get; set; }

        public ICommand RobotCycleAbortCommand { get; set; }

        public ICommand AddPositionCommand { get; set; }

        public ICommand MoveUpCommand { get; set; }

        public ICommand MoveDownCommand { get; set; }

        public ICommand RemoveCommand { get; set; }
        #endregion
        /// <summary>
        /// 构造器
        /// </summary>
        public RobotCycleViewModel()
        {
            RobotCycleConfirmCommand = new DelegateCommand<object>(RobotCycleConfirmAction);
            RobotCycleStartCommand = new DelegateCommand<object>(RobotCycleStartAction);
            RobotCycleAbortCommand = new DelegateCommand<object>(RobotCycleAbortAction);

            AddPositionCommand = new DelegateCommand<object>(AddPosition);
            MoveUpCommand = new DelegateCommand<object>(MovePositionUp);
            MoveDownCommand = new DelegateCommand<object>(MovePositionDown);
            RemoveCommand = new DelegateCommand<object>(RemovePosition);
            SelectedPositionType = PositionTypes.FirstOrDefault();
            RobotHand = Hand.Blade1;
            PickRobotFlip = Flip.Upper;
            PlaceRobotFlip = Flip.Upper;
        }

        private void UpdateAvailableSelections()
        {
            AvailableSelections.Clear();
            switch (SelectedPositionType)
            {
                case "LP":
                    AvailableSelections.Add(ModuleName.LP1);
                    AvailableSelections.Add(ModuleName.LP2);
                    break;
                case "Aligner":
                    AvailableSelections.Add(ModuleName.Aligner1);
                    Parameter = "0"; // 默认角度
                    break;
                case "Dummy":
                    AvailableSelections.Add(ModuleName.Dummy1);
                    AvailableSelections.Add(ModuleName.Dummy2);
                    break;
                case "SRD":
                    AvailableSelections.Add(ModuleName.SRD1);
                    AvailableSelections.Add(ModuleName.SRD2);
                    break;
                case "VPW":
                    AvailableSelections.Add(ModuleName.VPW1);
                    AvailableSelections.Add(ModuleName.VPW2);
                    break;
                case "PlatingCell":
                    AvailableSelections.Add(ModuleName.PlatingCell1);
                    AvailableSelections.Add(ModuleName.PlatingCell2);
                    AvailableSelections.Add(ModuleName.PlatingCell3);
                    AvailableSelections.Add(ModuleName.PlatingCell4);
                    break;
            }
            SelectedSelection = AvailableSelections.FirstOrDefault();
            //RobotHand = Hand.Blade1;
            //PickRobotFlip = Flip.Upper;
            //PlaceRobotFlip = Flip.Upper;
        }

        private void AddPosition(object obj)
        {
            if ("Aligner".Equals(SelectedPositionType))  //目前就aligner的条目需要参数
            {
                Positions.Add(new PositionItem
                {
                    ModuleType = SelectedPositionType,
                    ModuleName = SelectedSelection,
                    Parameter = Parameter,
                    RobotHand = RobotHand,
                    PickRobotFlip = PickRobotFlip,
                    PlaceRobotFlip = PlaceRobotFlip
                });
            }
            else
            {
                Positions.Add(new PositionItem
                {
                    ModuleType = SelectedPositionType,
                    ModuleName = SelectedSelection,
                    RobotHand = RobotHand,
                    PickRobotFlip = PickRobotFlip,
                    PlaceRobotFlip = PlaceRobotFlip
                });
            }
            
        }

        private void MovePositionUp(object obj)
        {
            if (obj is PositionItem item)
            {
                int index = Positions.IndexOf(item);
                if (index > 0)
                {
                    Positions.Move(index, index - 1);
                }
            }
        }

        private void MovePositionDown(object obj)
        {
            if (obj is PositionItem item)
            {
                int index = Positions.IndexOf(item);
                if (index < Positions.Count - 1)
                {
                    Positions.Move(index, index + 1);
                }
            }
        }

        private void RemovePosition(object obj)
        {
            if (obj is PositionItem item)
            {
                Positions.Remove(item);
            }
        }
        private void RobotCycleConfirmAction(object param)
        {
            if(Positions.Count == 0)
            {
                return;
            }
            else if (Positions.Count == 1) 
            {
                Positions[0].Destination = Positions[0].ModuleName.ToString();
            }
            else
            {
                for (int i = 0; i < Positions.Count; i++)
                {
                    if(i < Positions.Count - 1)
                    {
                        Positions[i].Destination = Positions[i + 1].ModuleName.ToString();
                    }
                    else
                    {
                        Positions[i].Destination = Positions[0].ModuleName.ToString();
                    }  
                }
            }      
        }
        private void RobotCycleStartAction(object param)
        {
            List<RobotCycleParameter> parameters = new List<RobotCycleParameter>();
            foreach(var parameter in Positions) 
            {
                RobotCycleParameter robotCycleParameter = new RobotCycleParameter();
                robotCycleParameter.ModuleName = parameter.ModuleName;
                robotCycleParameter.RobotArm = parameter.RobotHand;
                robotCycleParameter.PickRobotFlip = parameter.PickRobotFlip;
                robotCycleParameter.PlaceRobotFlip = parameter.PlaceRobotFlip;
                robotCycleParameter.Parameter = parameter.Parameter;
                parameters.Add(robotCycleParameter);
            }
            InvokeClient.Instance.Service.DoOperation($"EFEM.{EfemOperation.RobotCycle}", JsonConvert.SerializeObject(parameters), InPutCycleTimes);
        }
        private void RobotCycleAbortAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.EfemRobot}.{EfemOperation.Abort}");
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadData(string systemName)
        {
            _rtDataKeys.Clear();
            _rtDataKeys.Add("EFEM.CurrentRobotCycleTime");
            _rtDataKeys.Add("EFEM.CurrentRobotCycleStep");
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200);
                _timer.Tick += Timer_Tick;
            }
            _timer.Start();
        }

        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
             
                
                IsInputParameterEnable = "Aligner".Equals(SelectedPositionType) ? true : false;
               
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    CurrentCycle = CommonFunction.GetValue<int>(_rtDataValueDic, $"EFEM.CurrentRobotCycleTime");
                    CurrentStep = CommonFunction.GetValue<string>(_rtDataValueDic, $"EFEM.CurrentRobotCycleStep");
                }

            }

        }
        /// <summary>
        /// 隐藏
        /// </summary>
        public void Hide()
        {

        }
    }
}